tokenWrap.ts

/**
 * 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,
            },
        });
    };
}