micro-sol-signer
Version:
Create, sign & decode Solana transactions with minimum deps
1,206 lines (1,205 loc) • 114 kB
JavaScript
export default {
kind: 'rootNode',
program: {
kind: 'programNode',
pdas: [],
accounts: [
{
kind: 'accountNode',
data: {
kind: 'structTypeNode',
fields: [
{
kind: 'structFieldTypeNode',
name: 'mintAuthority',
type: {
kind: 'optionTypeNode',
item: { kind: 'publicKeyTypeNode' },
prefix: {
kind: 'numberTypeNode',
format: 'u32',
endian: 'le',
},
fixed: true,
},
docs: [
'Optional authority used to mint new tokens. The mint authority may only',
'be provided during mint creation. If no mint authority is present',
'then the mint has a fixed supply and no further tokens may be minted.',
],
},
{
kind: 'structFieldTypeNode',
name: 'supply',
type: {
kind: 'numberTypeNode',
format: 'u64',
endian: 'le',
},
docs: ['Total supply of tokens.'],
},
{
kind: 'structFieldTypeNode',
name: 'decimals',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: ['Number of base 10 digits to the right of the decimal place.'],
},
{
kind: 'structFieldTypeNode',
name: 'isInitialized',
type: {
kind: 'booleanTypeNode',
size: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
},
docs: ['Is `true` if this structure has been initialized.'],
},
{
kind: 'structFieldTypeNode',
name: 'freezeAuthority',
type: {
kind: 'optionTypeNode',
item: { kind: 'publicKeyTypeNode' },
prefix: {
kind: 'numberTypeNode',
format: 'u32',
endian: 'le',
},
fixed: true,
},
docs: ['Optional authority to freeze token accounts.'],
},
],
},
discriminators: [
{
kind: 'sizeDiscriminatorNode',
size: 82,
},
],
name: 'mint',
docs: [],
size: 82,
},
{
kind: 'accountNode',
data: {
kind: 'structTypeNode',
fields: [
{
kind: 'structFieldTypeNode',
name: 'mint',
type: { kind: 'publicKeyTypeNode' },
docs: ['The mint associated with this account.'],
},
{
kind: 'structFieldTypeNode',
name: 'owner',
type: { kind: 'publicKeyTypeNode' },
docs: ['The owner of this account.'],
},
{
kind: 'structFieldTypeNode',
name: 'amount',
type: {
kind: 'numberTypeNode',
format: 'u64',
endian: 'le',
},
docs: ['The amount of tokens this account holds.'],
},
{
kind: 'structFieldTypeNode',
name: 'delegate',
type: {
kind: 'optionTypeNode',
item: { kind: 'publicKeyTypeNode' },
prefix: {
kind: 'numberTypeNode',
format: 'u32',
endian: 'le',
},
fixed: true,
},
docs: [
'If `delegate` is `Some` then `delegated_amount` represents',
'the amount authorized by the delegate.',
],
},
{
kind: 'structFieldTypeNode',
name: 'state',
type: { kind: 'definedTypeLinkNode', name: 'accountState' },
docs: ["The account's state."],
},
{
kind: 'structFieldTypeNode',
name: 'isNative',
type: {
kind: 'optionTypeNode',
item: {
kind: 'numberTypeNode',
format: 'u64',
endian: 'le',
},
prefix: {
kind: 'numberTypeNode',
format: 'u32',
endian: 'le',
},
fixed: true,
},
docs: [
'If is_native.is_some, this is a native token, and the value logs the',
'rent-exempt reserve. An Account is required to be rent-exempt, so',
'the value is used by the Processor to ensure that wrapped SOL',
'accounts do not drop below this threshold.',
],
},
{
kind: 'structFieldTypeNode',
name: 'delegatedAmount',
type: {
kind: 'numberTypeNode',
format: 'u64',
endian: 'le',
},
docs: ['The amount delegated.'],
},
{
kind: 'structFieldTypeNode',
name: 'closeAuthority',
type: {
kind: 'optionTypeNode',
item: { kind: 'publicKeyTypeNode' },
prefix: {
kind: 'numberTypeNode',
format: 'u32',
endian: 'le',
},
fixed: true,
},
docs: ['Optional authority to close the account.'],
},
],
},
discriminators: [
{
kind: 'sizeDiscriminatorNode',
size: 165,
},
],
name: 'token',
docs: [],
size: 165,
},
{
kind: 'accountNode',
data: {
kind: 'structTypeNode',
fields: [
{
kind: 'structFieldTypeNode',
name: 'm',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: ['Number of signers required.'],
},
{
kind: 'structFieldTypeNode',
name: 'n',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: ['Number of valid signers.'],
},
{
kind: 'structFieldTypeNode',
name: 'isInitialized',
type: {
kind: 'booleanTypeNode',
size: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
},
docs: ['Is `true` if this structure has been initialized.'],
},
{
kind: 'structFieldTypeNode',
name: 'signers',
type: {
kind: 'arrayTypeNode',
item: { kind: 'publicKeyTypeNode' },
count: { kind: 'fixedCountNode', value: 11 },
},
docs: ['Signer public keys.'],
},
],
},
discriminators: [
{
kind: 'sizeDiscriminatorNode',
size: 355,
},
],
name: 'multisig',
docs: [],
size: 355,
},
],
instructions: [
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'mint',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['Token mint account.'],
},
{
kind: 'instructionAccountNode',
name: 'rent',
isWritable: false,
isSigner: false,
isOptional: false,
docs: ['Rent sysvar.'],
defaultValue: {
kind: 'publicKeyValueNode',
publicKey: 'SysvarRent111111111111111111111111111111111',
},
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 0 },
defaultValueStrategy: 'omitted',
},
{
kind: 'instructionArgumentNode',
name: 'decimals',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: ['Number of decimals in token account amounts.'],
},
{
kind: 'instructionArgumentNode',
name: 'mintAuthority',
type: { kind: 'publicKeyTypeNode' },
docs: ['Minting authority.'],
},
{
kind: 'instructionArgumentNode',
name: 'freezeAuthority',
type: {
kind: 'optionTypeNode',
item: { kind: 'publicKeyTypeNode' },
prefix: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
fixed: false,
},
defaultValue: {
kind: 'noneValueNode',
},
docs: ['Optional authority that can freeze token accounts.'],
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
name: 'initializeMint',
docs: [
'Initializes a new mint and optionally deposits all the newly minted',
'tokens in an account.',
'',
'The `InitializeMint` instruction requires no signers and MUST be',
"included within the same Transaction as the system program's",
'`CreateAccount` instruction that creates the account being initialized.',
'Otherwise another party can acquire ownership of the uninitialized account.',
],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'account',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The account to initialize.'],
},
{
kind: 'instructionAccountNode',
name: 'mint',
isWritable: false,
isSigner: false,
isOptional: false,
docs: ['The mint this account will be associated with.'],
},
{
kind: 'instructionAccountNode',
name: 'owner',
isWritable: false,
isSigner: false,
isOptional: false,
docs: ["The new account's owner/multisignature."],
},
{
kind: 'instructionAccountNode',
name: 'rent',
isWritable: false,
isSigner: false,
isOptional: false,
docs: ['Rent sysvar.'],
defaultValue: {
kind: 'publicKeyValueNode',
publicKey: 'SysvarRent111111111111111111111111111111111',
},
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 1 },
defaultValueStrategy: 'omitted',
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
name: 'initializeAccount',
docs: [
'Initializes a new account to hold tokens. If this account is associated',
'with the native mint then the token balance of the initialized account',
'will be equal to the amount of SOL in the account. If this account is',
'associated with another mint, that mint must be initialized before this',
'command can succeed.',
'',
'The `InitializeAccount` instruction requires no signers and MUST be',
"included within the same Transaction as the system program's",
'`CreateAccount` instruction that creates the account being initialized.',
'Otherwise another party can acquire ownership of the uninitialized account.',
],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'multisig',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The multisignature account to initialize.'],
},
{
kind: 'instructionAccountNode',
name: 'rent',
isWritable: false,
isSigner: false,
isOptional: false,
docs: ['Rent sysvar.'],
defaultValue: {
kind: 'publicKeyValueNode',
publicKey: 'SysvarRent111111111111111111111111111111111',
},
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 2 },
defaultValueStrategy: 'omitted',
},
{
kind: 'instructionArgumentNode',
name: 'm',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: ['The number of signers (M) required to validate this multisignature account.'],
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'signers',
},
},
],
name: 'initializeMultisig',
docs: [
'Initializes a multisignature account with N provided signers.',
'',
'Multisignature accounts can used in place of any single owner/delegate',
'accounts in any token instruction that require an owner/delegate to be',
'present. The variant field represents the number of signers (M)',
'required to validate this multisignature account.',
'',
'The `InitializeMultisig` instruction requires no signers and MUST be',
"included within the same Transaction as the system program's",
'`CreateAccount` instruction that creates the account being initialized.',
'Otherwise another party can acquire ownership of the uninitialized account.',
],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'source',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The source account.'],
},
{
kind: 'instructionAccountNode',
name: 'destination',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The destination account.'],
},
{
kind: 'instructionAccountNode',
name: 'authority',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: ["The source account's owner/delegate or its multisignature account."],
defaultValue: { kind: 'identityValueNode' },
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 3 },
defaultValueStrategy: 'omitted',
},
{
kind: 'instructionArgumentNode',
name: 'amount',
type: {
kind: 'numberTypeNode',
format: 'u64',
endian: 'le',
},
docs: ['The amount of tokens to transfer.'],
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'multiSigners',
},
isOptional: true,
isSigner: true,
},
],
name: 'transfer',
docs: [
'Transfers tokens from one account to another either directly or via a delegate.',
'If this account is associated with the native mint then equal amounts',
'of SOL and Tokens will be transferred to the destination account.',
],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'source',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The source account.'],
},
{
kind: 'instructionAccountNode',
name: 'delegate',
isWritable: false,
isSigner: false,
isOptional: false,
docs: ['The delegate.'],
},
{
kind: 'instructionAccountNode',
name: 'owner',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: ['The source account owner or its multisignature account.'],
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 4 },
defaultValueStrategy: 'omitted',
},
{
kind: 'instructionArgumentNode',
name: 'amount',
type: {
kind: 'numberTypeNode',
format: 'u64',
endian: 'le',
},
docs: ['The amount of tokens the delegate is approved for.'],
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'multiSigners',
},
isOptional: true,
isSigner: true,
},
],
name: 'approve',
docs: [
'Approves a delegate. A delegate is given the authority over tokens on',
"behalf of the source account's owner.",
],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'source',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The source account.'],
},
{
kind: 'instructionAccountNode',
name: 'owner',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: ['The source account owner or its multisignature.'],
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 5 },
defaultValueStrategy: 'omitted',
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'multiSigners',
},
isOptional: true,
isSigner: true,
},
],
name: 'revoke',
docs: ["Revokes the delegate's authority."],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'owned',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The mint or account to change the authority of.'],
},
{
kind: 'instructionAccountNode',
name: 'owner',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: [
'The current authority or the multisignature account of the mint or account to update.',
],
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 6 },
defaultValueStrategy: 'omitted',
},
{
kind: 'instructionArgumentNode',
name: 'authorityType',
type: { kind: 'definedTypeLinkNode', name: 'authorityType' },
docs: ['The type of authority to update.'],
},
{
kind: 'instructionArgumentNode',
name: 'newAuthority',
type: {
kind: 'optionTypeNode',
item: { kind: 'publicKeyTypeNode' },
prefix: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
fixed: false,
},
docs: ['The new authority'],
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'multiSigners',
},
isOptional: true,
isSigner: true,
},
],
name: 'setAuthority',
docs: ['Sets a new authority of a mint or account.'],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'mint',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The mint account.'],
},
{
kind: 'instructionAccountNode',
name: 'token',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The account to mint tokens to.'],
},
{
kind: 'instructionAccountNode',
name: 'mintAuthority',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: ["The mint's minting authority or its multisignature account."],
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 7 },
defaultValueStrategy: 'omitted',
},
{
kind: 'instructionArgumentNode',
name: 'amount',
type: {
kind: 'numberTypeNode',
format: 'u64',
endian: 'le',
},
docs: ['The amount of new tokens to mint.'],
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'multiSigners',
},
isOptional: true,
isSigner: true,
},
],
name: 'mintTo',
docs: ['Mints new tokens to an account. The native mint does not support minting.'],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'account',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The account to burn from.'],
},
{
kind: 'instructionAccountNode',
name: 'mint',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The token mint.'],
},
{
kind: 'instructionAccountNode',
name: 'authority',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: ["The account's owner/delegate or its multisignature account."],
defaultValue: { kind: 'identityValueNode' },
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: ['The amount of tokens to burn.'],
defaultValue: { kind: 'numberValueNode', number: 8 },
defaultValueStrategy: 'omitted',
},
{
kind: 'instructionArgumentNode',
name: 'amount',
type: {
kind: 'numberTypeNode',
format: 'u64',
endian: 'le',
},
docs: [],
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'multiSigners',
},
isOptional: true,
isSigner: true,
},
],
name: 'burn',
docs: [
'Burns tokens by removing them from an account. `Burn` does not support',
'accounts associated with the native mint, use `CloseAccount` instead.',
],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'account',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The account to close.'],
},
{
kind: 'instructionAccountNode',
name: 'destination',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The destination account.'],
},
{
kind: 'instructionAccountNode',
name: 'owner',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: ["The account's owner or its multisignature account."],
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 9 },
defaultValueStrategy: 'omitted',
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'multiSigners',
},
isOptional: true,
isSigner: true,
},
],
name: 'closeAccount',
docs: [
'Close an account by transferring all its SOL to the destination account.',
'Non-native accounts may only be closed if its token amount is zero.',
],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'account',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The account to freeze.'],
},
{
kind: 'instructionAccountNode',
name: 'mint',
isWritable: false,
isSigner: false,
isOptional: false,
docs: ['The token mint.'],
},
{
kind: 'instructionAccountNode',
name: 'owner',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: ['The mint freeze authority or its multisignature account.'],
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 10 },
defaultValueStrategy: 'omitted',
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'multiSigners',
},
isOptional: true,
isSigner: true,
},
],
name: 'freezeAccount',
docs: ["Freeze an Initialized account using the Mint's freeze_authority (if set)."],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'account',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The account to thaw.'],
},
{
kind: 'instructionAccountNode',
name: 'mint',
isWritable: false,
isSigner: false,
isOptional: false,
docs: ['The token mint.'],
},
{
kind: 'instructionAccountNode',
name: 'owner',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: ['The mint freeze authority or its multisignature account.'],
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 11 },
defaultValueStrategy: 'omitted',
},
],
discriminators: [
{
kind: 'fieldDiscriminatorNode',
name: 'discriminator',
offset: 0,
},
],
remainingAccounts: [
{
kind: 'instructionRemainingAccountsNode',
value: {
kind: 'argumentValueNode',
name: 'multiSigners',
},
isOptional: true,
isSigner: true,
},
],
name: 'thawAccount',
docs: ["Thaw a Frozen account using the Mint's freeze_authority (if set)."],
optionalAccountStrategy: 'programId',
},
{
kind: 'instructionNode',
accounts: [
{
kind: 'instructionAccountNode',
name: 'source',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The source account.'],
},
{
kind: 'instructionAccountNode',
name: 'mint',
isWritable: false,
isSigner: false,
isOptional: false,
docs: ['The token mint.'],
},
{
kind: 'instructionAccountNode',
name: 'destination',
isWritable: true,
isSigner: false,
isOptional: false,
docs: ['The destination account.'],
},
{
kind: 'instructionAccountNode',
name: 'authority',
isWritable: false,
isSigner: 'either',
isOptional: false,
docs: ["The source account's owner/delegate or its multisignature account."],
defaultValue: { kind: 'identityValueNode' },
},
],
arguments: [
{
kind: 'instructionArgumentNode',
name: 'discriminator',
type: {
kind: 'numberTypeNode',
format: 'u8',
endian: 'le',
},
docs: [],
defaultValue: { kind: 'numberValueNode', number: 12 },
defaultValueStrategy: 'omitted',
},
{
kind: 'instructionArgumentNode',
name: 'amount',
type: {
kind: 'numberTypeNode',
format: 'u64',