Improve Kinobi IDL

clients/js/src/generated/accounts/token.ts → clients/js/src/generated/accounts/account.ts

@@ -43,7 +43,7 @@ import {
   getTokenStateEncoder,
 } from '../types';
 
-export type Token = {
+export type Account = {
   mint: Address;
   owner: Address;
   amount: bigint;
@@ -54,7 +54,7 @@ export type Token = {
   closeAuthority: Option<Address>;
 };
 
-export type TokenArgs = {
+export type AccountArgs = {
   mint: Address;
   owner: Address;
   amount: number | bigint;
@@ -65,7 +65,7 @@ export type TokenArgs = {
   closeAuthority: OptionOrNullable<Address>;
 };
 
-export function getTokenEncoder(): Encoder<TokenArgs> {
+export function getAccountEncoder(): Encoder<AccountArgs> {
   return getStructEncoder([
     ['mint', getAddressEncoder()],
     ['owner', getAddressEncoder()],
@@ -96,7 +96,7 @@ export function getTokenEncoder(): Encoder<TokenArgs> {
   ]);
 }
 
-export function getTokenDecoder(): Decoder<Token> {
+export function getAccountDecoder(): Decoder<Account> {
   return getStructDecoder([
     ['mint', getAddressDecoder()],
     ['owner', getAddressDecoder()],
@@ -127,63 +127,63 @@ export function getTokenDecoder(): Decoder<Token> {
   ]);
 }
 
-export function getTokenCodec(): Codec<TokenArgs, Token> {
-  return combineCodec(getTokenEncoder(), getTokenDecoder());
+export function getAccountCodec(): Codec<AccountArgs, Account> {
+  return combineCodec(getAccountEncoder(), getAccountDecoder());
 }
 
-export function decodeToken<TAddress extends string = string>(
+export function decodeAccount<TAddress extends string = string>(
   encodedAccount: EncodedAccount<TAddress>
-): Account<Token, TAddress>;
-export function decodeToken<TAddress extends string = string>(
+): Account<Account, TAddress>;
+export function decodeAccount<TAddress extends string = string>(
   encodedAccount: MaybeEncodedAccount<TAddress>
-): MaybeAccount<Token, TAddress>;
-export function decodeToken<TAddress extends string = string>(
+): MaybeAccount<Account, TAddress>;
+export function decodeAccount<TAddress extends string = string>(
   encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>
-): Account<Token, TAddress> | MaybeAccount<Token, TAddress> {
+): Account<Account, TAddress> | MaybeAccount<Account, TAddress> {
   return decodeAccount(
     encodedAccount as MaybeEncodedAccount<TAddress>,
-    getTokenDecoder()
+    getAccountDecoder()
   );
 }
 
-export async function fetchToken<TAddress extends string = string>(
+export async function fetchAccount<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
   config?: FetchAccountConfig
-): Promise<Account<Token, TAddress>> {
-  const maybeAccount = await fetchMaybeToken(rpc, address, config);
+): Promise<Account<Account, TAddress>> {
+  const maybeAccount = await fetchMaybeAccount(rpc, address, config);
   assertAccountExists(maybeAccount);
   return maybeAccount;
 }
 
-export async function fetchMaybeToken<TAddress extends string = string>(
+export async function fetchMaybeAccount<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
   config?: FetchAccountConfig
-): Promise<MaybeAccount<Token, TAddress>> {
+): Promise<MaybeAccount<Account, TAddress>> {
   const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-  return decodeToken(maybeAccount);
+  return decodeAccount(maybeAccount);
 }
 
-export async function fetchAllToken(
+export async function fetchAllAccount(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
   config?: FetchAccountsConfig
-): Promise<Account<Token>[]> {
-  const maybeAccounts = await fetchAllMaybeToken(rpc, addresses, config);
+): Promise<Account<Account>[]> {
+  const maybeAccounts = await fetchAllMaybeAccount(rpc, addresses, config);
   assertAccountsExist(maybeAccounts);
   return maybeAccounts;
 }
 
-export async function fetchAllMaybeToken(
+export async function fetchAllMaybeAccount(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
   config?: FetchAccountsConfig
-): Promise<MaybeAccount<Token>[]> {
+): Promise<MaybeAccount<Account>[]> {
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
-  return maybeAccounts.map((maybeAccount) => decodeToken(maybeAccount));
+  return maybeAccounts.map((maybeAccount) => decodeAccount(maybeAccount));
 }
 
-export function getTokenSize(): number {
+export function getAccountSize(): number {
   return 165;
 }

clients/js/src/generated/accounts/index.ts

@@ -6,6 +6,6 @@
  * @see https://github.com/metaplex-foundation/kinobi
  */
 
+export * from './account';
 export * from './mint';
 export * from './multisig';
-export * from './token';

clients/js/src/generated/instructions/approveTokenDelegate.ts → clients/js/src/generated/instructions/approve.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -32,7 +33,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type ApproveTokenDelegateInstruction<
+export type ApproveInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource extends string | IAccountMeta<string> = string,
   TAccountDelegate extends string | IAccountMeta<string> = string,
@@ -49,23 +50,24 @@ export type ApproveTokenDelegateInstruction<
         ? ReadonlyAccount<TAccountDelegate>
         : TAccountDelegate,
       TAccountOwner extends string
-        ? ReadonlySignerAccount<TAccountOwner> &
-            IAccountSignerMeta<TAccountOwner>
+        ? ReadonlyAccount<TAccountOwner>
         : TAccountOwner,
       ...TRemainingAccounts,
     ]
   >;
 
-export type ApproveTokenDelegateInstructionData = {
+export type ApproveInstructionData = {
   discriminator: number;
+  /** The amount of tokens the delegate is approved for. */
   amount: bigint;
 };
 
-export type ApproveTokenDelegateInstructionDataArgs = {
+export type ApproveInstructionDataArgs = {
+  /** The amount of tokens the delegate is approved for. */
   amount: number | bigint;
 };
 
-export function getApproveTokenDelegateInstructionDataEncoder(): Encoder<ApproveTokenDelegateInstructionDataArgs> {
+export function getApproveInstructionDataEncoder(): Encoder<ApproveInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
@@ -75,49 +77,51 @@ export function getApproveTokenDelegateInstructionDataEncoder(): Encoder<Approve
   );
 }
 
-export function getApproveTokenDelegateInstructionDataDecoder(): Decoder<ApproveTokenDelegateInstructionData> {
+export function getApproveInstructionDataDecoder(): Decoder<ApproveInstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['amount', getU64Decoder()],
   ]);
 }
 
-export function getApproveTokenDelegateInstructionDataCodec(): Codec<
-  ApproveTokenDelegateInstructionDataArgs,
-  ApproveTokenDelegateInstructionData
+export function getApproveInstructionDataCodec(): Codec<
+  ApproveInstructionDataArgs,
+  ApproveInstructionData
 > {
   return combineCodec(
-    getApproveTokenDelegateInstructionDataEncoder(),
-    getApproveTokenDelegateInstructionDataDecoder()
+    getApproveInstructionDataEncoder(),
+    getApproveInstructionDataDecoder()
   );
 }
 
-export type ApproveTokenDelegateInput<
+export type ApproveInput<
   TAccountSource extends string = string,
   TAccountDelegate extends string = string,
   TAccountOwner extends string = string,
 > = {
+  /** The source account. */
   source: Address<TAccountSource>;
+  /** The delegate. */
   delegate: Address<TAccountDelegate>;
-  owner: TransactionSigner<TAccountOwner>;
-  amount: ApproveTokenDelegateInstructionDataArgs['amount'];
+  /** The source account owner or its multisignature account. */
+  owner: Address<TAccountOwner> | TransactionSigner<TAccountOwner>;
+  amount: ApproveInstructionDataArgs['amount'];
+  multiSigners?: Array<TransactionSigner>;
 };
 
-export function getApproveTokenDelegateInstruction<
+export function getApproveInstruction<
   TAccountSource extends string,
   TAccountDelegate extends string,
   TAccountOwner extends string,
 >(
-  input: ApproveTokenDelegateInput<
-    TAccountSource,
-    TAccountDelegate,
-    TAccountOwner
-  >
-): ApproveTokenDelegateInstruction<
+  input: ApproveInput<TAccountSource, TAccountDelegate, TAccountOwner>
+): ApproveInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource,
   TAccountDelegate,
-  TAccountOwner
+  (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+    ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+    : TAccountOwner
 > {
   // Program address.
   const programAddress = TOKEN_PROGRAM_ADDRESS;
@@ -136,48 +140,63 @@ export function getApproveTokenDelegateInstruction<
   // Original args.
   const args = { ...input };
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
       getAccountMeta(accounts.source),
       getAccountMeta(accounts.delegate),
       getAccountMeta(accounts.owner),
+      ...remainingAccounts,
     ],
     programAddress,
-    data: getApproveTokenDelegateInstructionDataEncoder().encode(
-      args as ApproveTokenDelegateInstructionDataArgs
+    data: getApproveInstructionDataEncoder().encode(
+      args as ApproveInstructionDataArgs
     ),
-  } as ApproveTokenDelegateInstruction<
+  } as ApproveInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountSource,
     TAccountDelegate,
-    TAccountOwner
+    (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+      ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+      : TAccountOwner
   >;
 
   return instruction;
 }
 
-export type ParsedApproveTokenDelegateInstruction<
+export type ParsedApproveInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The source account. */
     source: TAccountMetas[0];
+    /** The delegate. */
     delegate: TAccountMetas[1];
+    /** The source account owner or its multisignature account. */
     owner: TAccountMetas[2];
   };
-  data: ApproveTokenDelegateInstructionData;
+  data: ApproveInstructionData;
 };
 
-export function parseApproveTokenDelegateInstruction<
+export function parseApproveInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedApproveTokenDelegateInstruction<TProgram, TAccountMetas> {
+): ParsedApproveInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 3) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -195,8 +214,6 @@ export function parseApproveTokenDelegateInstruction<
       delegate: getNextAccount(),
       owner: getNextAccount(),
     },
-    data: getApproveTokenDelegateInstructionDataDecoder().decode(
-      instruction.data
-    ),
+    data: getApproveInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/approveTokenDelegateChecked.ts → clients/js/src/generated/instructions/approveChecked.ts

@@ -32,7 +32,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type ApproveTokenDelegateCheckedInstruction<
+export type ApproveCheckedInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource extends string | IAccountMeta<string> = string,
   TAccountMint extends string | IAccountMeta<string> = string,
@@ -60,18 +60,18 @@ export type ApproveTokenDelegateCheckedInstruction<
     ]
   >;
 
-export type ApproveTokenDelegateCheckedInstructionData = {
+export type ApproveCheckedInstructionData = {
   discriminator: number;
   amount: bigint;
   decimals: number;
 };
 
-export type ApproveTokenDelegateCheckedInstructionDataArgs = {
+export type ApproveCheckedInstructionDataArgs = {
   amount: number | bigint;
   decimals: number;
 };
 
-export function getApproveTokenDelegateCheckedInstructionDataEncoder(): Encoder<ApproveTokenDelegateCheckedInstructionDataArgs> {
+export function getApproveCheckedInstructionDataEncoder(): Encoder<ApproveCheckedInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
@@ -82,7 +82,7 @@ export function getApproveTokenDelegateCheckedInstructionDataEncoder(): Encoder<
   );
 }
 
-export function getApproveTokenDelegateCheckedInstructionDataDecoder(): Decoder<ApproveTokenDelegateCheckedInstructionData> {
+export function getApproveCheckedInstructionDataDecoder(): Decoder<ApproveCheckedInstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['amount', getU64Decoder()],
@@ -90,17 +90,17 @@ export function getApproveTokenDelegateCheckedInstructionDataDecoder(): Decoder<
   ]);
 }
 
-export function getApproveTokenDelegateCheckedInstructionDataCodec(): Codec<
-  ApproveTokenDelegateCheckedInstructionDataArgs,
-  ApproveTokenDelegateCheckedInstructionData
+export function getApproveCheckedInstructionDataCodec(): Codec<
+  ApproveCheckedInstructionDataArgs,
+  ApproveCheckedInstructionData
 > {
   return combineCodec(
-    getApproveTokenDelegateCheckedInstructionDataEncoder(),
-    getApproveTokenDelegateCheckedInstructionDataDecoder()
+    getApproveCheckedInstructionDataEncoder(),
+    getApproveCheckedInstructionDataDecoder()
   );
 }
 
-export type ApproveTokenDelegateCheckedInput<
+export type ApproveCheckedInput<
   TAccountSource extends string = string,
   TAccountMint extends string = string,
   TAccountDelegate extends string = string,
@@ -110,23 +110,23 @@ export type ApproveTokenDelegateCheckedInput<
   mint: Address<TAccountMint>;
   delegate: Address<TAccountDelegate>;
   owner: TransactionSigner<TAccountOwner>;
-  amount: ApproveTokenDelegateCheckedInstructionDataArgs['amount'];
-  decimals: ApproveTokenDelegateCheckedInstructionDataArgs['decimals'];
+  amount: ApproveCheckedInstructionDataArgs['amount'];
+  decimals: ApproveCheckedInstructionDataArgs['decimals'];
 };
 
-export function getApproveTokenDelegateCheckedInstruction<
+export function getApproveCheckedInstruction<
   TAccountSource extends string,
   TAccountMint extends string,
   TAccountDelegate extends string,
   TAccountOwner extends string,
 >(
-  input: ApproveTokenDelegateCheckedInput<
+  input: ApproveCheckedInput<
     TAccountSource,
     TAccountMint,
     TAccountDelegate,
     TAccountOwner
   >
-): ApproveTokenDelegateCheckedInstruction<
+): ApproveCheckedInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource,
   TAccountMint,
@@ -160,10 +160,10 @@ export function getApproveTokenDelegateCheckedInstruction<
       getAccountMeta(accounts.owner),
     ],
     programAddress,
-    data: getApproveTokenDelegateCheckedInstructionDataEncoder().encode(
-      args as ApproveTokenDelegateCheckedInstructionDataArgs
+    data: getApproveCheckedInstructionDataEncoder().encode(
+      args as ApproveCheckedInstructionDataArgs
     ),
-  } as ApproveTokenDelegateCheckedInstruction<
+  } as ApproveCheckedInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountSource,
     TAccountMint,
@@ -174,7 +174,7 @@ export function getApproveTokenDelegateCheckedInstruction<
   return instruction;
 }
 
-export type ParsedApproveTokenDelegateCheckedInstruction<
+export type ParsedApproveCheckedInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
@@ -185,17 +185,17 @@ export type ParsedApproveTokenDelegateCheckedInstruction<
     delegate: TAccountMetas[2];
     owner: TAccountMetas[3];
   };
-  data: ApproveTokenDelegateCheckedInstructionData;
+  data: ApproveCheckedInstructionData;
 };
 
-export function parseApproveTokenDelegateCheckedInstruction<
+export function parseApproveCheckedInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedApproveTokenDelegateCheckedInstruction<TProgram, TAccountMetas> {
+): ParsedApproveCheckedInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 4) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -214,8 +214,6 @@ export function parseApproveTokenDelegateCheckedInstruction<
       delegate: getNextAccount(),
       owner: getNextAccount(),
     },
-    data: getApproveTokenDelegateCheckedInstructionDataDecoder().decode(
-      instruction.data
-    ),
+    data: getApproveCheckedInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/burnToken.ts → clients/js/src/generated/instructions/burn.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -16,6 +17,7 @@ import {
   IInstruction,
   IInstructionWithAccounts,
   IInstructionWithData,
+  ReadonlyAccount,
   ReadonlySignerAccount,
   TransactionSigner,
   WritableAccount,
@@ -31,7 +33,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type BurnTokenInstruction<
+export type BurnInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount extends string | IAccountMeta<string> = string,
   TAccountMint extends string | IAccountMeta<string> = string,
@@ -48,21 +50,21 @@ export type BurnTokenInstruction<
         ? WritableAccount<TAccountMint>
         : TAccountMint,
       TAccountAuthority extends string
-        ? ReadonlySignerAccount<TAccountAuthority> &
-            IAccountSignerMeta<TAccountAuthority>
+        ? ReadonlyAccount<TAccountAuthority>
         : TAccountAuthority,
       ...TRemainingAccounts,
     ]
   >;
 
-export type BurnTokenInstructionData = {
+export type BurnInstructionData = {
+  /** The amount of tokens to burn. */
   discriminator: number;
   amount: bigint;
 };
 
-export type BurnTokenInstructionDataArgs = { amount: number | bigint };
+export type BurnInstructionDataArgs = { amount: number | bigint };
 
-export function getBurnTokenInstructionDataEncoder(): Encoder<BurnTokenInstructionDataArgs> {
+export function getBurnInstructionDataEncoder(): Encoder<BurnInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
@@ -72,45 +74,52 @@ export function getBurnTokenInstructionDataEncoder(): Encoder<BurnTokenInstructi
   );
 }
 
-export function getBurnTokenInstructionDataDecoder(): Decoder<BurnTokenInstructionData> {
+export function getBurnInstructionDataDecoder(): Decoder<BurnInstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['amount', getU64Decoder()],
   ]);
 }
 
-export function getBurnTokenInstructionDataCodec(): Codec<
-  BurnTokenInstructionDataArgs,
-  BurnTokenInstructionData
+export function getBurnInstructionDataCodec(): Codec<
+  BurnInstructionDataArgs,
+  BurnInstructionData
 > {
   return combineCodec(
-    getBurnTokenInstructionDataEncoder(),
-    getBurnTokenInstructionDataDecoder()
+    getBurnInstructionDataEncoder(),
+    getBurnInstructionDataDecoder()
   );
 }
 
-export type BurnTokenInput<
+export type BurnInput<
   TAccountAccount extends string = string,
   TAccountMint extends string = string,
   TAccountAuthority extends string = string,
 > = {
+  /** The account to burn from. */
   account: Address<TAccountAccount>;
+  /** The token mint. */
   mint: Address<TAccountMint>;
-  authority: TransactionSigner<TAccountAuthority>;
-  amount: BurnTokenInstructionDataArgs['amount'];
+  /** The account's owner/delegate or its multisignature account. */
+  authority: Address<TAccountAuthority> | TransactionSigner<TAccountAuthority>;
+  amount: BurnInstructionDataArgs['amount'];
+  multiSigners?: Array<TransactionSigner>;
 };
 
-export function getBurnTokenInstruction<
+export function getBurnInstruction<
   TAccountAccount extends string,
   TAccountMint extends string,
   TAccountAuthority extends string,
 >(
-  input: BurnTokenInput<TAccountAccount, TAccountMint, TAccountAuthority>
-): BurnTokenInstruction<
+  input: BurnInput<TAccountAccount, TAccountMint, TAccountAuthority>
+): BurnInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount,
   TAccountMint,
-  TAccountAuthority
+  (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+    ? ReadonlySignerAccount<TAccountAuthority> &
+        IAccountSignerMeta<TAccountAuthority>
+    : TAccountAuthority
 > {
   // Program address.
   const programAddress = TOKEN_PROGRAM_ADDRESS;
@@ -129,48 +138,64 @@ export function getBurnTokenInstruction<
   // Original args.
   const args = { ...input };
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
       getAccountMeta(accounts.account),
       getAccountMeta(accounts.mint),
       getAccountMeta(accounts.authority),
+      ...remainingAccounts,
     ],
     programAddress,
-    data: getBurnTokenInstructionDataEncoder().encode(
-      args as BurnTokenInstructionDataArgs
+    data: getBurnInstructionDataEncoder().encode(
+      args as BurnInstructionDataArgs
     ),
-  } as BurnTokenInstruction<
+  } as BurnInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountAccount,
     TAccountMint,
-    TAccountAuthority
+    (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+      ? ReadonlySignerAccount<TAccountAuthority> &
+          IAccountSignerMeta<TAccountAuthority>
+      : TAccountAuthority
   >;
 
   return instruction;
 }
 
-export type ParsedBurnTokenInstruction<
+export type ParsedBurnInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The account to burn from. */
     account: TAccountMetas[0];
+    /** The token mint. */
     mint: TAccountMetas[1];
+    /** The account's owner/delegate or its multisignature account. */
     authority: TAccountMetas[2];
   };
-  data: BurnTokenInstructionData;
+  data: BurnInstructionData;
 };
 
-export function parseBurnTokenInstruction<
+export function parseBurnInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedBurnTokenInstruction<TProgram, TAccountMetas> {
+): ParsedBurnInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 3) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -188,6 +213,6 @@ export function parseBurnTokenInstruction<
       mint: getNextAccount(),
       authority: getNextAccount(),
     },
-    data: getBurnTokenInstructionDataDecoder().decode(instruction.data),
+    data: getBurnInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/burnTokenChecked.ts → clients/js/src/generated/instructions/burnChecked.ts

@@ -31,7 +31,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type BurnTokenCheckedInstruction<
+export type BurnCheckedInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount extends string | IAccountMeta<string> = string,
   TAccountMint extends string | IAccountMeta<string> = string,
@@ -55,18 +55,18 @@ export type BurnTokenCheckedInstruction<
     ]
   >;
 
-export type BurnTokenCheckedInstructionData = {
+export type BurnCheckedInstructionData = {
   discriminator: number;
   amount: bigint;
   decimals: number;
 };
 
-export type BurnTokenCheckedInstructionDataArgs = {
+export type BurnCheckedInstructionDataArgs = {
   amount: number | bigint;
   decimals: number;
 };
 
-export function getBurnTokenCheckedInstructionDataEncoder(): Encoder<BurnTokenCheckedInstructionDataArgs> {
+export function getBurnCheckedInstructionDataEncoder(): Encoder<BurnCheckedInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
@@ -77,7 +77,7 @@ export function getBurnTokenCheckedInstructionDataEncoder(): Encoder<BurnTokenCh
   );
 }
 
-export function getBurnTokenCheckedInstructionDataDecoder(): Decoder<BurnTokenCheckedInstructionData> {
+export function getBurnCheckedInstructionDataDecoder(): Decoder<BurnCheckedInstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['amount', getU64Decoder()],
@@ -85,17 +85,17 @@ export function getBurnTokenCheckedInstructionDataDecoder(): Decoder<BurnTokenCh
   ]);
 }
 
-export function getBurnTokenCheckedInstructionDataCodec(): Codec<
-  BurnTokenCheckedInstructionDataArgs,
-  BurnTokenCheckedInstructionData
+export function getBurnCheckedInstructionDataCodec(): Codec<
+  BurnCheckedInstructionDataArgs,
+  BurnCheckedInstructionData
 > {
   return combineCodec(
-    getBurnTokenCheckedInstructionDataEncoder(),
-    getBurnTokenCheckedInstructionDataDecoder()
+    getBurnCheckedInstructionDataEncoder(),
+    getBurnCheckedInstructionDataDecoder()
   );
 }
 
-export type BurnTokenCheckedInput<
+export type BurnCheckedInput<
   TAccountAccount extends string = string,
   TAccountMint extends string = string,
   TAccountAuthority extends string = string,
@@ -103,17 +103,17 @@ export type BurnTokenCheckedInput<
   account: Address<TAccountAccount>;
   mint: Address<TAccountMint>;
   authority: TransactionSigner<TAccountAuthority>;
-  amount: BurnTokenCheckedInstructionDataArgs['amount'];
-  decimals: BurnTokenCheckedInstructionDataArgs['decimals'];
+  amount: BurnCheckedInstructionDataArgs['amount'];
+  decimals: BurnCheckedInstructionDataArgs['decimals'];
 };
 
-export function getBurnTokenCheckedInstruction<
+export function getBurnCheckedInstruction<
   TAccountAccount extends string,
   TAccountMint extends string,
   TAccountAuthority extends string,
 >(
-  input: BurnTokenCheckedInput<TAccountAccount, TAccountMint, TAccountAuthority>
-): BurnTokenCheckedInstruction<
+  input: BurnCheckedInput<TAccountAccount, TAccountMint, TAccountAuthority>
+): BurnCheckedInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount,
   TAccountMint,
@@ -144,10 +144,10 @@ export function getBurnTokenCheckedInstruction<
       getAccountMeta(accounts.authority),
     ],
     programAddress,
-    data: getBurnTokenCheckedInstructionDataEncoder().encode(
-      args as BurnTokenCheckedInstructionDataArgs
+    data: getBurnCheckedInstructionDataEncoder().encode(
+      args as BurnCheckedInstructionDataArgs
     ),
-  } as BurnTokenCheckedInstruction<
+  } as BurnCheckedInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountAccount,
     TAccountMint,
@@ -157,7 +157,7 @@ export function getBurnTokenCheckedInstruction<
   return instruction;
 }
 
-export type ParsedBurnTokenCheckedInstruction<
+export type ParsedBurnCheckedInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
@@ -167,17 +167,17 @@ export type ParsedBurnTokenCheckedInstruction<
     mint: TAccountMetas[1];
     authority: TAccountMetas[2];
   };
-  data: BurnTokenCheckedInstructionData;
+  data: BurnCheckedInstructionData;
 };
 
-export function parseBurnTokenCheckedInstruction<
+export function parseBurnCheckedInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedBurnTokenCheckedInstruction<TProgram, TAccountMetas> {
+): ParsedBurnCheckedInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 3) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -195,6 +195,6 @@ export function parseBurnTokenCheckedInstruction<
       mint: getNextAccount(),
       authority: getNextAccount(),
     },
-    data: getBurnTokenCheckedInstructionDataDecoder().decode(instruction.data),
+    data: getBurnCheckedInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/closeToken.ts → clients/js/src/generated/instructions/closeAccount.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -16,6 +17,7 @@ import {
   IInstruction,
   IInstructionWithAccounts,
   IInstructionWithData,
+  ReadonlyAccount,
   ReadonlySignerAccount,
   TransactionSigner,
   WritableAccount,
@@ -29,7 +31,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type CloseTokenInstruction<
+export type CloseAccountInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount extends string | IAccountMeta<string> = string,
   TAccountDestination extends string | IAccountMeta<string> = string,
@@ -46,59 +48,64 @@ export type CloseTokenInstruction<
         ? WritableAccount<TAccountDestination>
         : TAccountDestination,
       TAccountOwner extends string
-        ? ReadonlySignerAccount<TAccountOwner> &
-            IAccountSignerMeta<TAccountOwner>
+        ? ReadonlyAccount<TAccountOwner>
         : TAccountOwner,
       ...TRemainingAccounts,
     ]
   >;
 
-export type CloseTokenInstructionData = { discriminator: number };
+export type CloseAccountInstructionData = { discriminator: number };
 
-export type CloseTokenInstructionDataArgs = {};
+export type CloseAccountInstructionDataArgs = {};
 
-export function getCloseTokenInstructionDataEncoder(): Encoder<CloseTokenInstructionDataArgs> {
+export function getCloseAccountInstructionDataEncoder(): Encoder<CloseAccountInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([['discriminator', getU8Encoder()]]),
     (value) => ({ ...value, discriminator: 9 })
   );
 }
 
-export function getCloseTokenInstructionDataDecoder(): Decoder<CloseTokenInstructionData> {
+export function getCloseAccountInstructionDataDecoder(): Decoder<CloseAccountInstructionData> {
   return getStructDecoder([['discriminator', getU8Decoder()]]);
 }
 
-export function getCloseTokenInstructionDataCodec(): Codec<
-  CloseTokenInstructionDataArgs,
-  CloseTokenInstructionData
+export function getCloseAccountInstructionDataCodec(): Codec<
+  CloseAccountInstructionDataArgs,
+  CloseAccountInstructionData
 > {
   return combineCodec(
-    getCloseTokenInstructionDataEncoder(),
-    getCloseTokenInstructionDataDecoder()
+    getCloseAccountInstructionDataEncoder(),
+    getCloseAccountInstructionDataDecoder()
   );
 }
 
-export type CloseTokenInput<
+export type CloseAccountInput<
   TAccountAccount extends string = string,
   TAccountDestination extends string = string,
   TAccountOwner extends string = string,
 > = {
+  /** The account to close. */
   account: Address<TAccountAccount>;
+  /** The destination account. */
   destination: Address<TAccountDestination>;
-  owner: TransactionSigner<TAccountOwner>;
+  /** The account's owner or its multisignature account. */
+  owner: Address<TAccountOwner> | TransactionSigner<TAccountOwner>;
+  multiSigners?: Array<TransactionSigner>;
 };
 
-export function getCloseTokenInstruction<
+export function getCloseAccountInstruction<
   TAccountAccount extends string,
   TAccountDestination extends string,
   TAccountOwner extends string,
 >(
-  input: CloseTokenInput<TAccountAccount, TAccountDestination, TAccountOwner>
-): CloseTokenInstruction<
+  input: CloseAccountInput<TAccountAccount, TAccountDestination, TAccountOwner>
+): CloseAccountInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount,
   TAccountDestination,
-  TAccountOwner
+  (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+    ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+    : TAccountOwner
 > {
   // Program address.
   const programAddress = TOKEN_PROGRAM_ADDRESS;
@@ -114,46 +121,61 @@ export function getCloseTokenInstruction<
     ResolvedAccount
   >;
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
       getAccountMeta(accounts.account),
       getAccountMeta(accounts.destination),
       getAccountMeta(accounts.owner),
+      ...remainingAccounts,
     ],
     programAddress,
-    data: getCloseTokenInstructionDataEncoder().encode({}),
-  } as CloseTokenInstruction<
+    data: getCloseAccountInstructionDataEncoder().encode({}),
+  } as CloseAccountInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountAccount,
     TAccountDestination,
-    TAccountOwner
+    (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+      ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+      : TAccountOwner
   >;
 
   return instruction;
 }
 
-export type ParsedCloseTokenInstruction<
+export type ParsedCloseAccountInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The account to close. */
     account: TAccountMetas[0];
+    /** The destination account. */
     destination: TAccountMetas[1];
+    /** The account's owner or its multisignature account. */
     owner: TAccountMetas[2];
   };
-  data: CloseTokenInstructionData;
+  data: CloseAccountInstructionData;
 };
 
-export function parseCloseTokenInstruction<
+export function parseCloseAccountInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedCloseTokenInstruction<TProgram, TAccountMetas> {
+): ParsedCloseAccountInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 3) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -171,6 +193,6 @@ export function parseCloseTokenInstruction<
       destination: getNextAccount(),
       owner: getNextAccount(),
     },
-    data: getCloseTokenInstructionDataDecoder().decode(instruction.data),
+    data: getCloseAccountInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/freezeToken.ts → clients/js/src/generated/instructions/freezeAccount.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -30,7 +31,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type FreezeTokenInstruction<
+export type FreezeAccountInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount extends string | IAccountMeta<string> = string,
   TAccountMint extends string | IAccountMeta<string> = string,
@@ -47,59 +48,64 @@ export type FreezeTokenInstruction<
         ? ReadonlyAccount<TAccountMint>
         : TAccountMint,
       TAccountOwner extends string
-        ? ReadonlySignerAccount<TAccountOwner> &
-            IAccountSignerMeta<TAccountOwner>
+        ? ReadonlyAccount<TAccountOwner>
         : TAccountOwner,
       ...TRemainingAccounts,
     ]
   >;
 
-export type FreezeTokenInstructionData = { discriminator: number };
+export type FreezeAccountInstructionData = { discriminator: number };
 
-export type FreezeTokenInstructionDataArgs = {};
+export type FreezeAccountInstructionDataArgs = {};
 
-export function getFreezeTokenInstructionDataEncoder(): Encoder<FreezeTokenInstructionDataArgs> {
+export function getFreezeAccountInstructionDataEncoder(): Encoder<FreezeAccountInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([['discriminator', getU8Encoder()]]),
     (value) => ({ ...value, discriminator: 10 })
   );
 }
 
-export function getFreezeTokenInstructionDataDecoder(): Decoder<FreezeTokenInstructionData> {
+export function getFreezeAccountInstructionDataDecoder(): Decoder<FreezeAccountInstructionData> {
   return getStructDecoder([['discriminator', getU8Decoder()]]);
 }
 
-export function getFreezeTokenInstructionDataCodec(): Codec<
-  FreezeTokenInstructionDataArgs,
-  FreezeTokenInstructionData
+export function getFreezeAccountInstructionDataCodec(): Codec<
+  FreezeAccountInstructionDataArgs,
+  FreezeAccountInstructionData
 > {
   return combineCodec(
-    getFreezeTokenInstructionDataEncoder(),
-    getFreezeTokenInstructionDataDecoder()
+    getFreezeAccountInstructionDataEncoder(),
+    getFreezeAccountInstructionDataDecoder()
   );
 }
 
-export type FreezeTokenInput<
+export type FreezeAccountInput<
   TAccountAccount extends string = string,
   TAccountMint extends string = string,
   TAccountOwner extends string = string,
 > = {
+  /** The account to freeze. */
   account: Address<TAccountAccount>;
+  /** The token mint. */
   mint: Address<TAccountMint>;
-  owner: TransactionSigner<TAccountOwner>;
+  /** The mint freeze authority or its multisignature account. */
+  owner: Address<TAccountOwner> | TransactionSigner<TAccountOwner>;
+  multiSigners?: Array<TransactionSigner>;
 };
 
-export function getFreezeTokenInstruction<
+export function getFreezeAccountInstruction<
   TAccountAccount extends string,
   TAccountMint extends string,
   TAccountOwner extends string,
 >(
-  input: FreezeTokenInput<TAccountAccount, TAccountMint, TAccountOwner>
-): FreezeTokenInstruction<
+  input: FreezeAccountInput<TAccountAccount, TAccountMint, TAccountOwner>
+): FreezeAccountInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount,
   TAccountMint,
-  TAccountOwner
+  (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+    ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+    : TAccountOwner
 > {
   // Program address.
   const programAddress = TOKEN_PROGRAM_ADDRESS;
@@ -115,46 +121,61 @@ export function getFreezeTokenInstruction<
     ResolvedAccount
   >;
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
       getAccountMeta(accounts.account),
       getAccountMeta(accounts.mint),
       getAccountMeta(accounts.owner),
+      ...remainingAccounts,
     ],
     programAddress,
-    data: getFreezeTokenInstructionDataEncoder().encode({}),
-  } as FreezeTokenInstruction<
+    data: getFreezeAccountInstructionDataEncoder().encode({}),
+  } as FreezeAccountInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountAccount,
     TAccountMint,
-    TAccountOwner
+    (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+      ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+      : TAccountOwner
   >;
 
   return instruction;
 }
 
-export type ParsedFreezeTokenInstruction<
+export type ParsedFreezeAccountInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The account to freeze. */
     account: TAccountMetas[0];
+    /** The token mint. */
     mint: TAccountMetas[1];
+    /** The mint freeze authority or its multisignature account. */
     owner: TAccountMetas[2];
   };
-  data: FreezeTokenInstructionData;
+  data: FreezeAccountInstructionData;
 };
 
-export function parseFreezeTokenInstruction<
+export function parseFreezeAccountInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedFreezeTokenInstruction<TProgram, TAccountMetas> {
+): ParsedFreezeAccountInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 3) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -172,6 +193,6 @@ export function parseFreezeTokenInstruction<
       mint: getNextAccount(),
       owner: getNextAccount(),
     },
-    data: getFreezeTokenInstructionDataDecoder().decode(instruction.data),
+    data: getFreezeAccountInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/index.ts

@@ -7,30 +7,30 @@
  */
 
 export * from './amountToUiAmount';
-export * from './approveTokenDelegate';
-export * from './approveTokenDelegateChecked';
-export * from './burnToken';
-export * from './burnTokenChecked';
-export * from './closeToken';
+export * from './approve';
+export * from './approveChecked';
+export * from './burn';
+export * from './burnChecked';
+export * from './closeAccount';
 export * from './createAssociatedToken';
 export * from './createIdempotentAssociatedToken';
-export * from './freezeToken';
+export * from './freezeAccount';
 export * from './getTokenDataSize';
+export * from './initializeAccount';
+export * from './initializeAccount2';
+export * from './initializeAccount3';
 export * from './initializeImmutableOwner';
 export * from './initializeMint';
 export * from './initializeMint2';
 export * from './initializeMultisig';
 export * from './initializeMultisig2';
-export * from './initializeToken';
-export * from './initializeToken2';
-export * from './initializeToken3';
-export * from './mintTokensTo';
+export * from './mintTo';
 export * from './mintTokensToChecked';
 export * from './recoverNestedAssociatedToken';
-export * from './revokeTokenDelegate';
+export * from './revoke';
 export * from './setAuthority';
 export * from './syncNative';
-export * from './thawToken';
-export * from './transferTokens';
-export * from './transferTokensChecked';
+export * from './thawAccount';
+export * from './transfer';
+export * from './transferChecked';
 export * from './uiAmountToAmount';

clients/js/src/generated/instructions/initializeToken.ts → clients/js/src/generated/instructions/initializeAccount.ts

@@ -27,7 +27,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type InitializeTokenInstruction<
+export type InitializeAccountInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount extends string | IAccountMeta<string> = string,
   TAccountMint extends string | IAccountMeta<string> = string,
@@ -56,56 +56,60 @@ export type InitializeTokenInstruction<
     ]
   >;
 
-export type InitializeTokenInstructionData = { discriminator: number };
+export type InitializeAccountInstructionData = { discriminator: number };
 
-export type InitializeTokenInstructionDataArgs = {};
+export type InitializeAccountInstructionDataArgs = {};
 
-export function getInitializeTokenInstructionDataEncoder(): Encoder<InitializeTokenInstructionDataArgs> {
+export function getInitializeAccountInstructionDataEncoder(): Encoder<InitializeAccountInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([['discriminator', getU8Encoder()]]),
     (value) => ({ ...value, discriminator: 1 })
   );
 }
 
-export function getInitializeTokenInstructionDataDecoder(): Decoder<InitializeTokenInstructionData> {
+export function getInitializeAccountInstructionDataDecoder(): Decoder<InitializeAccountInstructionData> {
   return getStructDecoder([['discriminator', getU8Decoder()]]);
 }
 
-export function getInitializeTokenInstructionDataCodec(): Codec<
-  InitializeTokenInstructionDataArgs,
-  InitializeTokenInstructionData
+export function getInitializeAccountInstructionDataCodec(): Codec<
+  InitializeAccountInstructionDataArgs,
+  InitializeAccountInstructionData
 > {
   return combineCodec(
-    getInitializeTokenInstructionDataEncoder(),
-    getInitializeTokenInstructionDataDecoder()
+    getInitializeAccountInstructionDataEncoder(),
+    getInitializeAccountInstructionDataDecoder()
   );
 }
 
-export type InitializeTokenInput<
+export type InitializeAccountInput<
   TAccountAccount extends string = string,
   TAccountMint extends string = string,
   TAccountOwner extends string = string,
   TAccountRent extends string = string,
 > = {
+  /** The account to initialize. */
   account: Address<TAccountAccount>;
+  /** The mint this account will be associated with. */
   mint: Address<TAccountMint>;
+  /** The new account's owner/multisignature. */
   owner: Address<TAccountOwner>;
+  /** Rent sysvar. */
   rent?: Address<TAccountRent>;
 };
 
-export function getInitializeTokenInstruction<
+export function getInitializeAccountInstruction<
   TAccountAccount extends string,
   TAccountMint extends string,
   TAccountOwner extends string,
   TAccountRent extends string,
 >(
-  input: InitializeTokenInput<
+  input: InitializeAccountInput<
     TAccountAccount,
     TAccountMint,
     TAccountOwner,
     TAccountRent
   >
-): InitializeTokenInstruction<
+): InitializeAccountInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount,
   TAccountMint,
@@ -142,8 +146,8 @@ export function getInitializeTokenInstruction<
       getAccountMeta(accounts.rent),
     ],
     programAddress,
-    data: getInitializeTokenInstructionDataEncoder().encode({}),
-  } as InitializeTokenInstruction<
+    data: getInitializeAccountInstructionDataEncoder().encode({}),
+  } as InitializeAccountInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountAccount,
     TAccountMint,
@@ -154,28 +158,32 @@ export function getInitializeTokenInstruction<
   return instruction;
 }
 
-export type ParsedInitializeTokenInstruction<
+export type ParsedInitializeAccountInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The account to initialize. */
     account: TAccountMetas[0];
+    /** The mint this account will be associated with. */
     mint: TAccountMetas[1];
+    /** The new account's owner/multisignature. */
     owner: TAccountMetas[2];
+    /** Rent sysvar. */
     rent: TAccountMetas[3];
   };
-  data: InitializeTokenInstructionData;
+  data: InitializeAccountInstructionData;
 };
 
-export function parseInitializeTokenInstruction<
+export function parseInitializeAccountInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedInitializeTokenInstruction<TProgram, TAccountMetas> {
+): ParsedInitializeAccountInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 4) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -194,6 +202,6 @@ export function parseInitializeTokenInstruction<
       owner: getNextAccount(),
       rent: getNextAccount(),
     },
-    data: getInitializeTokenInstructionDataDecoder().decode(instruction.data),
+    data: getInitializeAccountInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/initializeToken2.ts → clients/js/src/generated/instructions/initializeAccount2.ts

@@ -29,7 +29,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type InitializeToken2Instruction<
+export type InitializeAccount2Instruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount extends string | IAccountMeta<string> = string,
   TAccountMint extends string | IAccountMeta<string> = string,
@@ -54,14 +54,14 @@ export type InitializeToken2Instruction<
     ]
   >;
 
-export type InitializeToken2InstructionData = {
+export type InitializeAccount2InstructionData = {
   discriminator: number;
   owner: Address;
 };
 
-export type InitializeToken2InstructionDataArgs = { owner: Address };
+export type InitializeAccount2InstructionDataArgs = { owner: Address };
 
-export function getInitializeToken2InstructionDataEncoder(): Encoder<InitializeToken2InstructionDataArgs> {
+export function getInitializeAccount2InstructionDataEncoder(): Encoder<InitializeAccount2InstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
@@ -71,24 +71,24 @@ export function getInitializeToken2InstructionDataEncoder(): Encoder<InitializeT
   );
 }
 
-export function getInitializeToken2InstructionDataDecoder(): Decoder<InitializeToken2InstructionData> {
+export function getInitializeAccount2InstructionDataDecoder(): Decoder<InitializeAccount2InstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['owner', getAddressDecoder()],
   ]);
 }
 
-export function getInitializeToken2InstructionDataCodec(): Codec<
-  InitializeToken2InstructionDataArgs,
-  InitializeToken2InstructionData
+export function getInitializeAccount2InstructionDataCodec(): Codec<
+  InitializeAccount2InstructionDataArgs,
+  InitializeAccount2InstructionData
 > {
   return combineCodec(
-    getInitializeToken2InstructionDataEncoder(),
-    getInitializeToken2InstructionDataDecoder()
+    getInitializeAccount2InstructionDataEncoder(),
+    getInitializeAccount2InstructionDataDecoder()
   );
 }
 
-export type InitializeToken2Input<
+export type InitializeAccount2Input<
   TAccountAccount extends string = string,
   TAccountMint extends string = string,
   TAccountRent extends string = string,
@@ -96,16 +96,16 @@ export type InitializeToken2Input<
   account: Address<TAccountAccount>;
   mint: Address<TAccountMint>;
   rent?: Address<TAccountRent>;
-  owner: InitializeToken2InstructionDataArgs['owner'];
+  owner: InitializeAccount2InstructionDataArgs['owner'];
 };
 
-export function getInitializeToken2Instruction<
+export function getInitializeAccount2Instruction<
   TAccountAccount extends string,
   TAccountMint extends string,
   TAccountRent extends string,
 >(
-  input: InitializeToken2Input<TAccountAccount, TAccountMint, TAccountRent>
-): InitializeToken2Instruction<
+  input: InitializeAccount2Input<TAccountAccount, TAccountMint, TAccountRent>
+): InitializeAccount2Instruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount,
   TAccountMint,
@@ -142,10 +142,10 @@ export function getInitializeToken2Instruction<
       getAccountMeta(accounts.rent),
     ],
     programAddress,
-    data: getInitializeToken2InstructionDataEncoder().encode(
-      args as InitializeToken2InstructionDataArgs
+    data: getInitializeAccount2InstructionDataEncoder().encode(
+      args as InitializeAccount2InstructionDataArgs
     ),
-  } as InitializeToken2Instruction<
+  } as InitializeAccount2Instruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountAccount,
     TAccountMint,
@@ -155,7 +155,7 @@ export function getInitializeToken2Instruction<
   return instruction;
 }
 
-export type ParsedInitializeToken2Instruction<
+export type ParsedInitializeAccount2Instruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
@@ -165,17 +165,17 @@ export type ParsedInitializeToken2Instruction<
     mint: TAccountMetas[1];
     rent: TAccountMetas[2];
   };
-  data: InitializeToken2InstructionData;
+  data: InitializeAccount2InstructionData;
 };
 
-export function parseInitializeToken2Instruction<
+export function parseInitializeAccount2Instruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedInitializeToken2Instruction<TProgram, TAccountMetas> {
+): ParsedInitializeAccount2Instruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 3) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -193,6 +193,8 @@ export function parseInitializeToken2Instruction<
       mint: getNextAccount(),
       rent: getNextAccount(),
     },
-    data: getInitializeToken2InstructionDataDecoder().decode(instruction.data),
+    data: getInitializeAccount2InstructionDataDecoder().decode(
+      instruction.data
+    ),
   };
 }

clients/js/src/generated/instructions/initializeToken3.ts → clients/js/src/generated/instructions/initializeAccount3.ts

@@ -29,7 +29,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type InitializeToken3Instruction<
+export type InitializeAccount3Instruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount extends string | IAccountMeta<string> = string,
   TAccountMint extends string | IAccountMeta<string> = string,
@@ -48,14 +48,14 @@ export type InitializeToken3Instruction<
     ]
   >;
 
-export type InitializeToken3InstructionData = {
+export type InitializeAccount3InstructionData = {
   discriminator: number;
   owner: Address;
 };
 
-export type InitializeToken3InstructionDataArgs = { owner: Address };
+export type InitializeAccount3InstructionDataArgs = { owner: Address };
 
-export function getInitializeToken3InstructionDataEncoder(): Encoder<InitializeToken3InstructionDataArgs> {
+export function getInitializeAccount3InstructionDataEncoder(): Encoder<InitializeAccount3InstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
@@ -65,38 +65,38 @@ export function getInitializeToken3InstructionDataEncoder(): Encoder<InitializeT
   );
 }
 
-export function getInitializeToken3InstructionDataDecoder(): Decoder<InitializeToken3InstructionData> {
+export function getInitializeAccount3InstructionDataDecoder(): Decoder<InitializeAccount3InstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['owner', getAddressDecoder()],
   ]);
 }
 
-export function getInitializeToken3InstructionDataCodec(): Codec<
-  InitializeToken3InstructionDataArgs,
-  InitializeToken3InstructionData
+export function getInitializeAccount3InstructionDataCodec(): Codec<
+  InitializeAccount3InstructionDataArgs,
+  InitializeAccount3InstructionData
 > {
   return combineCodec(
-    getInitializeToken3InstructionDataEncoder(),
-    getInitializeToken3InstructionDataDecoder()
+    getInitializeAccount3InstructionDataEncoder(),
+    getInitializeAccount3InstructionDataDecoder()
   );
 }
 
-export type InitializeToken3Input<
+export type InitializeAccount3Input<
   TAccountAccount extends string = string,
   TAccountMint extends string = string,
 > = {
   account: Address<TAccountAccount>;
   mint: Address<TAccountMint>;
-  owner: InitializeToken3InstructionDataArgs['owner'];
+  owner: InitializeAccount3InstructionDataArgs['owner'];
 };
 
-export function getInitializeToken3Instruction<
+export function getInitializeAccount3Instruction<
   TAccountAccount extends string,
   TAccountMint extends string,
 >(
-  input: InitializeToken3Input<TAccountAccount, TAccountMint>
-): InitializeToken3Instruction<
+  input: InitializeAccount3Input<TAccountAccount, TAccountMint>
+): InitializeAccount3Instruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount,
   TAccountMint
@@ -121,10 +121,10 @@ export function getInitializeToken3Instruction<
   const instruction = {
     accounts: [getAccountMeta(accounts.account), getAccountMeta(accounts.mint)],
     programAddress,
-    data: getInitializeToken3InstructionDataEncoder().encode(
-      args as InitializeToken3InstructionDataArgs
+    data: getInitializeAccount3InstructionDataEncoder().encode(
+      args as InitializeAccount3InstructionDataArgs
     ),
-  } as InitializeToken3Instruction<
+  } as InitializeAccount3Instruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountAccount,
     TAccountMint
@@ -133,7 +133,7 @@ export function getInitializeToken3Instruction<
   return instruction;
 }
 
-export type ParsedInitializeToken3Instruction<
+export type ParsedInitializeAccount3Instruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
@@ -142,17 +142,17 @@ export type ParsedInitializeToken3Instruction<
     account: TAccountMetas[0];
     mint: TAccountMetas[1];
   };
-  data: InitializeToken3InstructionData;
+  data: InitializeAccount3InstructionData;
 };
 
-export function parseInitializeToken3Instruction<
+export function parseInitializeAccount3Instruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedInitializeToken3Instruction<TProgram, TAccountMetas> {
+): ParsedInitializeAccount3Instruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 2) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -169,6 +169,8 @@ export function parseInitializeToken3Instruction<
       account: getNextAccount(),
       mint: getNextAccount(),
     },
-    data: getInitializeToken3InstructionDataDecoder().decode(instruction.data),
+    data: getInitializeAccount3InstructionDataDecoder().decode(
+      instruction.data
+    ),
   };
 }

clients/js/src/generated/instructions/initializeMint.ts

@@ -26,6 +26,8 @@ import {
   getOptionEncoder,
   getStructDecoder,
   getStructEncoder,
+  getU32Decoder,
+  getU32Encoder,
   getU8Decoder,
   getU8Encoder,
   transformEncoder,
@@ -56,14 +58,20 @@ export type InitializeMintInstruction<
 
 export type InitializeMintInstructionData = {
   discriminator: number;
+  /** Number of decimals in token account amounts. */
   decimals: number;
+  /** Minting authority. */
   mintAuthority: Address;
+  /** Optional authority that can freeze token accounts. */
   freezeAuthority: Option<Address>;
 };
 
 export type InitializeMintInstructionDataArgs = {
+  /** Number of decimals in token account amounts. */
   decimals: number;
+  /** Minting authority. */
   mintAuthority: Address;
+  /** Optional authority that can freeze token accounts. */
   freezeAuthority: OptionOrNullable<Address>;
 };
 
@@ -73,7 +81,13 @@ export function getInitializeMintInstructionDataEncoder(): Encoder<InitializeMin
       ['discriminator', getU8Encoder()],
       ['decimals', getU8Encoder()],
       ['mintAuthority', getAddressEncoder()],
-      ['freezeAuthority', getOptionEncoder(getAddressEncoder())],
+      [
+        'freezeAuthority',
+        getOptionEncoder(getAddressEncoder(), {
+          prefix: getU32Encoder(),
+          fixed: true,
+        }),
+      ],
     ]),
     (value) => ({ ...value, discriminator: 0 })
   );
@@ -84,7 +98,13 @@ export function getInitializeMintInstructionDataDecoder(): Decoder<InitializeMin
     ['discriminator', getU8Decoder()],
     ['decimals', getU8Decoder()],
     ['mintAuthority', getAddressDecoder()],
-    ['freezeAuthority', getOptionDecoder(getAddressDecoder())],
+    [
+      'freezeAuthority',
+      getOptionDecoder(getAddressDecoder(), {
+        prefix: getU32Decoder(),
+        fixed: true,
+      }),
+    ],
   ]);
 }
 
@@ -102,7 +122,9 @@ export type InitializeMintInput<
   TAccountMint extends string = string,
   TAccountRent extends string = string,
 > = {
+  /** Token mint account. */
   mint: Address<TAccountMint>;
+  /** Rent sysvar. */
   rent?: Address<TAccountRent>;
   decimals: InitializeMintInstructionDataArgs['decimals'];
   mintAuthority: InitializeMintInstructionDataArgs['mintAuthority'];
@@ -163,7 +185,9 @@ export type ParsedInitializeMintInstruction<
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** Token mint account. */
     mint: TAccountMetas[0];
+    /** Rent sysvar. */
     rent: TAccountMetas[1];
   };
   data: InitializeMintInstructionData;

clients/js/src/generated/instructions/initializeMultisig.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -50,10 +51,14 @@ export type InitializeMultisigInstruction<
 
 export type InitializeMultisigInstructionData = {
   discriminator: number;
+  /** The number of signers (M) required to validate this multisignature account. */
   m: number;
 };
 
-export type InitializeMultisigInstructionDataArgs = { m: number };
+export type InitializeMultisigInstructionDataArgs = {
+  /** The number of signers (M) required to validate this multisignature account. */
+  m: number;
+};
 
 export function getInitializeMultisigInstructionDataEncoder(): Encoder<InitializeMultisigInstructionDataArgs> {
   return transformEncoder(
@@ -86,9 +91,12 @@ export type InitializeMultisigInput<
   TAccountMultisig extends string = string,
   TAccountRent extends string = string,
 > = {
+  /** The multisignature account to initialize. */
   multisig: Address<TAccountMultisig>;
+  /** Rent sysvar. */
   rent?: Address<TAccountRent>;
   m: InitializeMultisigInstructionDataArgs['m'];
+  signers?: Array<Address>;
 };
 
 export function getInitializeMultisigInstruction<
@@ -123,11 +131,17 @@ export function getInitializeMultisigInstruction<
       'SysvarRent111111111111111111111111111111111' as Address<'SysvarRent111111111111111111111111111111111'>;
   }
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.signers ?? []).map(
+    (address) => ({ address, role: AccountRole.READONLY })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
       getAccountMeta(accounts.multisig),
       getAccountMeta(accounts.rent),
+      ...remainingAccounts,
     ],
     programAddress,
     data: getInitializeMultisigInstructionDataEncoder().encode(
@@ -148,7 +162,9 @@ export type ParsedInitializeMultisigInstruction<
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The multisignature account to initialize. */
     multisig: TAccountMetas[0];
+    /** Rent sysvar. */
     rent: TAccountMetas[1];
   };
   data: InitializeMultisigInstructionData;

clients/js/src/generated/instructions/mintTokensTo.ts → clients/js/src/generated/instructions/mintTo.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -16,6 +17,7 @@ import {
   IInstruction,
   IInstructionWithAccounts,
   IInstructionWithData,
+  ReadonlyAccount,
   ReadonlySignerAccount,
   TransactionSigner,
   WritableAccount,
@@ -31,7 +33,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type MintTokensToInstruction<
+export type MintToInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMint extends string | IAccountMeta<string> = string,
   TAccountToken extends string | IAccountMeta<string> = string,
@@ -48,21 +50,24 @@ export type MintTokensToInstruction<
         ? WritableAccount<TAccountToken>
         : TAccountToken,
       TAccountMintAuthority extends string
-        ? ReadonlySignerAccount<TAccountMintAuthority> &
-            IAccountSignerMeta<TAccountMintAuthority>
+        ? ReadonlyAccount<TAccountMintAuthority>
         : TAccountMintAuthority,
       ...TRemainingAccounts,
     ]
   >;
 
-export type MintTokensToInstructionData = {
+export type MintToInstructionData = {
   discriminator: number;
+  /** The amount of new tokens to mint. */
   amount: bigint;
 };
 
-export type MintTokensToInstructionDataArgs = { amount: number | bigint };
+export type MintToInstructionDataArgs = {
+  /** The amount of new tokens to mint. */
+  amount: number | bigint;
+};
 
-export function getMintTokensToInstructionDataEncoder(): Encoder<MintTokensToInstructionDataArgs> {
+export function getMintToInstructionDataEncoder(): Encoder<MintToInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
@@ -72,45 +77,54 @@ export function getMintTokensToInstructionDataEncoder(): Encoder<MintTokensToIns
   );
 }
 
-export function getMintTokensToInstructionDataDecoder(): Decoder<MintTokensToInstructionData> {
+export function getMintToInstructionDataDecoder(): Decoder<MintToInstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['amount', getU64Decoder()],
   ]);
 }
 
-export function getMintTokensToInstructionDataCodec(): Codec<
-  MintTokensToInstructionDataArgs,
-  MintTokensToInstructionData
+export function getMintToInstructionDataCodec(): Codec<
+  MintToInstructionDataArgs,
+  MintToInstructionData
 > {
   return combineCodec(
-    getMintTokensToInstructionDataEncoder(),
-    getMintTokensToInstructionDataDecoder()
+    getMintToInstructionDataEncoder(),
+    getMintToInstructionDataDecoder()
   );
 }
 
-export type MintTokensToInput<
+export type MintToInput<
   TAccountMint extends string = string,
   TAccountToken extends string = string,
   TAccountMintAuthority extends string = string,
 > = {
+  /** The mint account. */
   mint: Address<TAccountMint>;
+  /** The account to mint tokens to. */
   token: Address<TAccountToken>;
-  mintAuthority: TransactionSigner<TAccountMintAuthority>;
-  amount: MintTokensToInstructionDataArgs['amount'];
+  /** The mint's minting authority or its multisignature account. */
+  mintAuthority:
+    | Address<TAccountMintAuthority>
+    | TransactionSigner<TAccountMintAuthority>;
+  amount: MintToInstructionDataArgs['amount'];
+  multiSigners?: Array<TransactionSigner>;
 };
 
-export function getMintTokensToInstruction<
+export function getMintToInstruction<
   TAccountMint extends string,
   TAccountToken extends string,
   TAccountMintAuthority extends string,
 >(
-  input: MintTokensToInput<TAccountMint, TAccountToken, TAccountMintAuthority>
-): MintTokensToInstruction<
+  input: MintToInput<TAccountMint, TAccountToken, TAccountMintAuthority>
+): MintToInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMint,
   TAccountToken,
-  TAccountMintAuthority
+  (typeof input)['mintAuthority'] extends TransactionSigner<TAccountMintAuthority>
+    ? ReadonlySignerAccount<TAccountMintAuthority> &
+        IAccountSignerMeta<TAccountMintAuthority>
+    : TAccountMintAuthority
 > {
   // Program address.
   const programAddress = TOKEN_PROGRAM_ADDRESS;
@@ -129,48 +143,64 @@ export function getMintTokensToInstruction<
   // Original args.
   const args = { ...input };
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
       getAccountMeta(accounts.mint),
       getAccountMeta(accounts.token),
       getAccountMeta(accounts.mintAuthority),
+      ...remainingAccounts,
     ],
     programAddress,
-    data: getMintTokensToInstructionDataEncoder().encode(
-      args as MintTokensToInstructionDataArgs
+    data: getMintToInstructionDataEncoder().encode(
+      args as MintToInstructionDataArgs
     ),
-  } as MintTokensToInstruction<
+  } as MintToInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountMint,
     TAccountToken,
-    TAccountMintAuthority
+    (typeof input)['mintAuthority'] extends TransactionSigner<TAccountMintAuthority>
+      ? ReadonlySignerAccount<TAccountMintAuthority> &
+          IAccountSignerMeta<TAccountMintAuthority>
+      : TAccountMintAuthority
   >;
 
   return instruction;
 }
 
-export type ParsedMintTokensToInstruction<
+export type ParsedMintToInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The mint account. */
     mint: TAccountMetas[0];
+    /** The account to mint tokens to. */
     token: TAccountMetas[1];
+    /** The mint's minting authority or its multisignature account. */
     mintAuthority: TAccountMetas[2];
   };
-  data: MintTokensToInstructionData;
+  data: MintToInstructionData;
 };
 
-export function parseMintTokensToInstruction<
+export function parseMintToInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedMintTokensToInstruction<TProgram, TAccountMetas> {
+): ParsedMintToInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 3) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -188,6 +218,6 @@ export function parseMintTokensToInstruction<
       token: getNextAccount(),
       mintAuthority: getNextAccount(),
     },
-    data: getMintTokensToInstructionDataDecoder().decode(instruction.data),
+    data: getMintToInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/revokeTokenDelegate.ts → clients/js/src/generated/instructions/revoke.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -16,6 +17,7 @@ import {
   IInstruction,
   IInstructionWithAccounts,
   IInstructionWithData,
+  ReadonlyAccount,
   ReadonlySignerAccount,
   TransactionSigner,
   WritableAccount,
@@ -29,7 +31,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type RevokeTokenDelegateInstruction<
+export type RevokeInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource extends string | IAccountMeta<string> = string,
   TAccountOwner extends string | IAccountMeta<string> = string,
@@ -42,55 +44,59 @@ export type RevokeTokenDelegateInstruction<
         ? WritableAccount<TAccountSource>
         : TAccountSource,
       TAccountOwner extends string
-        ? ReadonlySignerAccount<TAccountOwner> &
-            IAccountSignerMeta<TAccountOwner>
+        ? ReadonlyAccount<TAccountOwner>
         : TAccountOwner,
       ...TRemainingAccounts,
     ]
   >;
 
-export type RevokeTokenDelegateInstructionData = { discriminator: number };
+export type RevokeInstructionData = { discriminator: number };
 
-export type RevokeTokenDelegateInstructionDataArgs = {};
+export type RevokeInstructionDataArgs = {};
 
-export function getRevokeTokenDelegateInstructionDataEncoder(): Encoder<RevokeTokenDelegateInstructionDataArgs> {
+export function getRevokeInstructionDataEncoder(): Encoder<RevokeInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([['discriminator', getU8Encoder()]]),
     (value) => ({ ...value, discriminator: 5 })
   );
 }
 
-export function getRevokeTokenDelegateInstructionDataDecoder(): Decoder<RevokeTokenDelegateInstructionData> {
+export function getRevokeInstructionDataDecoder(): Decoder<RevokeInstructionData> {
   return getStructDecoder([['discriminator', getU8Decoder()]]);
 }
 
-export function getRevokeTokenDelegateInstructionDataCodec(): Codec<
-  RevokeTokenDelegateInstructionDataArgs,
-  RevokeTokenDelegateInstructionData
+export function getRevokeInstructionDataCodec(): Codec<
+  RevokeInstructionDataArgs,
+  RevokeInstructionData
 > {
   return combineCodec(
-    getRevokeTokenDelegateInstructionDataEncoder(),
-    getRevokeTokenDelegateInstructionDataDecoder()
+    getRevokeInstructionDataEncoder(),
+    getRevokeInstructionDataDecoder()
   );
 }
 
-export type RevokeTokenDelegateInput<
+export type RevokeInput<
   TAccountSource extends string = string,
   TAccountOwner extends string = string,
 > = {
+  /** The source account. */
   source: Address<TAccountSource>;
-  owner: TransactionSigner<TAccountOwner>;
+  /** The source account owner or its multisignature. */
+  owner: Address<TAccountOwner> | TransactionSigner<TAccountOwner>;
+  multiSigners?: Array<TransactionSigner>;
 };
 
-export function getRevokeTokenDelegateInstruction<
+export function getRevokeInstruction<
   TAccountSource extends string,
   TAccountOwner extends string,
 >(
-  input: RevokeTokenDelegateInput<TAccountSource, TAccountOwner>
-): RevokeTokenDelegateInstruction<
+  input: RevokeInput<TAccountSource, TAccountOwner>
+): RevokeInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource,
-  TAccountOwner
+  (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+    ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+    : TAccountOwner
 > {
   // Program address.
   const programAddress = TOKEN_PROGRAM_ADDRESS;
@@ -105,40 +111,57 @@ export function getRevokeTokenDelegateInstruction<
     ResolvedAccount
   >;
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
-    accounts: [getAccountMeta(accounts.source), getAccountMeta(accounts.owner)],
+    accounts: [
+      getAccountMeta(accounts.source),
+      getAccountMeta(accounts.owner),
+      ...remainingAccounts,
+    ],
     programAddress,
-    data: getRevokeTokenDelegateInstructionDataEncoder().encode({}),
-  } as RevokeTokenDelegateInstruction<
+    data: getRevokeInstructionDataEncoder().encode({}),
+  } as RevokeInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountSource,
-    TAccountOwner
+    (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+      ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+      : TAccountOwner
   >;
 
   return instruction;
 }
 
-export type ParsedRevokeTokenDelegateInstruction<
+export type ParsedRevokeInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The source account. */
     source: TAccountMetas[0];
+    /** The source account owner or its multisignature. */
     owner: TAccountMetas[1];
   };
-  data: RevokeTokenDelegateInstructionData;
+  data: RevokeInstructionData;
 };
 
-export function parseRevokeTokenDelegateInstruction<
+export function parseRevokeInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedRevokeTokenDelegateInstruction<TProgram, TAccountMetas> {
+): ParsedRevokeInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 2) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -155,8 +178,6 @@ export function parseRevokeTokenDelegateInstruction<
       source: getNextAccount(),
       owner: getNextAccount(),
     },
-    data: getRevokeTokenDelegateInstructionDataDecoder().decode(
-      instruction.data
-    ),
+    data: getRevokeInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/setAuthority.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -29,6 +30,8 @@ import {
   getOptionEncoder,
   getStructDecoder,
   getStructEncoder,
+  getU32Decoder,
+  getU32Encoder,
   getU8Decoder,
   getU8Encoder,
   transformEncoder,
@@ -63,12 +66,16 @@ export type SetAuthorityInstruction<
 
 export type SetAuthorityInstructionData = {
   discriminator: number;
+  /** The type of authority to update. */
   authorityType: AuthorityType;
+  /** The new authority */
   newAuthority: Option<Address>;
 };
 
 export type SetAuthorityInstructionDataArgs = {
+  /** The type of authority to update. */
   authorityType: AuthorityTypeArgs;
+  /** The new authority */
   newAuthority: OptionOrNullable<Address>;
 };
 
@@ -77,7 +84,13 @@ export function getSetAuthorityInstructionDataEncoder(): Encoder<SetAuthorityIns
     getStructEncoder([
       ['discriminator', getU8Encoder()],
       ['authorityType', getAuthorityTypeEncoder()],
-      ['newAuthority', getOptionEncoder(getAddressEncoder())],
+      [
+        'newAuthority',
+        getOptionEncoder(getAddressEncoder(), {
+          prefix: getU32Encoder(),
+          fixed: true,
+        }),
+      ],
     ]),
     (value) => ({ ...value, discriminator: 6 })
   );
@@ -87,7 +100,13 @@ export function getSetAuthorityInstructionDataDecoder(): Decoder<SetAuthorityIns
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['authorityType', getAuthorityTypeDecoder()],
-    ['newAuthority', getOptionDecoder(getAddressDecoder())],
+    [
+      'newAuthority',
+      getOptionDecoder(getAddressDecoder(), {
+        prefix: getU32Decoder(),
+        fixed: true,
+      }),
+    ],
   ]);
 }
 
@@ -105,10 +124,13 @@ export type SetAuthorityInput<
   TAccountOwned extends string = string,
   TAccountOwner extends string = string,
 > = {
+  /** The mint or account to change the authority of. */
   owned: Address<TAccountOwned>;
+  /** The current authority or the multisignature account of the mint or account to update. */
   owner: Address<TAccountOwner> | TransactionSigner<TAccountOwner>;
   authorityType: SetAuthorityInstructionDataArgs['authorityType'];
   newAuthority: SetAuthorityInstructionDataArgs['newAuthority'];
+  multiSigners?: Array<TransactionSigner>;
 };
 
 export function getSetAuthorityInstruction<
@@ -139,9 +161,22 @@ export function getSetAuthorityInstruction<
   // Original args.
   const args = { ...input };
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
-    accounts: [getAccountMeta(accounts.owned), getAccountMeta(accounts.owner)],
+    accounts: [
+      getAccountMeta(accounts.owned),
+      getAccountMeta(accounts.owner),
+      ...remainingAccounts,
+    ],
     programAddress,
     data: getSetAuthorityInstructionDataEncoder().encode(
       args as SetAuthorityInstructionDataArgs
@@ -163,7 +198,9 @@ export type ParsedSetAuthorityInstruction<
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The mint or account to change the authority of. */
     owned: TAccountMetas[0];
+    /** The current authority or the multisignature account of the mint or account to update. */
     owner: TAccountMetas[1];
   };
   data: SetAuthorityInstructionData;

clients/js/src/generated/instructions/thawToken.ts → clients/js/src/generated/instructions/thawAccount.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -30,7 +31,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type ThawTokenInstruction<
+export type ThawAccountInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount extends string | IAccountMeta<string> = string,
   TAccountMint extends string | IAccountMeta<string> = string,
@@ -47,59 +48,64 @@ export type ThawTokenInstruction<
         ? ReadonlyAccount<TAccountMint>
         : TAccountMint,
       TAccountOwner extends string
-        ? ReadonlySignerAccount<TAccountOwner> &
-            IAccountSignerMeta<TAccountOwner>
+        ? ReadonlyAccount<TAccountOwner>
         : TAccountOwner,
       ...TRemainingAccounts,
     ]
   >;
 
-export type ThawTokenInstructionData = { discriminator: number };
+export type ThawAccountInstructionData = { discriminator: number };
 
-export type ThawTokenInstructionDataArgs = {};
+export type ThawAccountInstructionDataArgs = {};
 
-export function getThawTokenInstructionDataEncoder(): Encoder<ThawTokenInstructionDataArgs> {
+export function getThawAccountInstructionDataEncoder(): Encoder<ThawAccountInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([['discriminator', getU8Encoder()]]),
     (value) => ({ ...value, discriminator: 11 })
   );
 }
 
-export function getThawTokenInstructionDataDecoder(): Decoder<ThawTokenInstructionData> {
+export function getThawAccountInstructionDataDecoder(): Decoder<ThawAccountInstructionData> {
   return getStructDecoder([['discriminator', getU8Decoder()]]);
 }
 
-export function getThawTokenInstructionDataCodec(): Codec<
-  ThawTokenInstructionDataArgs,
-  ThawTokenInstructionData
+export function getThawAccountInstructionDataCodec(): Codec<
+  ThawAccountInstructionDataArgs,
+  ThawAccountInstructionData
 > {
   return combineCodec(
-    getThawTokenInstructionDataEncoder(),
-    getThawTokenInstructionDataDecoder()
+    getThawAccountInstructionDataEncoder(),
+    getThawAccountInstructionDataDecoder()
   );
 }
 
-export type ThawTokenInput<
+export type ThawAccountInput<
   TAccountAccount extends string = string,
   TAccountMint extends string = string,
   TAccountOwner extends string = string,
 > = {
+  /** The account to thaw. */
   account: Address<TAccountAccount>;
+  /** The token mint. */
   mint: Address<TAccountMint>;
-  owner: TransactionSigner<TAccountOwner>;
+  /** The mint freeze authority or its multisignature account. */
+  owner: Address<TAccountOwner> | TransactionSigner<TAccountOwner>;
+  multiSigners?: Array<TransactionSigner>;
 };
 
-export function getThawTokenInstruction<
+export function getThawAccountInstruction<
   TAccountAccount extends string,
   TAccountMint extends string,
   TAccountOwner extends string,
 >(
-  input: ThawTokenInput<TAccountAccount, TAccountMint, TAccountOwner>
-): ThawTokenInstruction<
+  input: ThawAccountInput<TAccountAccount, TAccountMint, TAccountOwner>
+): ThawAccountInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountAccount,
   TAccountMint,
-  TAccountOwner
+  (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+    ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+    : TAccountOwner
 > {
   // Program address.
   const programAddress = TOKEN_PROGRAM_ADDRESS;
@@ -115,46 +121,61 @@ export function getThawTokenInstruction<
     ResolvedAccount
   >;
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
       getAccountMeta(accounts.account),
       getAccountMeta(accounts.mint),
       getAccountMeta(accounts.owner),
+      ...remainingAccounts,
     ],
     programAddress,
-    data: getThawTokenInstructionDataEncoder().encode({}),
-  } as ThawTokenInstruction<
+    data: getThawAccountInstructionDataEncoder().encode({}),
+  } as ThawAccountInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountAccount,
     TAccountMint,
-    TAccountOwner
+    (typeof input)['owner'] extends TransactionSigner<TAccountOwner>
+      ? ReadonlySignerAccount<TAccountOwner> & IAccountSignerMeta<TAccountOwner>
+      : TAccountOwner
   >;
 
   return instruction;
 }
 
-export type ParsedThawTokenInstruction<
+export type ParsedThawAccountInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The account to thaw. */
     account: TAccountMetas[0];
+    /** The token mint. */
     mint: TAccountMetas[1];
+    /** The mint freeze authority or its multisignature account. */
     owner: TAccountMetas[2];
   };
-  data: ThawTokenInstructionData;
+  data: ThawAccountInstructionData;
 };
 
-export function parseThawTokenInstruction<
+export function parseThawAccountInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedThawTokenInstruction<TProgram, TAccountMetas> {
+): ParsedThawAccountInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 3) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -172,6 +193,6 @@ export function parseThawTokenInstruction<
       mint: getNextAccount(),
       owner: getNextAccount(),
     },
-    data: getThawTokenInstructionDataDecoder().decode(instruction.data),
+    data: getThawAccountInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/transferTokens.ts → clients/js/src/generated/instructions/transfer.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -16,6 +17,7 @@ import {
   IInstruction,
   IInstructionWithAccounts,
   IInstructionWithData,
+  ReadonlyAccount,
   ReadonlySignerAccount,
   TransactionSigner,
   WritableAccount,
@@ -31,7 +33,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type TransferTokensInstruction<
+export type TransferInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource extends string | IAccountMeta<string> = string,
   TAccountDestination extends string | IAccountMeta<string> = string,
@@ -48,21 +50,24 @@ export type TransferTokensInstruction<
         ? WritableAccount<TAccountDestination>
         : TAccountDestination,
       TAccountAuthority extends string
-        ? ReadonlySignerAccount<TAccountAuthority> &
-            IAccountSignerMeta<TAccountAuthority>
+        ? ReadonlyAccount<TAccountAuthority>
         : TAccountAuthority,
       ...TRemainingAccounts,
     ]
   >;
 
-export type TransferTokensInstructionData = {
+export type TransferInstructionData = {
   discriminator: number;
+  /** The amount of tokens to transfer. */
   amount: bigint;
 };
 
-export type TransferTokensInstructionDataArgs = { amount: number | bigint };
+export type TransferInstructionDataArgs = {
+  /** The amount of tokens to transfer. */
+  amount: number | bigint;
+};
 
-export function getTransferTokensInstructionDataEncoder(): Encoder<TransferTokensInstructionDataArgs> {
+export function getTransferInstructionDataEncoder(): Encoder<TransferInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
@@ -72,49 +77,52 @@ export function getTransferTokensInstructionDataEncoder(): Encoder<TransferToken
   );
 }
 
-export function getTransferTokensInstructionDataDecoder(): Decoder<TransferTokensInstructionData> {
+export function getTransferInstructionDataDecoder(): Decoder<TransferInstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['amount', getU64Decoder()],
   ]);
 }
 
-export function getTransferTokensInstructionDataCodec(): Codec<
-  TransferTokensInstructionDataArgs,
-  TransferTokensInstructionData
+export function getTransferInstructionDataCodec(): Codec<
+  TransferInstructionDataArgs,
+  TransferInstructionData
 > {
   return combineCodec(
-    getTransferTokensInstructionDataEncoder(),
-    getTransferTokensInstructionDataDecoder()
+    getTransferInstructionDataEncoder(),
+    getTransferInstructionDataDecoder()
   );
 }
 
-export type TransferTokensInput<
+export type TransferInput<
   TAccountSource extends string = string,
   TAccountDestination extends string = string,
   TAccountAuthority extends string = string,
 > = {
+  /** The source account. */
   source: Address<TAccountSource>;
+  /** The destination account. */
   destination: Address<TAccountDestination>;
-  authority: TransactionSigner<TAccountAuthority>;
-  amount: TransferTokensInstructionDataArgs['amount'];
+  /** The source account's owner/delegate or its multisignature account. */
+  authority: Address<TAccountAuthority> | TransactionSigner<TAccountAuthority>;
+  amount: TransferInstructionDataArgs['amount'];
+  multiSigners?: Array<TransactionSigner>;
 };
 
-export function getTransferTokensInstruction<
+export function getTransferInstruction<
   TAccountSource extends string,
   TAccountDestination extends string,
   TAccountAuthority extends string,
 >(
-  input: TransferTokensInput<
-    TAccountSource,
-    TAccountDestination,
-    TAccountAuthority
-  >
-): TransferTokensInstruction<
+  input: TransferInput<TAccountSource, TAccountDestination, TAccountAuthority>
+): TransferInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource,
   TAccountDestination,
-  TAccountAuthority
+  (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+    ? ReadonlySignerAccount<TAccountAuthority> &
+        IAccountSignerMeta<TAccountAuthority>
+    : TAccountAuthority
 > {
   // Program address.
   const programAddress = TOKEN_PROGRAM_ADDRESS;
@@ -133,48 +141,64 @@ export function getTransferTokensInstruction<
   // Original args.
   const args = { ...input };
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
       getAccountMeta(accounts.source),
       getAccountMeta(accounts.destination),
       getAccountMeta(accounts.authority),
+      ...remainingAccounts,
     ],
     programAddress,
-    data: getTransferTokensInstructionDataEncoder().encode(
-      args as TransferTokensInstructionDataArgs
+    data: getTransferInstructionDataEncoder().encode(
+      args as TransferInstructionDataArgs
     ),
-  } as TransferTokensInstruction<
+  } as TransferInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountSource,
     TAccountDestination,
-    TAccountAuthority
+    (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+      ? ReadonlySignerAccount<TAccountAuthority> &
+          IAccountSignerMeta<TAccountAuthority>
+      : TAccountAuthority
   >;
 
   return instruction;
 }
 
-export type ParsedTransferTokensInstruction<
+export type ParsedTransferInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The source account. */
     source: TAccountMetas[0];
+    /** The destination account. */
     destination: TAccountMetas[1];
+    /** The source account's owner/delegate or its multisignature account. */
     authority: TAccountMetas[2];
   };
-  data: TransferTokensInstructionData;
+  data: TransferInstructionData;
 };
 
-export function parseTransferTokensInstruction<
+export function parseTransferInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedTransferTokensInstruction<TProgram, TAccountMetas> {
+): ParsedTransferInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 3) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -192,6 +216,6 @@ export function parseTransferTokensInstruction<
       destination: getNextAccount(),
       authority: getNextAccount(),
     },
-    data: getTransferTokensInstructionDataDecoder().decode(instruction.data),
+    data: getTransferInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/instructions/transferTokensChecked.ts → clients/js/src/generated/instructions/transferChecked.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  AccountRole,
   Address,
   Codec,
   Decoder,
@@ -32,7 +33,7 @@ import {
 import { TOKEN_PROGRAM_ADDRESS } from '../programs';
 import { ResolvedAccount, getAccountMetaFactory } from '../shared';
 
-export type TransferTokensCheckedInstruction<
+export type TransferCheckedInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource extends string | IAccountMeta<string> = string,
   TAccountMint extends string | IAccountMeta<string> = string,
@@ -53,25 +54,28 @@ export type TransferTokensCheckedInstruction<
         ? WritableAccount<TAccountDestination>
         : TAccountDestination,
       TAccountAuthority extends string
-        ? ReadonlySignerAccount<TAccountAuthority> &
-            IAccountSignerMeta<TAccountAuthority>
+        ? ReadonlyAccount<TAccountAuthority>
         : TAccountAuthority,
       ...TRemainingAccounts,
     ]
   >;
 
-export type TransferTokensCheckedInstructionData = {
+export type TransferCheckedInstructionData = {
   discriminator: number;
+  /** The amount of tokens to transfer. */
   amount: bigint;
+  /** Expected number of base 10 digits to the right of the decimal place. */
   decimals: number;
 };
 
-export type TransferTokensCheckedInstructionDataArgs = {
+export type TransferCheckedInstructionDataArgs = {
+  /** The amount of tokens to transfer. */
   amount: number | bigint;
+  /** Expected number of base 10 digits to the right of the decimal place. */
   decimals: number;
 };
 
-export function getTransferTokensCheckedInstructionDataEncoder(): Encoder<TransferTokensCheckedInstructionDataArgs> {
+export function getTransferCheckedInstructionDataEncoder(): Encoder<TransferCheckedInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
@@ -82,7 +86,7 @@ export function getTransferTokensCheckedInstructionDataEncoder(): Encoder<Transf
   );
 }
 
-export function getTransferTokensCheckedInstructionDataDecoder(): Decoder<TransferTokensCheckedInstructionData> {
+export function getTransferCheckedInstructionDataDecoder(): Decoder<TransferCheckedInstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['amount', getU64Decoder()],
@@ -90,48 +94,56 @@ export function getTransferTokensCheckedInstructionDataDecoder(): Decoder<Transf
   ]);
 }
 
-export function getTransferTokensCheckedInstructionDataCodec(): Codec<
-  TransferTokensCheckedInstructionDataArgs,
-  TransferTokensCheckedInstructionData
+export function getTransferCheckedInstructionDataCodec(): Codec<
+  TransferCheckedInstructionDataArgs,
+  TransferCheckedInstructionData
 > {
   return combineCodec(
-    getTransferTokensCheckedInstructionDataEncoder(),
-    getTransferTokensCheckedInstructionDataDecoder()
+    getTransferCheckedInstructionDataEncoder(),
+    getTransferCheckedInstructionDataDecoder()
   );
 }
 
-export type TransferTokensCheckedInput<
+export type TransferCheckedInput<
   TAccountSource extends string = string,
   TAccountMint extends string = string,
   TAccountDestination extends string = string,
   TAccountAuthority extends string = string,
 > = {
+  /** The source account. */
   source: Address<TAccountSource>;
+  /** The token mint. */
   mint: Address<TAccountMint>;
+  /** The destination account. */
   destination: Address<TAccountDestination>;
-  authority: TransactionSigner<TAccountAuthority>;
-  amount: TransferTokensCheckedInstructionDataArgs['amount'];
-  decimals: TransferTokensCheckedInstructionDataArgs['decimals'];
+  /** The source account's owner/delegate or its multisignature account. */
+  authority: Address<TAccountAuthority> | TransactionSigner<TAccountAuthority>;
+  amount: TransferCheckedInstructionDataArgs['amount'];
+  decimals: TransferCheckedInstructionDataArgs['decimals'];
+  multiSigners?: Array<TransactionSigner>;
 };
 
-export function getTransferTokensCheckedInstruction<
+export function getTransferCheckedInstruction<
   TAccountSource extends string,
   TAccountMint extends string,
   TAccountDestination extends string,
   TAccountAuthority extends string,
 >(
-  input: TransferTokensCheckedInput<
+  input: TransferCheckedInput<
     TAccountSource,
     TAccountMint,
     TAccountDestination,
     TAccountAuthority
   >
-): TransferTokensCheckedInstruction<
+): TransferCheckedInstruction<
   typeof TOKEN_PROGRAM_ADDRESS,
   TAccountSource,
   TAccountMint,
   TAccountDestination,
-  TAccountAuthority
+  (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+    ? ReadonlySignerAccount<TAccountAuthority> &
+        IAccountSignerMeta<TAccountAuthority>
+    : TAccountAuthority
 > {
   // Program address.
   const programAddress = TOKEN_PROGRAM_ADDRESS;
@@ -151,6 +163,15 @@ export function getTransferTokensCheckedInstruction<
   // Original args.
   const args = { ...input };
 
+  // Remaining accounts.
+  const remainingAccounts: IAccountMeta[] = (args.multiSigners ?? []).map(
+    (signer) => ({
+      address: signer.address,
+      role: AccountRole.READONLY_SIGNER,
+      signer,
+    })
+  );
+
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
@@ -158,44 +179,52 @@ export function getTransferTokensCheckedInstruction<
       getAccountMeta(accounts.mint),
       getAccountMeta(accounts.destination),
       getAccountMeta(accounts.authority),
+      ...remainingAccounts,
     ],
     programAddress,
-    data: getTransferTokensCheckedInstructionDataEncoder().encode(
-      args as TransferTokensCheckedInstructionDataArgs
+    data: getTransferCheckedInstructionDataEncoder().encode(
+      args as TransferCheckedInstructionDataArgs
     ),
-  } as TransferTokensCheckedInstruction<
+  } as TransferCheckedInstruction<
     typeof TOKEN_PROGRAM_ADDRESS,
     TAccountSource,
     TAccountMint,
     TAccountDestination,
-    TAccountAuthority
+    (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+      ? ReadonlySignerAccount<TAccountAuthority> &
+          IAccountSignerMeta<TAccountAuthority>
+      : TAccountAuthority
   >;
 
   return instruction;
 }
 
-export type ParsedTransferTokensCheckedInstruction<
+export type ParsedTransferCheckedInstruction<
   TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
   TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
+    /** The source account. */
     source: TAccountMetas[0];
+    /** The token mint. */
     mint: TAccountMetas[1];
+    /** The destination account. */
     destination: TAccountMetas[2];
+    /** The source account's owner/delegate or its multisignature account. */
     authority: TAccountMetas[3];
   };
-  data: TransferTokensCheckedInstructionData;
+  data: TransferCheckedInstructionData;
 };
 
-export function parseTransferTokensCheckedInstruction<
+export function parseTransferCheckedInstruction<
   TProgram extends string,
   TAccountMetas extends readonly IAccountMeta[],
 >(
   instruction: IInstruction<TProgram> &
     IInstructionWithAccounts<TAccountMetas> &
     IInstructionWithData<Uint8Array>
-): ParsedTransferTokensCheckedInstruction<TProgram, TAccountMetas> {
+): ParsedTransferCheckedInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 4) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
@@ -214,8 +243,6 @@ export function parseTransferTokensCheckedInstruction<
       destination: getNextAccount(),
       authority: getNextAccount(),
     },
-    data: getTransferTokensCheckedInstructionDataDecoder().decode(
-      instruction.data
-    ),
+    data: getTransferCheckedInstructionDataDecoder().decode(instruction.data),
   };
 }

clients/js/src/generated/programs/token.ts

@@ -9,29 +9,29 @@
 import { Address, containsBytes, getU8Encoder } from '@solana/web3.js';
 import {
   ParsedAmountToUiAmountInstruction,
-  ParsedApproveTokenDelegateCheckedInstruction,
-  ParsedApproveTokenDelegateInstruction,
-  ParsedBurnTokenCheckedInstruction,
-  ParsedBurnTokenInstruction,
-  ParsedCloseTokenInstruction,
-  ParsedFreezeTokenInstruction,
+  ParsedApproveCheckedInstruction,
+  ParsedApproveInstruction,
+  ParsedBurnCheckedInstruction,
+  ParsedBurnInstruction,
+  ParsedCloseAccountInstruction,
+  ParsedFreezeAccountInstruction,
   ParsedGetTokenDataSizeInstruction,
+  ParsedInitializeAccount2Instruction,
+  ParsedInitializeAccount3Instruction,
+  ParsedInitializeAccountInstruction,
   ParsedInitializeImmutableOwnerInstruction,
   ParsedInitializeMint2Instruction,
   ParsedInitializeMintInstruction,
   ParsedInitializeMultisig2Instruction,
   ParsedInitializeMultisigInstruction,
-  ParsedInitializeToken2Instruction,
-  ParsedInitializeToken3Instruction,
-  ParsedInitializeTokenInstruction,
+  ParsedMintToInstruction,
   ParsedMintTokensToCheckedInstruction,
-  ParsedMintTokensToInstruction,
-  ParsedRevokeTokenDelegateInstruction,
+  ParsedRevokeInstruction,
   ParsedSetAuthorityInstruction,
   ParsedSyncNativeInstruction,
-  ParsedThawTokenInstruction,
-  ParsedTransferTokensCheckedInstruction,
-  ParsedTransferTokensInstruction,
+  ParsedThawAccountInstruction,
+  ParsedTransferCheckedInstruction,
+  ParsedTransferInstruction,
   ParsedUiAmountToAmountInstruction,
 } from '../instructions';
 
@@ -40,30 +40,30 @@ export const TOKEN_PROGRAM_ADDRESS =
 
 export enum TokenAccount {
   Mint,
-  Token,
+  Account,
   Multisig,
 }
 
 export enum TokenInstruction {
   InitializeMint,
-  InitializeToken,
+  InitializeAccount,
   InitializeMultisig,
-  TransferTokens,
-  ApproveTokenDelegate,
-  RevokeTokenDelegate,
+  Transfer,
+  Approve,
+  Revoke,
   SetAuthority,
-  MintTokensTo,
-  BurnToken,
-  CloseToken,
-  FreezeToken,
-  ThawToken,
-  TransferTokensChecked,
-  ApproveTokenDelegateChecked,
+  MintTo,
+  Burn,
+  CloseAccount,
+  FreezeAccount,
+  ThawAccount,
+  TransferChecked,
+  ApproveChecked,
   MintTokensToChecked,
-  BurnTokenChecked,
-  InitializeToken2,
+  BurnChecked,
+  InitializeAccount2,
   SyncNative,
-  InitializeToken3,
+  InitializeAccount3,
   InitializeMultisig2,
   InitializeMint2,
   GetTokenDataSize,
@@ -81,58 +81,58 @@ export function identifyTokenInstruction(
     return TokenInstruction.InitializeMint;
   }
   if (containsBytes(data, getU8Encoder().encode(1), 0)) {
-    return TokenInstruction.InitializeToken;
+    return TokenInstruction.InitializeAccount;
   }
   if (containsBytes(data, getU8Encoder().encode(2), 0)) {
     return TokenInstruction.InitializeMultisig;
   }
   if (containsBytes(data, getU8Encoder().encode(3), 0)) {
-    return TokenInstruction.TransferTokens;
+    return TokenInstruction.Transfer;
   }
   if (containsBytes(data, getU8Encoder().encode(4), 0)) {
-    return TokenInstruction.ApproveTokenDelegate;
+    return TokenInstruction.Approve;
   }
   if (containsBytes(data, getU8Encoder().encode(5), 0)) {
-    return TokenInstruction.RevokeTokenDelegate;
+    return TokenInstruction.Revoke;
   }
   if (containsBytes(data, getU8Encoder().encode(6), 0)) {
     return TokenInstruction.SetAuthority;
   }
   if (containsBytes(data, getU8Encoder().encode(7), 0)) {
-    return TokenInstruction.MintTokensTo;
+    return TokenInstruction.MintTo;
   }
   if (containsBytes(data, getU8Encoder().encode(8), 0)) {
-    return TokenInstruction.BurnToken;
+    return TokenInstruction.Burn;
   }
   if (containsBytes(data, getU8Encoder().encode(9), 0)) {
-    return TokenInstruction.CloseToken;
+    return TokenInstruction.CloseAccount;
   }
   if (containsBytes(data, getU8Encoder().encode(10), 0)) {
-    return TokenInstruction.FreezeToken;
+    return TokenInstruction.FreezeAccount;
   }
   if (containsBytes(data, getU8Encoder().encode(11), 0)) {
-    return TokenInstruction.ThawToken;
+    return TokenInstruction.ThawAccount;
   }
   if (containsBytes(data, getU8Encoder().encode(12), 0)) {
-    return TokenInstruction.TransferTokensChecked;
+    return TokenInstruction.TransferChecked;
   }
   if (containsBytes(data, getU8Encoder().encode(13), 0)) {
-    return TokenInstruction.ApproveTokenDelegateChecked;
+    return TokenInstruction.ApproveChecked;
   }
   if (containsBytes(data, getU8Encoder().encode(14), 0)) {
     return TokenInstruction.MintTokensToChecked;
   }
   if (containsBytes(data, getU8Encoder().encode(15), 0)) {
-    return TokenInstruction.BurnTokenChecked;
+    return TokenInstruction.BurnChecked;
   }
   if (containsBytes(data, getU8Encoder().encode(16), 0)) {
-    return TokenInstruction.InitializeToken2;
+    return TokenInstruction.InitializeAccount2;
   }
   if (containsBytes(data, getU8Encoder().encode(17), 0)) {
     return TokenInstruction.SyncNative;
   }
   if (containsBytes(data, getU8Encoder().encode(18), 0)) {
-    return TokenInstruction.InitializeToken3;
+    return TokenInstruction.InitializeAccount3;
   }
   if (containsBytes(data, getU8Encoder().encode(19), 0)) {
     return TokenInstruction.InitializeMultisig2;
@@ -164,59 +164,59 @@ export type ParsedTokenInstruction<
       instructionType: TokenInstruction.InitializeMint;
     } & ParsedInitializeMintInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.InitializeToken;
-    } & ParsedInitializeTokenInstruction<TProgram>)
+      instructionType: TokenInstruction.InitializeAccount;
+    } & ParsedInitializeAccountInstruction<TProgram>)
   | ({
       instructionType: TokenInstruction.InitializeMultisig;
     } & ParsedInitializeMultisigInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.TransferTokens;
-    } & ParsedTransferTokensInstruction<TProgram>)
+      instructionType: TokenInstruction.Transfer;
+    } & ParsedTransferInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.ApproveTokenDelegate;
-    } & ParsedApproveTokenDelegateInstruction<TProgram>)
+      instructionType: TokenInstruction.Approve;
+    } & ParsedApproveInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.RevokeTokenDelegate;
-    } & ParsedRevokeTokenDelegateInstruction<TProgram>)
+      instructionType: TokenInstruction.Revoke;
+    } & ParsedRevokeInstruction<TProgram>)
   | ({
       instructionType: TokenInstruction.SetAuthority;
     } & ParsedSetAuthorityInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.MintTokensTo;
-    } & ParsedMintTokensToInstruction<TProgram>)
+      instructionType: TokenInstruction.MintTo;
+    } & ParsedMintToInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.BurnToken;
-    } & ParsedBurnTokenInstruction<TProgram>)
+      instructionType: TokenInstruction.Burn;
+    } & ParsedBurnInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.CloseToken;
-    } & ParsedCloseTokenInstruction<TProgram>)
+      instructionType: TokenInstruction.CloseAccount;
+    } & ParsedCloseAccountInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.FreezeToken;
-    } & ParsedFreezeTokenInstruction<TProgram>)
+      instructionType: TokenInstruction.FreezeAccount;
+    } & ParsedFreezeAccountInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.ThawToken;
-    } & ParsedThawTokenInstruction<TProgram>)
+      instructionType: TokenInstruction.ThawAccount;
+    } & ParsedThawAccountInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.TransferTokensChecked;
-    } & ParsedTransferTokensCheckedInstruction<TProgram>)
+      instructionType: TokenInstruction.TransferChecked;
+    } & ParsedTransferCheckedInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.ApproveTokenDelegateChecked;
-    } & ParsedApproveTokenDelegateCheckedInstruction<TProgram>)
+      instructionType: TokenInstruction.ApproveChecked;
+    } & ParsedApproveCheckedInstruction<TProgram>)
   | ({
       instructionType: TokenInstruction.MintTokensToChecked;
     } & ParsedMintTokensToCheckedInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.BurnTokenChecked;
-    } & ParsedBurnTokenCheckedInstruction<TProgram>)
+      instructionType: TokenInstruction.BurnChecked;
+    } & ParsedBurnCheckedInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.InitializeToken2;
-    } & ParsedInitializeToken2Instruction<TProgram>)
+      instructionType: TokenInstruction.InitializeAccount2;
+    } & ParsedInitializeAccount2Instruction<TProgram>)
   | ({
       instructionType: TokenInstruction.SyncNative;
     } & ParsedSyncNativeInstruction<TProgram>)
   | ({
-      instructionType: TokenInstruction.InitializeToken3;
-    } & ParsedInitializeToken3Instruction<TProgram>)
+      instructionType: TokenInstruction.InitializeAccount3;
+    } & ParsedInitializeAccount3Instruction<TProgram>)
   | ({
       instructionType: TokenInstruction.InitializeMultisig2;
     } & ParsedInitializeMultisig2Instruction<TProgram>)

program/idl.json

@@ -241,7 +241,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["Token mint account."]
           },
           {
             "kind": "instructionAccountNode",
@@ -249,7 +249,7 @@
             "isWritable": false,
             "isSigner": false,
             "isOptional": false,
-            "docs": [],
+            "docs": ["Rent sysvar."],
             "defaultValue": {
               "kind": "publicKeyValueNode",
               "publicKey": "SysvarRent111111111111111111111111111111111"
@@ -277,13 +277,13 @@
               "format": "u8",
               "endian": "le"
             },
-            "docs": []
+            "docs": ["Number of decimals in token account amounts."]
           },
           {
             "kind": "instructionArgumentNode",
             "name": "mintAuthority",
             "type": { "kind": "publicKeyTypeNode" },
-            "docs": []
+            "docs": ["Minting authority."]
           },
           {
             "kind": "instructionArgumentNode",
@@ -293,12 +293,12 @@
               "item": { "kind": "publicKeyTypeNode" },
               "prefix": {
                 "kind": "numberTypeNode",
-                "format": "u8",
+                "format": "u32",
                 "endian": "le"
               },
-              "fixed": false
+              "fixed": true
             },
-            "docs": []
+            "docs": ["Optional authority that can freeze token accounts."]
           }
         ],
         "discriminators": [
@@ -309,7 +309,15 @@
           }
         ],
         "name": "initializeMint",
-        "docs": [],
+        "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"
       },
       {
@@ -321,7 +329,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The account to initialize."]
           },
           {
             "kind": "instructionAccountNode",
@@ -329,7 +337,7 @@
             "isWritable": false,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The mint this account will be associated with."]
           },
           {
             "kind": "instructionAccountNode",
@@ -337,7 +345,7 @@
             "isWritable": false,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The new account's owner/multisignature."]
           },
           {
             "kind": "instructionAccountNode",
@@ -345,7 +353,7 @@
             "isWritable": false,
             "isSigner": false,
             "isOptional": false,
-            "docs": [],
+            "docs": ["Rent sysvar."],
             "defaultValue": {
               "kind": "publicKeyValueNode",
               "publicKey": "SysvarRent111111111111111111111111111111111"
@@ -373,8 +381,19 @@
             "offset": 0
           }
         ],
-        "name": "initializeToken",
-        "docs": [],
+        "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"
       },
       {
@@ -386,7 +405,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The multisignature account to initialize."]
           },
           {
             "kind": "instructionAccountNode",
@@ -394,7 +413,7 @@
             "isWritable": false,
             "isSigner": false,
             "isOptional": false,
-            "docs": [],
+            "docs": ["Rent sysvar."],
             "defaultValue": {
               "kind": "publicKeyValueNode",
               "publicKey": "SysvarRent111111111111111111111111111111111"
@@ -422,7 +441,9 @@
               "format": "u8",
               "endian": "le"
             },
-            "docs": []
+            "docs": [
+              "The number of signers (M) required to validate this multisignature account."
+            ]
           }
         ],
         "discriminators": [
@@ -432,8 +453,30 @@
             "offset": 0
           }
         ],
+        "remainingAccounts": [
+          {
+            "kind": "instructionRemainingAccountsNode",
+            "value": {
+              "kind": "argumentValueNode",
+              "name": "signers"
+            },
+            "isOptional": true
+          }
+        ],
         "name": "initializeMultisig",
-        "docs": [],
+        "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"
       },
       {
@@ -445,7 +488,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The source account."]
           },
           {
             "kind": "instructionAccountNode",
@@ -453,15 +496,17 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The destination account."]
           },
           {
             "kind": "instructionAccountNode",
             "name": "authority",
             "isWritable": false,
-            "isSigner": true,
+            "isSigner": "either",
             "isOptional": false,
-            "docs": [],
+            "docs": [
+              "The source account's owner/delegate or its multisignature account."
+            ],
             "defaultValue": { "kind": "identityValueNode" }
           }
         ],
@@ -486,7 +531,7 @@
               "format": "u64",
               "endian": "le"
             },
-            "docs": []
+            "docs": ["The amount of tokens to transfer."]
           }
         ],
         "discriminators": [
@@ -496,8 +541,23 @@
             "offset": 0
           }
         ],
-        "name": "transferTokens",
-        "docs": [],
+        "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"
       },
       {
@@ -509,7 +569,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The source account."]
           },
           {
             "kind": "instructionAccountNode",
@@ -517,15 +577,15 @@
             "isWritable": false,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The delegate."]
           },
           {
             "kind": "instructionAccountNode",
             "name": "owner",
             "isWritable": false,
-            "isSigner": true,
+            "isSigner": "either",
             "isOptional": false,
-            "docs": []
+            "docs": ["The source account owner or its multisignature account."]
           }
         ],
         "arguments": [
@@ -549,7 +609,7 @@
               "format": "u64",
               "endian": "le"
             },
-            "docs": []
+            "docs": ["The amount of tokens the delegate is approved for."]
           }
         ],
         "discriminators": [
@@ -559,8 +619,22 @@
             "offset": 0
           }
         ],
-        "name": "approveTokenDelegate",
-        "docs": [],
+        "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"
       },
       {
@@ -572,15 +646,15 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The source account."]
           },
           {
             "kind": "instructionAccountNode",
             "name": "owner",
             "isWritable": false,
-            "isSigner": true,
+            "isSigner": "either",
             "isOptional": false,
-            "docs": []
+            "docs": ["The source account owner or its multisignature."]
           }
         ],
         "arguments": [
@@ -604,8 +678,19 @@
             "offset": 0
           }
         ],
-        "name": "revokeTokenDelegate",
-        "docs": [],
+        "remainingAccounts": [
+          {
+            "kind": "instructionRemainingAccountsNode",
+            "value": {
+              "kind": "argumentValueNode",
+              "name": "multiSigners"
+            },
+            "isOptional": true,
+            "isSigner": true
+          }
+        ],
+        "name": "revoke",
+        "docs": ["Revokes the delegate's authority."],
         "optionalAccountStrategy": "programId"
       },
       {
@@ -617,7 +702,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The mint or account to change the authority of."]
           },
           {
             "kind": "instructionAccountNode",
@@ -625,7 +710,9 @@
             "isWritable": false,
             "isSigner": "either",
             "isOptional": false,
-            "docs": []
+            "docs": [
+              "The current authority or the multisignature account of the mint or account to update."
+            ]
           }
         ],
         "arguments": [
@@ -645,7 +732,7 @@
             "kind": "instructionArgumentNode",
             "name": "authorityType",
             "type": { "kind": "definedTypeLinkNode", "name": "authorityType" },
-            "docs": []
+            "docs": ["The type of authority to update."]
           },
           {
             "kind": "instructionArgumentNode",
@@ -655,12 +742,12 @@
               "item": { "kind": "publicKeyTypeNode" },
               "prefix": {
                 "kind": "numberTypeNode",
-                "format": "u8",
+                "format": "u32",
                 "endian": "le"
               },
-              "fixed": false
+              "fixed": true
             },
-            "docs": []
+            "docs": ["The new authority"]
           }
         ],
         "discriminators": [
@@ -670,8 +757,19 @@
             "offset": 0
           }
         ],
+        "remainingAccounts": [
+          {
+            "kind": "instructionRemainingAccountsNode",
+            "value": {
+              "kind": "argumentValueNode",
+              "name": "multiSigners"
+            },
+            "isOptional": true,
+            "isSigner": true
+          }
+        ],
         "name": "setAuthority",
-        "docs": [],
+        "docs": ["Sets a new authority of a mint or account."],
         "optionalAccountStrategy": "programId"
       },
       {
@@ -683,7 +781,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The mint account."]
           },
           {
             "kind": "instructionAccountNode",
@@ -691,15 +789,17 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The account to mint tokens to."]
           },
           {
             "kind": "instructionAccountNode",
             "name": "mintAuthority",
             "isWritable": false,
-            "isSigner": true,
+            "isSigner": "either",
             "isOptional": false,
-            "docs": []
+            "docs": [
+              "The mint's minting authority or its multisignature account."
+            ]
           }
         ],
         "arguments": [
@@ -723,7 +823,7 @@
               "format": "u64",
               "endian": "le"
             },
-            "docs": []
+            "docs": ["The amount of new tokens to mint."]
           }
         ],
         "discriminators": [
@@ -733,8 +833,21 @@
             "offset": 0
           }
         ],
-        "name": "mintTokensTo",
-        "docs": [],
+        "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"
       },
       {
@@ -746,7 +859,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The account to burn from."]
           },
           {
             "kind": "instructionAccountNode",
@@ -754,15 +867,17 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The token mint."]
           },
           {
             "kind": "instructionAccountNode",
             "name": "authority",
             "isWritable": false,
-            "isSigner": true,
+            "isSigner": "either",
             "isOptional": false,
-            "docs": [],
+            "docs": [
+              "The account's owner/delegate or its multisignature account."
+            ],
             "defaultValue": { "kind": "identityValueNode" }
           }
         ],
@@ -775,7 +890,7 @@
               "format": "u8",
               "endian": "le"
             },
-            "docs": [],
+            "docs": ["The amount of tokens to burn."],
             "defaultValue": { "kind": "numberValueNode", "number": 8 },
             "defaultValueStrategy": "omitted"
           },
@@ -797,8 +912,22 @@
             "offset": 0
           }
         ],
-        "name": "burnToken",
-        "docs": [],
+        "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"
       },
       {
@@ -810,7 +939,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The account to close."]
           },
           {
             "kind": "instructionAccountNode",
@@ -818,15 +947,15 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The destination account."]
           },
           {
             "kind": "instructionAccountNode",
             "name": "owner",
             "isWritable": false,
-            "isSigner": true,
+            "isSigner": "either",
             "isOptional": false,
-            "docs": []
+            "docs": ["The account's owner or its multisignature account."]
           }
         ],
         "arguments": [
@@ -850,8 +979,22 @@
             "offset": 0
           }
         ],
-        "name": "closeToken",
-        "docs": [],
+        "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"
       },
       {
@@ -863,7 +1006,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The account to freeze."]
           },
           {
             "kind": "instructionAccountNode",
@@ -871,15 +1014,15 @@
             "isWritable": false,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The token mint."]
           },
           {
             "kind": "instructionAccountNode",
             "name": "owner",
             "isWritable": false,
-            "isSigner": true,
+            "isSigner": "either",
             "isOptional": false,
-            "docs": []
+            "docs": ["The mint freeze authority or its multisignature account."]
           }
         ],
         "arguments": [
@@ -903,8 +1046,21 @@
             "offset": 0
           }
         ],
-        "name": "freezeToken",
-        "docs": [],
+        "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"
       },
       {
@@ -916,7 +1072,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The account to thaw."]
           },
           {
             "kind": "instructionAccountNode",
@@ -924,15 +1080,15 @@
             "isWritable": false,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The token mint."]
           },
           {
             "kind": "instructionAccountNode",
             "name": "owner",
             "isWritable": false,
-            "isSigner": true,
+            "isSigner": "either",
             "isOptional": false,
-            "docs": []
+            "docs": ["The mint freeze authority or its multisignature account."]
           }
         ],
         "arguments": [
@@ -956,8 +1112,21 @@
             "offset": 0
           }
         ],
-        "name": "thawToken",
-        "docs": [],
+        "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"
       },
       {
@@ -969,7 +1138,7 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The source account."]
           },
           {
             "kind": "instructionAccountNode",
@@ -977,7 +1146,7 @@
             "isWritable": false,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The token mint."]
           },
           {
             "kind": "instructionAccountNode",
@@ -985,15 +1154,17 @@
             "isWritable": true,
             "isSigner": false,
             "isOptional": false,
-            "docs": []
+            "docs": ["The destination account."]
           },
           {
             "kind": "instructionAccountNode",
             "name": "authority",
             "isWritable": false,
-            "isSigner": true,
+            "isSigner": "either",
             "isOptional": false,
-            "docs": [],
+            "docs": [
+              "The source account's owner/delegate or its multisignature account."
+            ],
             "defaultValue": { "kind": "identityValueNode" }
           }
         ],
@@ -1018,7 +1189,7 @@
               "format": "u64",
               "endian": "le"
             },
-            "docs": []
+            "docs": ["The amount of tokens to transfer."]
           },
           {
             "kind": "instructionArgumentNode",
@@ -1028,7 +1199,9 @@
               "format": "u8",
               "endian": "le"
             },
-            "docs": []
+            "docs": [
+              "Expected number of base 10 digits to the right of the decimal place."
+            ]
           }
         ],
         "discriminators": [
@@ -1038,8 +1211,27 @@
             "offset": 0
           }
         ],
-        "name": "transferTokensChecked",
-        "docs": [],
+        "remainingAccounts": [
+          {
+            "kind": "instructionRemainingAccountsNode",
+            "value": {
+              "kind": "argumentValueNode",
+              "name": "multiSigners"
+            },
+            "isOptional": true,
+            "isSigner": true
+          }
+        ],
+        "name": "transferChecked",
+        "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.",
+          "",
+          "This instruction differs from Transfer in that the token mint and",
+          "decimals value is checked by the caller. This may be useful when",
+          "creating transactions offline or within a hardware wallet."
+        ],
         "optionalAccountStrategy": "programId"
       },
       {
@@ -1119,7 +1311,7 @@
             "offset": 0
           }
         ],
-        "name": "approveTokenDelegateChecked",
+        "name": "approveChecked",
         "docs": [],
         "optionalAccountStrategy": "programId"
       },
@@ -1266,7 +1458,7 @@
             "offset": 0
           }
         ],
-        "name": "burnTokenChecked",
+        "name": "burnChecked",
         "docs": [],
         "optionalAccountStrategy": "programId"
       },
@@ -1329,7 +1521,7 @@
             "offset": 0
           }
         ],
-        "name": "initializeToken2",
+        "name": "initializeAccount2",
         "docs": [],
         "optionalAccountStrategy": "programId"
       },
@@ -1417,7 +1609,7 @@
             "offset": 0
           }
         ],
-        "name": "initializeToken3",
+        "name": "initializeAccount3",
         "docs": [],
         "optionalAccountStrategy": "programId"
       },