@solana-program/token-wrap 2.3.0 → 2.5.0

package/src/examples/sync-spl-to-token2022.ts

@@ -0,0 +1,96 @@
+import {
+    address,
+    appendTransactionMessageInstructions,
+    assertIsSendableTransaction,
+    assertIsTransactionWithBlockhashLifetime,
+    createKeyPairSignerFromBytes,
+    createSolanaRpc,
+    createSolanaRpcSubscriptions,
+    createTransactionMessage,
+    getSignatureFromTransaction,
+    pipe,
+    sendAndConfirmTransactionFactory,
+    setTransactionMessageFeePayerSigner,
+    setTransactionMessageLifetimeUsingBlockhash,
+    signTransactionMessageWithSigners,
+} from '@solana/kit';
+import { TOKEN_2022_PROGRAM_ADDRESS } from '@solana-program/token-2022';
+import { getAddressEncoder, getProgramDerivedAddress, getUtf8Encoder } from '@solana/kit';
+import { findWrappedMintAuthorityPda, findWrappedMintPda, getSyncMetadataToToken2022Instruction } from '../index';
+
+// =================================================================
+// PREREQUISITES:
+// =================================================================
+// 1. An unwrapped SPL Token mint with Metaplex metadata must exist.
+// 2. The corresponding wrapped Token-2022 mint for it must have been created
+//    via the `create-mint` command or `createMint` helper.
+//
+// This example ASSUMES these accounts already exist and focuses only on the
+// transaction to sync the metadata.
+
+// Replace these consts with the addresses from your setup
+const PRIVATE_KEY_PAIR = new Uint8Array([
+    242, 30, 38, 177, 152, 71, 235, 193, 93, 30, 119, 131, 42, 186, 202, 7, 45, 250, 126, 135, 107, 137, 38, 91, 202,
+    212, 12, 8, 154, 213, 163, 200, 23, 237, 17, 163, 3, 135, 34, 126, 235, 146, 251, 18, 199, 101, 153, 249, 134, 88,
+    219, 68, 167, 136, 234, 195, 12, 34, 184, 85, 234, 25, 125, 94,
+]);
+
+// Source Mint: An existing SPL Token mint with Metaplex metadata
+const UNWRAPPED_SPL_TOKEN_MINT = address('8owJWKMiKfMKYbPmobyZAwXibNFcY7Roj6quktaeqxGL');
+
+async function main() {
+    const rpc = createSolanaRpc('http://127.0.0.1:8899');
+    const rpcSubscriptions = createSolanaRpcSubscriptions('ws://127.0.0.1:8900');
+    const sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });
+
+    const payer = await createKeyPairSignerFromBytes(PRIVATE_KEY_PAIR);
+    const { value: blockhash } = await rpc.getLatestBlockhash().send();
+
+    console.log('======== Syncing: SPL Token -> Token-2022 ========');
+
+    // To sync from an SPL Token mint, the client must resolve and provide the
+    // Metaplex Metadata PDA as the `sourceMetadata` account.
+    // Derive it using the known Metadata program and seeds: ['metadata', programId, mint]
+    const TOKEN_METADATA_PROGRAM_ADDRESS = address('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
+    const [metaplexMetadataPda] = await getProgramDerivedAddress({
+        programAddress: TOKEN_METADATA_PROGRAM_ADDRESS,
+        seeds: [
+            getUtf8Encoder().encode('metadata'),
+            getAddressEncoder().encode(TOKEN_METADATA_PROGRAM_ADDRESS),
+            getAddressEncoder().encode(UNWRAPPED_SPL_TOKEN_MINT),
+        ],
+    });
+    const [wrappedMint] = await findWrappedMintPda({
+        unwrappedMint: UNWRAPPED_SPL_TOKEN_MINT,
+        wrappedTokenProgram: TOKEN_2022_PROGRAM_ADDRESS,
+    });
+    const [wrappedMintAuthority] = await findWrappedMintAuthorityPda({
+        wrappedMint,
+    });
+
+    const syncToT22Ix = getSyncMetadataToToken2022Instruction({
+        wrappedMint,
+        wrappedMintAuthority,
+        unwrappedMint: UNWRAPPED_SPL_TOKEN_MINT,
+        // When the source mint is a standard SPL Token, `sourceMetadata` MUST be
+        // the address of its Metaplex Metadata PDA.
+        sourceMetadata: metaplexMetadataPda,
+    });
+
+    const transaction = await pipe(
+        createTransactionMessage({ version: 0 }),
+        tx => setTransactionMessageFeePayerSigner(payer, tx),
+        tx => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
+        tx => appendTransactionMessageInstructions([syncToT22Ix], tx),
+        tx => signTransactionMessageWithSigners(tx),
+    );
+    assertIsSendableTransaction(transaction);
+    assertIsTransactionWithBlockhashLifetime(transaction);
+    const signature = getSignatureFromTransaction(transaction);
+    await sendAndConfirm(transaction, { commitment: 'confirmed' });
+
+    console.log('Successfully synced metadata to Token-2022 mint.');
+    console.log('Signature:', signature);
+}
+
+void main();

package/src/examples/sync-token2022-to-spl.ts

@@ -0,0 +1,101 @@
+import {
+    address,
+    appendTransactionMessageInstructions,
+    assertIsSendableTransaction,
+    assertIsTransactionWithBlockhashLifetime,
+    createKeyPairSignerFromBytes,
+    createSolanaRpc,
+    createSolanaRpcSubscriptions,
+    createTransactionMessage,
+    getAddressEncoder,
+    getProgramDerivedAddress,
+    getSignatureFromTransaction,
+    getUtf8Encoder,
+    pipe,
+    sendAndConfirmTransactionFactory,
+    setTransactionMessageFeePayerSigner,
+    setTransactionMessageLifetimeUsingBlockhash,
+    signTransactionMessageWithSigners,
+} from '@solana/kit';
+import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+import { findWrappedMintAuthorityPda, findWrappedMintPda, getSyncMetadataToSplTokenInstruction } from '../index';
+
+// =================================================================
+// PREREQUISITES:
+// =================================================================
+// 1. An unwrapped Token-2022 mint with `TokenMetadata` and `MetadataPointer`
+//    extensions must exist. The pointer should point to the mint itself.
+// 2. The corresponding wrapped SPL Token mint for it must have been created
+//    via the `create-mint` command or `createMint` helper.
+// 3. The wrapped mint authority PDA must be funded with enough SOL to pay for
+//    the creation of the Metaplex metadata account, as it acts as the payer
+//    for the CPI to the Metaplex program.
+//
+// This example ASSUMES these accounts already exist and focuses only on the
+// transaction to sync the metadata.
+
+// Replace these consts with the addresses from your setup
+const PRIVATE_KEY_PAIR = new Uint8Array([
+    242, 30, 38, 177, 152, 71, 235, 193, 93, 30, 119, 131, 42, 186, 202, 7, 45, 250, 126, 135, 107, 137, 38, 91, 202,
+    212, 12, 8, 154, 213, 163, 200, 23, 237, 17, 163, 3, 135, 34, 126, 235, 146, 251, 18, 199, 101, 153, 249, 134, 88,
+    219, 68, 167, 136, 234, 195, 12, 34, 184, 85, 234, 25, 125, 94,
+]);
+
+// Source Mint: An existing Token-2022 mint with metadata extensions
+const UNWRAPPED_TOKEN_2022_MINT = address('5xte8yNSUTrTtfdptekeA4QJyo8zZdanpDJojrRaXP1Y');
+
+async function main() {
+    const rpc = createSolanaRpc('http://127.0.0.1:8899');
+    const rpcSubscriptions = createSolanaRpcSubscriptions('ws://127.0.0.1:8900');
+    const sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });
+
+    const payer = await createKeyPairSignerFromBytes(PRIVATE_KEY_PAIR);
+    const { value: blockhash } = await rpc.getLatestBlockhash().send();
+
+    console.log('======== Syncing: Token-2022 -> SPL Token ========');
+
+    // Derive the wrapped SPL Token mint PDA
+    const [wrappedMint] = await findWrappedMintPda({
+        unwrappedMint: UNWRAPPED_TOKEN_2022_MINT,
+        wrappedTokenProgram: TOKEN_PROGRAM_ADDRESS,
+    });
+
+    // Derive the Metaplex Metadata PDA for the wrapped mint.
+    const TOKEN_METADATA_PROGRAM_ADDRESS = address('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
+    const [metaplexMetadataPda] = await getProgramDerivedAddress({
+        programAddress: TOKEN_METADATA_PROGRAM_ADDRESS,
+        seeds: [
+            getUtf8Encoder().encode('metadata'),
+            getAddressEncoder().encode(TOKEN_METADATA_PROGRAM_ADDRESS),
+            getAddressEncoder().encode(wrappedMint),
+        ],
+    });
+
+    const [wrappedMintAuthority] = await findWrappedMintAuthorityPda({
+        wrappedMint,
+    });
+
+    const syncToSplIx = getSyncMetadataToSplTokenInstruction({
+        metaplexMetadata: metaplexMetadataPda,
+        wrappedMint,
+        wrappedMintAuthority,
+        unwrappedMint: UNWRAPPED_TOKEN_2022_MINT,
+    });
+
+    const transaction = await pipe(
+        createTransactionMessage({ version: 0 }),
+        tx => setTransactionMessageFeePayerSigner(payer, tx),
+        tx => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
+        tx => appendTransactionMessageInstructions([syncToSplIx], tx),
+        tx => signTransactionMessageWithSigners(tx),
+    );
+    assertIsSendableTransaction(transaction);
+    assertIsTransactionWithBlockhashLifetime(transaction);
+    const signature = getSignatureFromTransaction(transaction);
+    await sendAndConfirm(transaction, { commitment: 'confirmed' });
+
+    console.log('Successfully synced metadata to SPL Token Metaplex account.');
+    console.log('Signature:', signature);
+}
+
+void main();

package/src/generated/accounts/backpointer.ts

@@ -0,0 +1,125 @@
+/**
+ * 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 {
+    assertAccountExists,
+    assertAccountsExist,
+    combineCodec,
+    decodeAccount,
+    fetchEncodedAccount,
+    fetchEncodedAccounts,
+    getAddressDecoder,
+    getAddressEncoder,
+    getStructDecoder,
+    getStructEncoder,
+    type Account,
+    type Address,
+    type EncodedAccount,
+    type FetchAccountConfig,
+    type FetchAccountsConfig,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type MaybeAccount,
+    type MaybeEncodedAccount,
+} from '@solana/kit';
+import { BackpointerSeeds, findBackpointerPda } from '../pdas';
+
+/** Account to store the address of the unwrapped mint. */
+export type Backpointer = { unwrappedMint: Address };
+
+export type BackpointerArgs = Backpointer;
+
+/** Gets the encoder for {@link BackpointerArgs} account data. */
+export function getBackpointerEncoder(): FixedSizeEncoder<BackpointerArgs> {
+    return getStructEncoder([['unwrappedMint', getAddressEncoder()]]);
+}
+
+/** Gets the decoder for {@link Backpointer} account data. */
+export function getBackpointerDecoder(): FixedSizeDecoder<Backpointer> {
+    return getStructDecoder([['unwrappedMint', getAddressDecoder()]]);
+}
+
+/** Gets the codec for {@link Backpointer} account data. */
+export function getBackpointerCodec(): FixedSizeCodec<BackpointerArgs, Backpointer> {
+    return combineCodec(getBackpointerEncoder(), getBackpointerDecoder());
+}
+
+export function decodeBackpointer<TAddress extends string = string>(
+    encodedAccount: EncodedAccount<TAddress>,
+): Account<Backpointer, TAddress>;
+export function decodeBackpointer<TAddress extends string = string>(
+    encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<Backpointer, TAddress>;
+export function decodeBackpointer<TAddress extends string = string>(
+    encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<Backpointer, TAddress> | MaybeAccount<Backpointer, TAddress> {
+    return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getBackpointerDecoder());
+}
+
+export async function fetchBackpointer<TAddress extends string = string>(
+    rpc: Parameters<typeof fetchEncodedAccount>[0],
+    address: Address<TAddress>,
+    config?: FetchAccountConfig,
+): Promise<Account<Backpointer, TAddress>> {
+    const maybeAccount = await fetchMaybeBackpointer(rpc, address, config);
+    assertAccountExists(maybeAccount);
+    return maybeAccount;
+}
+
+export async function fetchMaybeBackpointer<TAddress extends string = string>(
+    rpc: Parameters<typeof fetchEncodedAccount>[0],
+    address: Address<TAddress>,
+    config?: FetchAccountConfig,
+): Promise<MaybeAccount<Backpointer, TAddress>> {
+    const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+    return decodeBackpointer(maybeAccount);
+}
+
+export async function fetchAllBackpointer(
+    rpc: Parameters<typeof fetchEncodedAccounts>[0],
+    addresses: Array<Address>,
+    config?: FetchAccountsConfig,
+): Promise<Account<Backpointer>[]> {
+    const maybeAccounts = await fetchAllMaybeBackpointer(rpc, addresses, config);
+    assertAccountsExist(maybeAccounts);
+    return maybeAccounts;
+}
+
+export async function fetchAllMaybeBackpointer(
+    rpc: Parameters<typeof fetchEncodedAccounts>[0],
+    addresses: Array<Address>,
+    config?: FetchAccountsConfig,
+): Promise<MaybeAccount<Backpointer>[]> {
+    const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+    return maybeAccounts.map(maybeAccount => decodeBackpointer(maybeAccount));
+}
+
+export function getBackpointerSize(): number {
+    return 32;
+}
+
+export async function fetchBackpointerFromSeeds(
+    rpc: Parameters<typeof fetchEncodedAccount>[0],
+    seeds: BackpointerSeeds,
+    config: FetchAccountConfig & { programAddress?: Address } = {},
+): Promise<Account<Backpointer>> {
+    const maybeAccount = await fetchMaybeBackpointerFromSeeds(rpc, seeds, config);
+    assertAccountExists(maybeAccount);
+    return maybeAccount;
+}
+
+export async function fetchMaybeBackpointerFromSeeds(
+    rpc: Parameters<typeof fetchEncodedAccount>[0],
+    seeds: BackpointerSeeds,
+    config: FetchAccountConfig & { programAddress?: Address } = {},
+): Promise<MaybeAccount<Backpointer>> {
+    const { programAddress, ...fetchConfig } = config;
+    const [address] = await findBackpointerPda(seeds, { programAddress });
+    return await fetchMaybeBackpointer(rpc, address, fetchConfig);
+}

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

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

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

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

package/src/generated/errors/tokenWrap.ts

@@ -0,0 +1,89 @@
+/**
+ * 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 {
+    isProgramError,
+    type Address,
+    type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM,
+    type SolanaError,
+} from '@solana/kit';
+import { TOKEN_WRAP_PROGRAM_ADDRESS } from '../programs';
+
+export const TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH = 0x0; // 0
+export const TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH = 0x1; // 1
+export const TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT = 0x2; // 2
+export const TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH = 0x3; // 3
+export const TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH = 0x4; // 4
+export const TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER = 0x5; // 5
+export const TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER = 0x6; // 6
+export const TOKEN_WRAP_ERROR__ESCROW_MISMATCH = 0x7; // 7
+export const TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE = 0x8; // 8
+export const TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA = 0x9; // 9
+export const TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH = 0xa; // 10
+export const TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING = 0xb; // 11
+export const TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET = 0xc; // 12
+export const TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH = 0xd; // 13
+export const TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA = 0xe; // 14
+export const TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022 = 0xf; // 15
+
+export type TokenWrapError =
+    | typeof TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH
+    | typeof TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE
+    | typeof TOKEN_WRAP_ERROR__ESCROW_MISMATCH
+    | typeof TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH
+    | typeof TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA
+    | typeof TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER
+    | typeof TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER
+    | typeof TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH
+    | typeof TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING
+    | typeof TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET
+    | typeof TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH
+    | typeof TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH
+    | typeof TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022
+    | typeof TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA
+    | typeof TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH
+    | typeof TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT;
+
+let tokenWrapErrorMessages: Record<TokenWrapError, string> | undefined;
+if (process.env['NODE_ENV'] !== 'production') {
+    tokenWrapErrorMessages = {
+        [TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH]: `Wrapped backpointer account address does not match expected PDA`,
+        [TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE]: `The escrow account is in a good state and cannot be recreated`,
+        [TOKEN_WRAP_ERROR__ESCROW_MISMATCH]: `Escrow account address does not match expected ATA`,
+        [TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH]: `Unwrapped escrow token owner is not set to expected PDA`,
+        [TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA]: `External metadata program returned no data`,
+        [TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER]: `Wrapped backpointer account owner is not the expected token wrap program`,
+        [TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER]: `Wrapped mint account owner is not the expected token program`,
+        [TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH]: `Provided source metadata account does not match pointer`,
+        [TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING]: `Metadata pointer extension missing on mint`,
+        [TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET]: `Metadata pointer is unset (None)`,
+        [TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH]: `Metaplex metadata account address does not match expected PDA`,
+        [TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH]: `Wrapped mint authority does not match expected PDA`,
+        [TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022]: `Instruction can only be used with spl-token wrapped mints`,
+        [TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA]: `Unwrapped mint does not have the TokenMetadata extension`,
+        [TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH]: `Wrapped mint account address does not match expected PDA`,
+        [TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT]: `Wrap amount should be positive`,
+    };
+}
+
+export function getTokenWrapErrorMessage(code: TokenWrapError): string {
+    if (process.env['NODE_ENV'] !== 'production') {
+        return (tokenWrapErrorMessages as Record<TokenWrapError, string>)[code];
+    }
+
+    return 'Error message not available in production bundles.';
+}
+
+export function isTokenWrapError<TProgramErrorCode extends TokenWrapError>(
+    error: unknown,
+    transactionMessage: { instructions: Record<number, { programAddress: Address }> },
+    code?: TProgramErrorCode,
+): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> &
+    Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
+    return isProgramError<TProgramErrorCode>(error, transactionMessage, TOKEN_WRAP_PROGRAM_ADDRESS, code);
+}

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

@@ -5,6 +5,7 @@
  *
  * @see https://github.com/codama-idl/codama
  */
+
 export * from './accounts';
 export * from './errors';
 export * from './instructions';

package/src/generated/instructions/closeStuckEscrow.ts

@@ -0,0 +1,235 @@
+/**
+ * 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 {
+    combineCodec,
+    getStructDecoder,
+    getStructEncoder,
+    getU8Decoder,
+    getU8Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
+    transformEncoder,
+    type AccountMeta,
+    type Address,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type ReadonlyAccount,
+    type ReadonlyUint8Array,
+    type WritableAccount,
+} from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/program-client-core';
+import { TOKEN_WRAP_PROGRAM_ADDRESS } from '../programs';
+
+export const CLOSE_STUCK_ESCROW_DISCRIMINATOR = 3;
+
+export function getCloseStuckEscrowDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU8Encoder().encode(CLOSE_STUCK_ESCROW_DISCRIMINATOR);
+}
+
+export type CloseStuckEscrowInstruction<
+    TProgram extends string = typeof TOKEN_WRAP_PROGRAM_ADDRESS,
+    TAccountEscrow extends string | AccountMeta<string> = string,
+    TAccountDestination extends string | AccountMeta<string> = string,
+    TAccountUnwrappedMint extends string | AccountMeta<string> = string,
+    TAccountWrappedMint extends string | AccountMeta<string> = string,
+    TAccountWrappedMintAuthority extends string | AccountMeta<string> = string,
+    TAccountToken2022Program extends string | AccountMeta<string> = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountEscrow extends string ? WritableAccount<TAccountEscrow> : TAccountEscrow,
+            TAccountDestination extends string ? WritableAccount<TAccountDestination> : TAccountDestination,
+            TAccountUnwrappedMint extends string ? ReadonlyAccount<TAccountUnwrappedMint> : TAccountUnwrappedMint,
+            TAccountWrappedMint extends string ? ReadonlyAccount<TAccountWrappedMint> : TAccountWrappedMint,
+            TAccountWrappedMintAuthority extends string
+                ? ReadonlyAccount<TAccountWrappedMintAuthority>
+                : TAccountWrappedMintAuthority,
+            TAccountToken2022Program extends string
+                ? ReadonlyAccount<TAccountToken2022Program>
+                : TAccountToken2022Program,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type CloseStuckEscrowInstructionData = { discriminator: number };
+
+export type CloseStuckEscrowInstructionDataArgs = {};
+
+export function getCloseStuckEscrowInstructionDataEncoder(): FixedSizeEncoder<CloseStuckEscrowInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', getU8Encoder()]]), value => ({
+        ...value,
+        discriminator: CLOSE_STUCK_ESCROW_DISCRIMINATOR,
+    }));
+}
+
+export function getCloseStuckEscrowInstructionDataDecoder(): FixedSizeDecoder<CloseStuckEscrowInstructionData> {
+    return getStructDecoder([['discriminator', getU8Decoder()]]);
+}
+
+export function getCloseStuckEscrowInstructionDataCodec(): FixedSizeCodec<
+    CloseStuckEscrowInstructionDataArgs,
+    CloseStuckEscrowInstructionData
+> {
+    return combineCodec(getCloseStuckEscrowInstructionDataEncoder(), getCloseStuckEscrowInstructionDataDecoder());
+}
+
+export type CloseStuckEscrowInput<
+    TAccountEscrow extends string = string,
+    TAccountDestination extends string = string,
+    TAccountUnwrappedMint extends string = string,
+    TAccountWrappedMint extends string = string,
+    TAccountWrappedMintAuthority extends string = string,
+    TAccountToken2022Program extends string = string,
+> = {
+    /** Escrow account to close (ATA) */
+    escrow: Address<TAccountEscrow>;
+    /** Destination for lamports from closed account */
+    destination: Address<TAccountDestination>;
+    /** Unwrapped mint */
+    unwrappedMint: Address<TAccountUnwrappedMint>;
+    /** Wrapped mint */
+    wrappedMint: Address<TAccountWrappedMint>;
+    /** Wrapped mint authority (PDA) */
+    wrappedMintAuthority: Address<TAccountWrappedMintAuthority>;
+    /** Token-2022 program */
+    token2022Program?: Address<TAccountToken2022Program>;
+};
+
+export function getCloseStuckEscrowInstruction<
+    TAccountEscrow extends string,
+    TAccountDestination extends string,
+    TAccountUnwrappedMint extends string,
+    TAccountWrappedMint extends string,
+    TAccountWrappedMintAuthority extends string,
+    TAccountToken2022Program extends string,
+    TProgramAddress extends Address = typeof TOKEN_WRAP_PROGRAM_ADDRESS,
+>(
+    input: CloseStuckEscrowInput<
+        TAccountEscrow,
+        TAccountDestination,
+        TAccountUnwrappedMint,
+        TAccountWrappedMint,
+        TAccountWrappedMintAuthority,
+        TAccountToken2022Program
+    >,
+    config?: { programAddress?: TProgramAddress },
+): CloseStuckEscrowInstruction<
+    TProgramAddress,
+    TAccountEscrow,
+    TAccountDestination,
+    TAccountUnwrappedMint,
+    TAccountWrappedMint,
+    TAccountWrappedMintAuthority,
+    TAccountToken2022Program
+> {
+    // Program address.
+    const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        escrow: { value: input.escrow ?? null, isWritable: true },
+        destination: { value: input.destination ?? null, isWritable: true },
+        unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
+        wrappedMint: { value: input.wrappedMint ?? null, isWritable: false },
+        wrappedMintAuthority: { value: input.wrappedMintAuthority ?? null, isWritable: false },
+        token2022Program: { value: input.token2022Program ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Resolve default values.
+    if (!accounts.token2022Program.value) {
+        accounts.token2022Program.value =
+            'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb' as Address<'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb'>;
+    }
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta('escrow', accounts.escrow),
+            getAccountMeta('destination', accounts.destination),
+            getAccountMeta('unwrappedMint', accounts.unwrappedMint),
+            getAccountMeta('wrappedMint', accounts.wrappedMint),
+            getAccountMeta('wrappedMintAuthority', accounts.wrappedMintAuthority),
+            getAccountMeta('token2022Program', accounts.token2022Program),
+        ],
+        data: getCloseStuckEscrowInstructionDataEncoder().encode({}),
+        programAddress,
+    } as CloseStuckEscrowInstruction<
+        TProgramAddress,
+        TAccountEscrow,
+        TAccountDestination,
+        TAccountUnwrappedMint,
+        TAccountWrappedMint,
+        TAccountWrappedMintAuthority,
+        TAccountToken2022Program
+    >);
+}
+
+export type ParsedCloseStuckEscrowInstruction<
+    TProgram extends string = typeof TOKEN_WRAP_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        /** Escrow account to close (ATA) */
+        escrow: TAccountMetas[0];
+        /** Destination for lamports from closed account */
+        destination: TAccountMetas[1];
+        /** Unwrapped mint */
+        unwrappedMint: TAccountMetas[2];
+        /** Wrapped mint */
+        wrappedMint: TAccountMetas[3];
+        /** Wrapped mint authority (PDA) */
+        wrappedMintAuthority: TAccountMetas[4];
+        /** Token-2022 program */
+        token2022Program?: TAccountMetas[5] | undefined;
+    };
+    data: CloseStuckEscrowInstructionData;
+};
+
+export function parseCloseStuckEscrowInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedCloseStuckEscrowInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 6) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 6,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    const getNextOptionalAccount = () => {
+        const accountMeta = getNextAccount();
+        return accountMeta.address === TOKEN_WRAP_PROGRAM_ADDRESS ? undefined : accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: {
+            escrow: getNextAccount(),
+            destination: getNextAccount(),
+            unwrappedMint: getNextAccount(),
+            wrappedMint: getNextAccount(),
+            wrappedMintAuthority: getNextAccount(),
+            token2022Program: getNextOptionalAccount(),
+        },
+        data: getCloseStuckEscrowInstructionDataDecoder().decode(instruction.data),
+    };
+}