@solana-program/token-wrap 2.4.0 → 2.5.0

package/src/generated/instructions/wrap.ts

@@ -0,0 +1,326 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    AccountRole,
+    combineCodec,
+    getStructDecoder,
+    getStructEncoder,
+    getU64Decoder,
+    getU64Encoder,
+    getU8Decoder,
+    getU8Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
+    transformEncoder,
+    type AccountMeta,
+    type AccountSignerMeta,
+    type Address,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type ReadonlyAccount,
+    type ReadonlySignerAccount,
+    type ReadonlyUint8Array,
+    type TransactionSigner,
+    type WritableAccount,
+} from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/program-client-core';
+import { TOKEN_WRAP_PROGRAM_ADDRESS } from '../programs';
+
+export const WRAP_DISCRIMINATOR = 1;
+
+export function getWrapDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU8Encoder().encode(WRAP_DISCRIMINATOR);
+}
+
+export type WrapInstruction<
+    TProgram extends string = typeof TOKEN_WRAP_PROGRAM_ADDRESS,
+    TAccountRecipientWrappedTokenAccount extends string | AccountMeta<string> = string,
+    TAccountWrappedMint extends string | AccountMeta<string> = string,
+    TAccountWrappedMintAuthority extends string | AccountMeta<string> = string,
+    TAccountUnwrappedTokenProgram extends string | AccountMeta<string> = string,
+    TAccountWrappedTokenProgram extends string | AccountMeta<string> = string,
+    TAccountUnwrappedTokenAccount extends string | AccountMeta<string> = string,
+    TAccountUnwrappedMint extends string | AccountMeta<string> = string,
+    TAccountUnwrappedEscrow extends string | AccountMeta<string> = string,
+    TAccountTransferAuthority extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountRecipientWrappedTokenAccount extends string
+                ? WritableAccount<TAccountRecipientWrappedTokenAccount>
+                : TAccountRecipientWrappedTokenAccount,
+            TAccountWrappedMint extends string ? WritableAccount<TAccountWrappedMint> : TAccountWrappedMint,
+            TAccountWrappedMintAuthority extends string
+                ? ReadonlyAccount<TAccountWrappedMintAuthority>
+                : TAccountWrappedMintAuthority,
+            TAccountUnwrappedTokenProgram extends string
+                ? ReadonlyAccount<TAccountUnwrappedTokenProgram>
+                : TAccountUnwrappedTokenProgram,
+            TAccountWrappedTokenProgram extends string
+                ? ReadonlyAccount<TAccountWrappedTokenProgram>
+                : TAccountWrappedTokenProgram,
+            TAccountUnwrappedTokenAccount extends string
+                ? WritableAccount<TAccountUnwrappedTokenAccount>
+                : TAccountUnwrappedTokenAccount,
+            TAccountUnwrappedMint extends string ? ReadonlyAccount<TAccountUnwrappedMint> : TAccountUnwrappedMint,
+            TAccountUnwrappedEscrow extends string ? WritableAccount<TAccountUnwrappedEscrow> : TAccountUnwrappedEscrow,
+            TAccountTransferAuthority extends string
+                ? ReadonlyAccount<TAccountTransferAuthority>
+                : TAccountTransferAuthority,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type WrapInstructionData = {
+    discriminator: number;
+    /** The amount of tokens to wrap. */
+    amount: bigint;
+};
+
+export type WrapInstructionDataArgs = {
+    /** The amount of tokens to wrap. */
+    amount: number | bigint;
+};
+
+export function getWrapInstructionDataEncoder(): FixedSizeEncoder<WrapInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU8Encoder()],
+            ['amount', getU64Encoder()],
+        ]),
+        value => ({ ...value, discriminator: WRAP_DISCRIMINATOR }),
+    );
+}
+
+export function getWrapInstructionDataDecoder(): FixedSizeDecoder<WrapInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU8Decoder()],
+        ['amount', getU64Decoder()],
+    ]);
+}
+
+export function getWrapInstructionDataCodec(): FixedSizeCodec<WrapInstructionDataArgs, WrapInstructionData> {
+    return combineCodec(getWrapInstructionDataEncoder(), getWrapInstructionDataDecoder());
+}
+
+export type WrapInput<
+    TAccountRecipientWrappedTokenAccount extends string = string,
+    TAccountWrappedMint extends string = string,
+    TAccountWrappedMintAuthority extends string = string,
+    TAccountUnwrappedTokenProgram extends string = string,
+    TAccountWrappedTokenProgram extends string = string,
+    TAccountUnwrappedTokenAccount extends string = string,
+    TAccountUnwrappedMint extends string = string,
+    TAccountUnwrappedEscrow extends string = string,
+    TAccountTransferAuthority extends string = string,
+> = {
+    /** The token account to receive the wrapped tokens. */
+    recipientWrappedTokenAccount: Address<TAccountRecipientWrappedTokenAccount>;
+    /**
+     * Wrapped mint, must be initialized, address must be:
+     * `get_wrapped_mint_address(unwrapped_mint_address, wrapped_token_program_id)`
+     */
+    wrappedMint: Address<TAccountWrappedMint>;
+    /**
+     * The PDA authority of the wrapped mint, address must be
+     * `get_wrapped_mint_authority(wrapped_mint)`
+     */
+    wrappedMintAuthority: Address<TAccountWrappedMintAuthority>;
+    /** The token program of the unwrapped tokens. */
+    unwrappedTokenProgram: Address<TAccountUnwrappedTokenProgram>;
+    /** The token program of the wrapped tokens. */
+    wrappedTokenProgram: Address<TAccountWrappedTokenProgram>;
+    /** The source token account for the unwrapped tokens. */
+    unwrappedTokenAccount: Address<TAccountUnwrappedTokenAccount>;
+    /** The mint of the unwrapped tokens. */
+    unwrappedMint: Address<TAccountUnwrappedMint>;
+    /**
+     * The escrow account that holds the unwrapped tokens.
+     * Address must be ATA: get_escrow_address(unwrapped_mint, unwrapped_token_program, wrapped_token_program)
+     */
+    unwrappedEscrow: Address<TAccountUnwrappedEscrow>;
+    /** The authority to transfer the unwrapped tokens. */
+    transferAuthority: Address<TAccountTransferAuthority> | TransactionSigner<TAccountTransferAuthority>;
+    amount: WrapInstructionDataArgs['amount'];
+    multiSigners?: Array<TransactionSigner>;
+};
+
+export function getWrapInstruction<
+    TAccountRecipientWrappedTokenAccount extends string,
+    TAccountWrappedMint extends string,
+    TAccountWrappedMintAuthority extends string,
+    TAccountUnwrappedTokenProgram extends string,
+    TAccountWrappedTokenProgram extends string,
+    TAccountUnwrappedTokenAccount extends string,
+    TAccountUnwrappedMint extends string,
+    TAccountUnwrappedEscrow extends string,
+    TAccountTransferAuthority extends string,
+    TProgramAddress extends Address = typeof TOKEN_WRAP_PROGRAM_ADDRESS,
+>(
+    input: WrapInput<
+        TAccountRecipientWrappedTokenAccount,
+        TAccountWrappedMint,
+        TAccountWrappedMintAuthority,
+        TAccountUnwrappedTokenProgram,
+        TAccountWrappedTokenProgram,
+        TAccountUnwrappedTokenAccount,
+        TAccountUnwrappedMint,
+        TAccountUnwrappedEscrow,
+        TAccountTransferAuthority
+    >,
+    config?: { programAddress?: TProgramAddress },
+): WrapInstruction<
+    TProgramAddress,
+    TAccountRecipientWrappedTokenAccount,
+    TAccountWrappedMint,
+    TAccountWrappedMintAuthority,
+    TAccountUnwrappedTokenProgram,
+    TAccountWrappedTokenProgram,
+    TAccountUnwrappedTokenAccount,
+    TAccountUnwrappedMint,
+    TAccountUnwrappedEscrow,
+    (typeof input)['transferAuthority'] extends TransactionSigner<TAccountTransferAuthority>
+        ? ReadonlySignerAccount<TAccountTransferAuthority> & AccountSignerMeta<TAccountTransferAuthority>
+        : TAccountTransferAuthority
+> {
+    // Program address.
+    const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        recipientWrappedTokenAccount: { value: input.recipientWrappedTokenAccount ?? null, isWritable: true },
+        wrappedMint: { value: input.wrappedMint ?? null, isWritable: true },
+        wrappedMintAuthority: { value: input.wrappedMintAuthority ?? null, isWritable: false },
+        unwrappedTokenProgram: { value: input.unwrappedTokenProgram ?? null, isWritable: false },
+        wrappedTokenProgram: { value: input.wrappedTokenProgram ?? null, isWritable: false },
+        unwrappedTokenAccount: { value: input.unwrappedTokenAccount ?? null, isWritable: true },
+        unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
+        unwrappedEscrow: { value: input.unwrappedEscrow ?? null, isWritable: true },
+        transferAuthority: { value: input.transferAuthority ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Original args.
+    const args = { ...input };
+
+    // Remaining accounts.
+    const remainingAccounts: AccountMeta[] = (args.multiSigners ?? []).map(signer => ({
+        address: signer.address,
+        role: AccountRole.READONLY_SIGNER,
+        signer,
+    }));
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta('recipientWrappedTokenAccount', accounts.recipientWrappedTokenAccount),
+            getAccountMeta('wrappedMint', accounts.wrappedMint),
+            getAccountMeta('wrappedMintAuthority', accounts.wrappedMintAuthority),
+            getAccountMeta('unwrappedTokenProgram', accounts.unwrappedTokenProgram),
+            getAccountMeta('wrappedTokenProgram', accounts.wrappedTokenProgram),
+            getAccountMeta('unwrappedTokenAccount', accounts.unwrappedTokenAccount),
+            getAccountMeta('unwrappedMint', accounts.unwrappedMint),
+            getAccountMeta('unwrappedEscrow', accounts.unwrappedEscrow),
+            getAccountMeta('transferAuthority', accounts.transferAuthority),
+            ...remainingAccounts,
+        ],
+        data: getWrapInstructionDataEncoder().encode(args as WrapInstructionDataArgs),
+        programAddress,
+    } as WrapInstruction<
+        TProgramAddress,
+        TAccountRecipientWrappedTokenAccount,
+        TAccountWrappedMint,
+        TAccountWrappedMintAuthority,
+        TAccountUnwrappedTokenProgram,
+        TAccountWrappedTokenProgram,
+        TAccountUnwrappedTokenAccount,
+        TAccountUnwrappedMint,
+        TAccountUnwrappedEscrow,
+        (typeof input)['transferAuthority'] extends TransactionSigner<TAccountTransferAuthority>
+            ? ReadonlySignerAccount<TAccountTransferAuthority> & AccountSignerMeta<TAccountTransferAuthority>
+            : TAccountTransferAuthority
+    >);
+}
+
+export type ParsedWrapInstruction<
+    TProgram extends string = typeof TOKEN_WRAP_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        /** The token account to receive the wrapped tokens. */
+        recipientWrappedTokenAccount: TAccountMetas[0];
+        /**
+         * Wrapped mint, must be initialized, address must be:
+         * `get_wrapped_mint_address(unwrapped_mint_address, wrapped_token_program_id)`
+         */
+        wrappedMint: TAccountMetas[1];
+        /**
+         * The PDA authority of the wrapped mint, address must be
+         * `get_wrapped_mint_authority(wrapped_mint)`
+         */
+        wrappedMintAuthority: TAccountMetas[2];
+        /** The token program of the unwrapped tokens. */
+        unwrappedTokenProgram: TAccountMetas[3];
+        /** The token program of the wrapped tokens. */
+        wrappedTokenProgram: TAccountMetas[4];
+        /** The source token account for the unwrapped tokens. */
+        unwrappedTokenAccount: TAccountMetas[5];
+        /** The mint of the unwrapped tokens. */
+        unwrappedMint: TAccountMetas[6];
+        /**
+         * The escrow account that holds the unwrapped tokens.
+         * Address must be ATA: get_escrow_address(unwrapped_mint, unwrapped_token_program, wrapped_token_program)
+         */
+        unwrappedEscrow: TAccountMetas[7];
+        /** The authority to transfer the unwrapped tokens. */
+        transferAuthority: TAccountMetas[8];
+    };
+    data: WrapInstructionData;
+};
+
+export function parseWrapInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedWrapInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 9) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 9,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: {
+            recipientWrappedTokenAccount: getNextAccount(),
+            wrappedMint: getNextAccount(),
+            wrappedMintAuthority: getNextAccount(),
+            unwrappedTokenProgram: getNextAccount(),
+            wrappedTokenProgram: getNextAccount(),
+            unwrappedTokenAccount: getNextAccount(),
+            unwrappedMint: getNextAccount(),
+            unwrappedEscrow: getNextAccount(),
+            transferAuthority: getNextAccount(),
+        },
+        data: getWrapInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/pdas/backpointer.ts

@@ -0,0 +1,32 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    getAddressEncoder,
+    getProgramDerivedAddress,
+    getUtf8Encoder,
+    type Address,
+    type ProgramDerivedAddress,
+} from '@solana/kit';
+
+export type BackpointerSeeds = {
+    wrappedMint: Address;
+};
+
+export async function findBackpointerPda(
+    seeds: BackpointerSeeds,
+    config: { programAddress?: Address | undefined } = {},
+): Promise<ProgramDerivedAddress> {
+    const {
+        programAddress = 'TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR' as Address<'TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR'>,
+    } = config;
+    return await getProgramDerivedAddress({
+        programAddress,
+        seeds: [getUtf8Encoder().encode('backpointer'), getAddressEncoder().encode(seeds.wrappedMint)],
+    });
+}

package/{dist/types/src/generated/pdas/index.d.ts → src/generated/pdas/index.ts}

@@ -5,6 +5,7 @@
  *
  * @see https://github.com/codama-idl/codama
  */
+
 export * from './backpointer';
 export * from './wrappedMint';
 export * from './wrappedMintAuthority';

package/src/generated/pdas/wrappedMint.ts

@@ -0,0 +1,37 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    getAddressEncoder,
+    getProgramDerivedAddress,
+    getUtf8Encoder,
+    type Address,
+    type ProgramDerivedAddress,
+} from '@solana/kit';
+
+export type WrappedMintSeeds = {
+    unwrappedMint: Address;
+    wrappedTokenProgram: Address;
+};
+
+export async function findWrappedMintPda(
+    seeds: WrappedMintSeeds,
+    config: { programAddress?: Address | undefined } = {},
+): Promise<ProgramDerivedAddress> {
+    const {
+        programAddress = 'TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR' as Address<'TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR'>,
+    } = config;
+    return await getProgramDerivedAddress({
+        programAddress,
+        seeds: [
+            getUtf8Encoder().encode('mint'),
+            getAddressEncoder().encode(seeds.unwrappedMint),
+            getAddressEncoder().encode(seeds.wrappedTokenProgram),
+        ],
+    });
+}

package/src/generated/pdas/wrappedMintAuthority.ts

@@ -0,0 +1,32 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    getAddressEncoder,
+    getProgramDerivedAddress,
+    getUtf8Encoder,
+    type Address,
+    type ProgramDerivedAddress,
+} from '@solana/kit';
+
+export type WrappedMintAuthoritySeeds = {
+    wrappedMint: Address;
+};
+
+export async function findWrappedMintAuthorityPda(
+    seeds: WrappedMintAuthoritySeeds,
+    config: { programAddress?: Address | undefined } = {},
+): Promise<ProgramDerivedAddress> {
+    const {
+        programAddress = 'TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR' as Address<'TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR'>,
+    } = config;
+    return await getProgramDerivedAddress({
+        programAddress,
+        seeds: [getUtf8Encoder().encode('authority'), getAddressEncoder().encode(seeds.wrappedMint)],
+    });
+}

package/{dist/types/src/generated/programs/index.d.ts → src/generated/programs/index.ts}

@@ -5,4 +5,5 @@
  *
  * @see https://github.com/codama-idl/codama
  */
+
 export * from './tokenWrap';

package/src/generated/programs/tokenWrap.ts

@@ -0,0 +1,228 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    assertIsInstructionWithAccounts,
+    containsBytes,
+    extendClient,
+    getU8Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+    SolanaError,
+    type Address,
+    type ClientWithRpc,
+    type ClientWithTransactionPlanning,
+    type ClientWithTransactionSending,
+    type ExtendedClient,
+    type GetAccountInfoApi,
+    type GetMultipleAccountsApi,
+    type Instruction,
+    type InstructionWithData,
+    type ReadonlyUint8Array,
+} from '@solana/kit';
+import {
+    addSelfFetchFunctions,
+    addSelfPlanAndSendFunctions,
+    type SelfFetchFunctions,
+    type SelfPlanAndSendFunctions,
+} from '@solana/program-client-core';
+import { getBackpointerCodec, type Backpointer, type BackpointerArgs } from '../accounts';
+import {
+    getCloseStuckEscrowInstruction,
+    getCreateMintInstruction,
+    getSyncMetadataToSplTokenInstruction,
+    getSyncMetadataToToken2022Instruction,
+    getUnwrapInstruction,
+    getWrapInstruction,
+    parseCloseStuckEscrowInstruction,
+    parseCreateMintInstruction,
+    parseSyncMetadataToSplTokenInstruction,
+    parseSyncMetadataToToken2022Instruction,
+    parseUnwrapInstruction,
+    parseWrapInstruction,
+    type CloseStuckEscrowInput,
+    type CreateMintInput,
+    type ParsedCloseStuckEscrowInstruction,
+    type ParsedCreateMintInstruction,
+    type ParsedSyncMetadataToSplTokenInstruction,
+    type ParsedSyncMetadataToToken2022Instruction,
+    type ParsedUnwrapInstruction,
+    type ParsedWrapInstruction,
+    type SyncMetadataToSplTokenInput,
+    type SyncMetadataToToken2022Input,
+    type UnwrapInput,
+    type WrapInput,
+} from '../instructions';
+import { findBackpointerPda, findWrappedMintAuthorityPda, findWrappedMintPda } from '../pdas';
+
+export const TOKEN_WRAP_PROGRAM_ADDRESS =
+    'TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR' as Address<'TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR'>;
+
+export enum TokenWrapAccount {
+    Backpointer,
+}
+
+export enum TokenWrapInstruction {
+    CreateMint,
+    Wrap,
+    Unwrap,
+    CloseStuckEscrow,
+    SyncMetadataToToken2022,
+    SyncMetadataToSplToken,
+}
+
+export function identifyTokenWrapInstruction(
+    instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): TokenWrapInstruction {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, getU8Encoder().encode(0), 0)) {
+        return TokenWrapInstruction.CreateMint;
+    }
+    if (containsBytes(data, getU8Encoder().encode(1), 0)) {
+        return TokenWrapInstruction.Wrap;
+    }
+    if (containsBytes(data, getU8Encoder().encode(2), 0)) {
+        return TokenWrapInstruction.Unwrap;
+    }
+    if (containsBytes(data, getU8Encoder().encode(3), 0)) {
+        return TokenWrapInstruction.CloseStuckEscrow;
+    }
+    if (containsBytes(data, getU8Encoder().encode(4), 0)) {
+        return TokenWrapInstruction.SyncMetadataToToken2022;
+    }
+    if (containsBytes(data, getU8Encoder().encode(5), 0)) {
+        return TokenWrapInstruction.SyncMetadataToSplToken;
+    }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
+        instructionData: data,
+        programName: 'tokenWrap',
+    });
+}
+
+export type ParsedTokenWrapInstruction<TProgram extends string = 'TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR'> =
+    | ({ instructionType: TokenWrapInstruction.CreateMint } & ParsedCreateMintInstruction<TProgram>)
+    | ({ instructionType: TokenWrapInstruction.Wrap } & ParsedWrapInstruction<TProgram>)
+    | ({ instructionType: TokenWrapInstruction.Unwrap } & ParsedUnwrapInstruction<TProgram>)
+    | ({ instructionType: TokenWrapInstruction.CloseStuckEscrow } & ParsedCloseStuckEscrowInstruction<TProgram>)
+    | ({
+          instructionType: TokenWrapInstruction.SyncMetadataToToken2022;
+      } & ParsedSyncMetadataToToken2022Instruction<TProgram>)
+    | ({
+          instructionType: TokenWrapInstruction.SyncMetadataToSplToken;
+      } & ParsedSyncMetadataToSplTokenInstruction<TProgram>);
+
+export function parseTokenWrapInstruction<TProgram extends string>(
+    instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedTokenWrapInstruction<TProgram> {
+    const instructionType = identifyTokenWrapInstruction(instruction);
+    switch (instructionType) {
+        case TokenWrapInstruction.CreateMint: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: TokenWrapInstruction.CreateMint, ...parseCreateMintInstruction(instruction) };
+        }
+        case TokenWrapInstruction.Wrap: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: TokenWrapInstruction.Wrap, ...parseWrapInstruction(instruction) };
+        }
+        case TokenWrapInstruction.Unwrap: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: TokenWrapInstruction.Unwrap, ...parseUnwrapInstruction(instruction) };
+        }
+        case TokenWrapInstruction.CloseStuckEscrow: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: TokenWrapInstruction.CloseStuckEscrow,
+                ...parseCloseStuckEscrowInstruction(instruction),
+            };
+        }
+        case TokenWrapInstruction.SyncMetadataToToken2022: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: TokenWrapInstruction.SyncMetadataToToken2022,
+                ...parseSyncMetadataToToken2022Instruction(instruction),
+            };
+        }
+        case TokenWrapInstruction.SyncMetadataToSplToken: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: TokenWrapInstruction.SyncMetadataToSplToken,
+                ...parseSyncMetadataToSplTokenInstruction(instruction),
+            };
+        }
+        default:
+            throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
+                instructionType: instructionType as string,
+                programName: 'tokenWrap',
+            });
+    }
+}
+
+export type TokenWrapPlugin = {
+    accounts: TokenWrapPluginAccounts;
+    instructions: TokenWrapPluginInstructions;
+    pdas: TokenWrapPluginPdas;
+    identifyInstruction: typeof identifyTokenWrapInstruction;
+    parseInstruction: typeof parseTokenWrapInstruction;
+};
+
+export type TokenWrapPluginAccounts = {
+    backpointer: ReturnType<typeof getBackpointerCodec> & SelfFetchFunctions<BackpointerArgs, Backpointer>;
+};
+
+export type TokenWrapPluginInstructions = {
+    createMint: (input: CreateMintInput) => ReturnType<typeof getCreateMintInstruction> & SelfPlanAndSendFunctions;
+    wrap: (input: WrapInput) => ReturnType<typeof getWrapInstruction> & SelfPlanAndSendFunctions;
+    unwrap: (input: UnwrapInput) => ReturnType<typeof getUnwrapInstruction> & SelfPlanAndSendFunctions;
+    closeStuckEscrow: (
+        input: CloseStuckEscrowInput,
+    ) => ReturnType<typeof getCloseStuckEscrowInstruction> & SelfPlanAndSendFunctions;
+    syncMetadataToToken2022: (
+        input: SyncMetadataToToken2022Input,
+    ) => ReturnType<typeof getSyncMetadataToToken2022Instruction> & SelfPlanAndSendFunctions;
+    syncMetadataToSplToken: (
+        input: SyncMetadataToSplTokenInput,
+    ) => ReturnType<typeof getSyncMetadataToSplTokenInstruction> & SelfPlanAndSendFunctions;
+};
+
+export type TokenWrapPluginPdas = {
+    backpointer: typeof findBackpointerPda;
+    wrappedMint: typeof findWrappedMintPda;
+    wrappedMintAuthority: typeof findWrappedMintAuthorityPda;
+};
+
+export type TokenWrapPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> &
+    ClientWithTransactionPlanning &
+    ClientWithTransactionSending;
+
+export function tokenWrapProgram() {
+    return <T extends TokenWrapPluginRequirements>(client: T): ExtendedClient<T, { tokenWrap: TokenWrapPlugin }> => {
+        return extendClient(client, {
+            tokenWrap: <TokenWrapPlugin>{
+                accounts: { backpointer: addSelfFetchFunctions(client, getBackpointerCodec()) },
+                instructions: {
+                    createMint: input => addSelfPlanAndSendFunctions(client, getCreateMintInstruction(input)),
+                    wrap: input => addSelfPlanAndSendFunctions(client, getWrapInstruction(input)),
+                    unwrap: input => addSelfPlanAndSendFunctions(client, getUnwrapInstruction(input)),
+                    closeStuckEscrow: input =>
+                        addSelfPlanAndSendFunctions(client, getCloseStuckEscrowInstruction(input)),
+                    syncMetadataToToken2022: input =>
+                        addSelfPlanAndSendFunctions(client, getSyncMetadataToToken2022Instruction(input)),
+                    syncMetadataToSplToken: input =>
+                        addSelfPlanAndSendFunctions(client, getSyncMetadataToSplTokenInstruction(input)),
+                },
+                pdas: {
+                    backpointer: findBackpointerPda,
+                    wrappedMint: findWrappedMintPda,
+                    wrappedMintAuthority: findWrappedMintAuthorityPda,
+                },
+                identifyInstruction: identifyTokenWrapInstruction,
+                parseInstruction: parseTokenWrapInstruction,
+            },
+        });
+    };
+}

package/src/global.d.ts

@@ -0,0 +1,8 @@
+// Done to appease issue in generated code:
+//  error TS4111: Property 'NODE_ENV' comes from an index signature, so it must be accessed with ['NODE_ENV'].
+
+declare namespace NodeJS {
+    interface ProcessEnv {
+        NODE_ENV: string;
+    }
+}