Create Certificate Program
Get Certificate Programs
Register Student
Grant Certificate
View Student Certificate
{output}
Form requires: {invalidInputs.join(', ')}
InitializeLeaderboard
```rust
leaderboard: Account<'info, Leaderboard>,
game_owner: Signer<'info>,
system_program: Program<'info, System>,
```
NewGame
```rust
user: Signer<'info>,
game_owner: AccountInfo<'info>,
leaderboard: Account<'info, Leaderboard>,
system_program: Program<'info, System>,
```
AddPlayerToLeaderboard
```rust
leaderboard: Account<'info, Leaderboard>,
user: Signer<'info>,
```
Leaderboard
```rust
players: VecPlayer
```rust
username: String, // max length 32
pubkey: Pubkey,
score: u64,
has_payed: bool,
```
| Decimals | Smallest Token Unit |
| :------: | :-----------------: |
| 0 | 1 |
| 1 | 0.1 |
| ... | ... |
| 9 | 0.000000001 |
### --tests--
You should import `createMint` from `@solana/spl-token`.
```js
const importDeclaration = babelisedCode.getImportDeclarations().find(i => {
return i.source.value === '@solana/spl-token';
});
assert.exists(
importDeclaration,
'An import from `@solana/spl-token` should exist'
);
const importSpecifiers = importDeclaration.specifiers.map(s => s.imported.name);
assert.include(
importSpecifiers,
'createMint',
'`createMint` should be imported from `@solana/spl-token`'
);
```
You should have `const mint = await createMint(connection, payer, mintAuthority, freezeAuthority, 9);` in `create-mint-account.js`.
```js
const mintDeclaration = babelisedCode.getVariableDeclarations().find(v => {
return v.declarations?.[0]?.id?.name === 'mint';
});
assert.exists(mintDeclaration, 'A variable named `mint` should exist');
const mintAwaitExpression = mintDeclaration.declarations?.[0]?.init;
assert.equal(
mintAwaitExpression.type,
'AwaitExpression',
'The `createMint` call should be awaited'
);
const createMintCallExpression = mintAwaitExpression.argument;
assert.equal(
createMintCallExpression.callee.name,
'createMint',
'The `mint` variable should be initialised with the `createMint` function'
);
const createMintArguments = createMintCallExpression.arguments;
assert.equal(
createMintArguments.length,
5,
'The `createMint` function should be called with 5 arguments'
);
const [
connectionArgument,
payerArgument,
mintAuthorityArgument,
freezeAuthorityArgument,
decimalsArgument
] = createMintArguments;
assert.equal(
connectionArgument.name,
'connection',
'The first argument to `createMint` should be `connection`'
);
assert.equal(
payerArgument.name,
'payer',
'The second argument to `createMint` should be `payer`'
);
assert.equal(
mintAuthorityArgument.name,
'mintAuthority',
'The third argument to `createMint` should be `mintAuthority`'
);
assert.equal(
freezeAuthorityArgument.name,
'freezeAuthority',
'The fourth argument to `createMint` should be `freezeAuthority`'
);
assert.equal(
decimalsArgument.value,
9,
'The fifth argument to `createMint` should be `9`'
);
```
### --before-all--
```js
const codeString = await __helpers.getFile(
'learn-solanas-token-program-by-minting-a-fungible-token/create-mint-account.js'
);
const babelisedCode = new __helpers.Babeliser(codeString);
global.babelisedCode = babelisedCode;
```
### --after-all--
```js
delete global.babelisedCode;
```
### --seed--
#### --"create-mint-account.js"--
```js
import { Connection } from '@solana/web3.js';
import { payer } from './utils.js';
const connection = new Connection('http://localhost:8899');
const mintAuthority = payer.publicKey;
const freezeAuthority = payer.publicKey;
```
## 10
### --description--
The `createMint` function returns the public key of the newly-created Mint Account.
Log the base-58 representation of `mint` to the console.
### --tests--
You should use the `toBase58` method on `mint`.
```js
const mintMemberExpression = babelisedCode
.getType('MemberExpression')
.find(m => {
return m.object?.name === 'mint' && m.property?.name === 'toBase58';
});
assert.exists(
mintMemberExpression,
'The `mint` variable should have a `toBase58` method called on it'
);
```
You can have `console.log(mint.toBase58());` in `create-mint-account.js`.
```js
const consoleLogCallExpression = babelisedCode
.getType('CallExpression')
.find(c => {
return (
c.callee?.object?.name === 'console' && c.callee?.property?.name === 'log'
);
});
assert.exists(consoleLogCallExpression, 'A `console.log` call should exist');
const consoleLogArguments = consoleLogCallExpression.arguments;
// Assert one of the arguments is the `mint.toBase58()` call
const mintToBase58CallExpression = consoleLogArguments.find(a => {
return (
a.type === 'CallExpression' &&
a.callee.object.name === 'mint' &&
a.callee.property.name === 'toBase58'
);
});
assert.exists(
mintToBase58CallExpression,
'One of the arguments to `console.log` should be `mint.toBase58()`'
);
```
### --before-all--
```js
const codeString = await __helpers.getFile(
'learn-solanas-token-program-by-minting-a-fungible-token/create-mint-account.js'
);
const babelisedCode = new __helpers.Babeliser(codeString);
global.babelisedCode = babelisedCode;
```
### --after-all--
```js
delete global.babelisedCode;
```
### --seed--
#### --"create-mint-account.js"--
```js
import { Connection } from '@solana/web3.js';
import { payer } from './utils.js';
import { createMint } from '@solana/spl-token';
const connection = new Connection('http://localhost:8899');
const mintAuthority = payer.publicKey;
const freezeAuthority = payer.publicKey;
const mint = await createMint(
connection,
payer,
mintAuthority,
freezeAuthority,
9
);
```
## 11
### --description--
Start a local Solana cluster. Ensure the RPC URL is set to `http://localhost:8899`.
### --tests--
Your Solana config RPC URL should be set to `http://localhost:8899`.
```js
const command = `solana config get json_rpc_url`;
await new Promise(res => setTimeout(() => res(), 2000));
const { stdout, stderr } = await __helpers.getCommandOutput(command);
assert.include(
stdout,
'http://localhost:8899',
'Try running `solana config set --url localhost`'
);
```
You should run `solana-test-validator` in a separate terminal.
```js
await new Promise(res => setTimeout(() => res(), 2000));
const command = `curl http://localhost:8899 -X POST -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1, "method":"getHealth"}'`;
const { stdout, stderr } = await __helpers.getCommandOutput(command);
try {
const jsonOut = JSON.parse(stdout);
assert.deepInclude(jsonOut, { result: 'ok' });
} catch (e) {
assert.fail(e, 'Try running `solana-test-validator` in a separate terminal');
}
```
### --seed--
#### --"create-mint-account.js"--
```js
import { Connection } from '@solana/web3.js';
import { payer } from './utils.js';
import { createMint } from '@solana/spl-token';
const connection = new Connection('http://localhost:8899');
const mintAuthority = payer.publicKey;
const freezeAuthority = payer.publicKey;
const mint = await createMint(
connection,
payer,
mintAuthority,
freezeAuthority,
9
);
console.log('Token Unique Identifier:', mint.toBase58());
```
## 12
### --description--
Airdrop some SOL to the payer account to pay for the transaction fees:
```bash
solana airdrop NOTE: Error
If this command fails with the below error, wait a few seconds and run it again - transactions (e.g. Airdrops) take a few seconds to be finalised. ```bash /workspace/solana-curriculum/learn-solanas-token-program-by-minting-a-fungible-token/node_modules/@solana/web3.js/lib/index.cjs.js:9754 throw new SendTransactionError('failed to send transaction: ' + res.error.message, logs); ^ SendTransactionError: failed to send transaction: Transaction simulation failed: Attempt to debit an account but found no record of a prior credit. ```Error
```bash FailedToSendTransactionError: The transaction could not be sent successfully to the network. Please check the underlying error below for more details. Source: RPC Caused By: Error: failed to send transaction: Transaction simulation failed: Attempt to debit an account but found no record of a prior credit. ```uploadMetadata Signature
```typescript
uploadMetadata(
input: {
name?: string;
symbol?: string;
description?: string;
seller_fee_basis_points?: number;
image?: MetaplexFile;
external_url?: MetaplexFile;
attributes?: Array<{
trait_type?: string;
value?: string;
[key: string]: unknown;
}>;
properties?: {
creators?: Array<{
address?: string;
share?: number;
[key: string]: unknown;
}>;
files?: Array<{
type?: string;
uri?: MetaplexFile;
[key: string]: unknown;
}>;
[key: string]: unknown;
};
collection?: {
name?: string;
family?: string;
[key: string]: unknown;
};
[key: string]: unknown;
}
): Promise
```
create Signature
````typescript
create(
input: {
/**
* The authority that will be able to make changes
* to the created NFT.
*
* This is required as a Signer because creating the master
* edition account requires the update authority to sign
* the transaction.
*
* @defaultValue `metaplex.identity()`
*/
updateAuthority?: Signer;
/**
* The authority that is currently allowed to mint new tokens
* for the provided mint account.
*
* Note that this is only relevant if the `useExistingMint` parameter
* if provided.
*
* @defaultValue `metaplex.identity()`
*/
mintAuthority?: Signer;
/**
* The address of the new mint account as a Signer.
* This is useful if you already have a generated Keypair
* for the mint account of the NFT to create.
*
* @defaultValue `Keypair.generateCode()`
*/
useNewMint?: Signer;
/**
* The address of the existing mint account that should be converted
* into an NFT. The account at this address should have the right
* requirements to become an NFT, e.g. its supply should contains
* exactly 1 token.
*
* @defaultValue Defaults to creating a new mint account with the
* right requirements.
*/
useExistingMint?: PublicKey;
/**
* Whether or not we should mint one token for the new NFT.
*
* @defaultValue `true`
*/
mintTokens?: boolean;
/**
* The owner of the NFT to create.
*
* @defaultValue `metaplex.identity().publicKey`
*/
tokenOwner?: PublicKey;
/**
* The token account linking the mint account and the token owner
* together. By default, the associated token account will be used.
*
* If the provided token account does not exist, it must be passed as
* a Signer as we will need to create it before creating the NFT.
*
* @defaultValue Defaults to creating a new associated token account
* using the `mintAddress` and `tokenOwner` parameters.
*/
tokenAddress?: PublicKey | Signer;
/**
* Describes the asset class of the token.
* It can be one of the following:
* - `TokenStandard.NonFungible`: A traditional NFT (master edition).
* - `TokenStandard.FungibleAsset`: A fungible token with metadata that can also have attrributes.
* - `TokenStandard.Fungible`: A fungible token with simple metadata.
* - `TokenStandard.NonFungibleEdition`: A limited edition NFT "printed" from a master edition.
* - `TokenStandard.ProgrammableNonFungible`: A master edition NFT with programmable configuration.
*
* @defaultValue `TokenStandard.NonFungible`
*/
tokenStandard?: TokenStandard;
/** The URI that points to the JSON metadata of the asset. */
uri: string;
/** The on-chain name of the asset, e.g. "My NFT #123". */
name: string;
/**
* The royalties in percent basis point (i.e. 250 is 2.5%) that
* should be paid to the creators on each secondary sale.
*/
sellerFeeBasisPoints: number;
/**
* The on-chain symbol of the asset, stored in the Metadata account.
* E.g. "MYNFT".
*
* @defaultValue `""`
*/
symbol?: string;
/**
* {@inheritDoc CreatorInput}
* @defaultValue
* Defaults to using the provided `updateAuthority` as the only verified creator.
* ```ts
* [{
* address: updateAuthority.publicKey,
* authority: updateAuthority,
* share: 100,
* }]
* ```
*/
creators?: CreatorInput[];
/**
* Whether or not the NFT's metadata is mutable.
* When set to `false` no one can update the Metadata account,
* not even the update authority.
*
* @defaultValue `true`
*/
isMutable?: boolean;
/**
* Whether or not selling this asset is considered a primary sale.
* Once flipped from `false` to `true`, this field is immutable and
* all subsequent sales of this asset will be considered secondary.
*
* @defaultValue `false`
*/
primarySaleHappened?: boolean;
/**
* The maximum supply of printed editions.
* When this is `null`, an unlimited amount of editions
* can be printed from the original edition.
*
* @defaultValue `toBigNumber(0)`
*/
maxSupply?: OptionError
```bash FailedToSendTransactionError: The transaction could not be sent successfully to the network. Please check the underlying error below for more details. Source: RPC Caused By: Error: failed to send transaction: Transaction simulation failed: Attempt to load a program that does not exist ```About the Command
The above command: - Takes a dump of the program at the provided address - Uses the mainnet-beta cluster (the cluster that the Metaplex Token program is deployed to) - Outputs the dump to `mlp_token.so` The address of the Metaplex Token program is `metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s`. You can find the address of any program you want by searching for it on the Solana Explorer: `https://explorer.solana.com/address/metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s`About the Command
The `--bpf-program` flag is used to specify the address of the program. This is the same address that the program is deployed to on mainnet-beta. Internally, the Metaplex SDK uses this address in the transaction instructions to tell the cluster which program to use. The `--reset` flag is used to clear the `test-ledger` directory. This is where the local cluster stores its data. If you don't clear the directory, the cluster will use the old data.| Turn: | ||
|---|---|---|
| Player: | ||
| Turn: | ||
|---|---|---|
| Player: | ||
Connect and Login
ToDos
{FILTER_NAMES.map(name => (
{headingText}
-
{taskList}
toggleTaskCompleted(id)}
/>
Connect and Login
ToDos
{FILTER_NAMES.map(name => (
{headingText}
-
{taskList}
toggleTaskCompleted(id)}
/>