@robertprp/intents-sdk/src/core/solana/generated/cross-chain/instructions/claimTokens.ts

Shogun Network Intent-based cross-chain swaps SDK

/**
 * 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 { type Address } from '@solana/kit';
import {
  combineCodec,
  fixDecoderSize,
  fixEncoderSize,
  getBytesDecoder,
  getBytesEncoder,
  getStructDecoder,
  getStructEncoder,
  transformEncoder,
  type Codec,
  type Decoder,
  type Encoder,
  type ReadonlyUint8Array,
} from '@solana/kit';
import {
  type IAccountMeta,
  type IInstruction,
  type IInstructionWithAccounts,
  type IInstructionWithData,
  type ReadonlyAccount,
  type WritableAccount,
  type WritableSignerAccount,
} from '@solana/kit';
import { type IAccountSignerMeta, type TransactionSigner } from '@solana/kit';
import { SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS } from '../programs/index.js';
import { getAccountMetaFactory, type ResolvedAccount } from '../shared/index.js';

export const CLAIM_TOKENS_DISCRIMINATOR = new Uint8Array([108, 216, 210, 231, 0, 212, 42, 64]);

export function getClaimTokensDiscriminatorBytes() {
  return fixEncoderSize(getBytesEncoder(), 8).encode(CLAIM_TOKENS_DISCRIMINATOR);
}

export type ClaimTokensInstruction<
  TProgram extends string = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
  TAccountSolver extends string | IAccountMeta<string> = string,
  TAccountOrder extends string | IAccountMeta<string> = string,
  TAccountUser extends string | IAccountMeta<string> = string,
  TAccountGuard extends string | IAccountMeta<string> = string,
  TAccountIxSysvar extends string | IAccountMeta<string> = 'Sysvar1nstructions1111111111111111111111111',
  TAccountRecoveredTokenMint extends string | IAccountMeta<string> = string,
  TAccountSolverRecoveredTokenAccount extends string | IAccountMeta<string> = string,
  TAccountGuardRecoveredTokenAccount extends string | IAccountMeta<string> = string,
  TAccountRecoveredTokenProgram extends string | IAccountMeta<string> = string,
  TAccountCollateralTokenMint extends string | IAccountMeta<string> = string,
  TAccountSolverCollateralTokenAccount extends string | IAccountMeta<string> = string,
  TAccountUserCollateralTokenAccount extends string | IAccountMeta<string> = string,
  TAccountGuardCollateralTokenAccount extends string | IAccountMeta<string> = string,
  TAccountCollateralTokenProgram extends string | IAccountMeta<string> = string,
  TRemainingAccounts extends readonly IAccountMeta<string>[] = [],
> = IInstruction<TProgram> &
  IInstructionWithData<Uint8Array> &
  IInstructionWithAccounts<
    [
      TAccountSolver extends string
        ? WritableSignerAccount<TAccountSolver> & IAccountSignerMeta<TAccountSolver>
        : TAccountSolver,
      TAccountOrder extends string ? WritableAccount<TAccountOrder> : TAccountOrder,
      TAccountUser extends string ? WritableAccount<TAccountUser> : TAccountUser,
      TAccountGuard extends string ? ReadonlyAccount<TAccountGuard> : TAccountGuard,
      TAccountIxSysvar extends string ? ReadonlyAccount<TAccountIxSysvar> : TAccountIxSysvar,
      TAccountRecoveredTokenMint extends string
        ? ReadonlyAccount<TAccountRecoveredTokenMint>
        : TAccountRecoveredTokenMint,
      TAccountSolverRecoveredTokenAccount extends string
        ? WritableAccount<TAccountSolverRecoveredTokenAccount>
        : TAccountSolverRecoveredTokenAccount,
      TAccountGuardRecoveredTokenAccount extends string
        ? WritableAccount<TAccountGuardRecoveredTokenAccount>
        : TAccountGuardRecoveredTokenAccount,
      TAccountRecoveredTokenProgram extends string
        ? ReadonlyAccount<TAccountRecoveredTokenProgram>
        : TAccountRecoveredTokenProgram,
      TAccountCollateralTokenMint extends string
        ? ReadonlyAccount<TAccountCollateralTokenMint>
        : TAccountCollateralTokenMint,
      TAccountSolverCollateralTokenAccount extends string
        ? WritableAccount<TAccountSolverCollateralTokenAccount>
        : TAccountSolverCollateralTokenAccount,
      TAccountUserCollateralTokenAccount extends string
        ? WritableAccount<TAccountUserCollateralTokenAccount>
        : TAccountUserCollateralTokenAccount,
      TAccountGuardCollateralTokenAccount extends string
        ? WritableAccount<TAccountGuardCollateralTokenAccount>
        : TAccountGuardCollateralTokenAccount,
      TAccountCollateralTokenProgram extends string
        ? ReadonlyAccount<TAccountCollateralTokenProgram>
        : TAccountCollateralTokenProgram,
      ...TRemainingAccounts,
    ]
  >;

export type ClaimTokensInstructionData = { discriminator: ReadonlyUint8Array };

export type ClaimTokensInstructionDataArgs = {};

export function getClaimTokensInstructionDataEncoder(): Encoder<ClaimTokensInstructionDataArgs> {
  return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({
    ...value,
    discriminator: CLAIM_TOKENS_DISCRIMINATOR,
  }));
}

export function getClaimTokensInstructionDataDecoder(): Decoder<ClaimTokensInstructionData> {
  return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
}

export function getClaimTokensInstructionDataCodec(): Codec<
  ClaimTokensInstructionDataArgs,
  ClaimTokensInstructionData
> {
  return combineCodec(getClaimTokensInstructionDataEncoder(), getClaimTokensInstructionDataDecoder());
}

export type ClaimTokensInput<
  TAccountSolver extends string = string,
  TAccountOrder extends string = string,
  TAccountUser extends string = string,
  TAccountGuard extends string = string,
  TAccountIxSysvar extends string = string,
  TAccountRecoveredTokenMint extends string = string,
  TAccountSolverRecoveredTokenAccount extends string = string,
  TAccountGuardRecoveredTokenAccount extends string = string,
  TAccountRecoveredTokenProgram extends string = string,
  TAccountCollateralTokenMint extends string = string,
  TAccountSolverCollateralTokenAccount extends string = string,
  TAccountUserCollateralTokenAccount extends string = string,
  TAccountGuardCollateralTokenAccount extends string = string,
  TAccountCollateralTokenProgram extends string = string,
> = {
  /** Solver that has successfully executed the order and claims tokens */
  solver: TransactionSigner<TAccountSolver>;
  /** Order data */
  order: Address<TAccountOrder>;
  /** User account that will receive lamports after closing Order account */
  user: Address<TAccountUser>;
  /** Guard address, that protects this order execution */
  guard: Address<TAccountGuard>;
  /**
   * the supplied Sysvar could be anything else.
   * The Instruction Sysvar has not been implemented
   * in the Anchor framework yet, so this is the safe approach.
   */
  ixSysvar?: Address<TAccountIxSysvar>;
  /** Recovered token mint */
  recoveredTokenMint: Address<TAccountRecoveredTokenMint>;
  /**
   * Solver token account to which tokens IN or stablecoins will be sent.
   * - Must be either Token IN account or stablecoin account
   * - Must be same token as Guard token account
   */
  solverRecoveredTokenAccount: Address<TAccountSolverRecoveredTokenAccount>;
  /**
   * Guard token account from which tokens IN or stablecoins will be sent to the solver
   * - Must be either Token IN account or stablecoin account
   * - Must be same token as Guard token account
   */
  guardRecoveredTokenAccount: Address<TAccountGuardRecoveredTokenAccount>;
  /** Recovered token program */
  recoveredTokenProgram: Address<TAccountRecoveredTokenProgram>;
  /** Recovered token mint */
  collateralTokenMint: Address<TAccountCollateralTokenMint>;
  /** Solver collateral token account to which locked collateral will be sent. */
  solverCollateralTokenAccount: Address<TAccountSolverCollateralTokenAccount>;
  /** User collateral token account to which taken collateral will be sent. */
  userCollateralTokenAccount?: Address<TAccountUserCollateralTokenAccount>;
  /** Guard collateral token account from which locked and taken collateral will be sent. */
  guardCollateralTokenAccount: Address<TAccountGuardCollateralTokenAccount>;
  /** Solana token program */
  collateralTokenProgram: Address<TAccountCollateralTokenProgram>;
};

export function getClaimTokensInstruction<
  TAccountSolver extends string,
  TAccountOrder extends string,
  TAccountUser extends string,
  TAccountGuard extends string,
  TAccountIxSysvar extends string,
  TAccountRecoveredTokenMint extends string,
  TAccountSolverRecoveredTokenAccount extends string,
  TAccountGuardRecoveredTokenAccount extends string,
  TAccountRecoveredTokenProgram extends string,
  TAccountCollateralTokenMint extends string,
  TAccountSolverCollateralTokenAccount extends string,
  TAccountUserCollateralTokenAccount extends string,
  TAccountGuardCollateralTokenAccount extends string,
  TAccountCollateralTokenProgram extends string,
  TProgramAddress extends Address = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
>(
  input: ClaimTokensInput<
    TAccountSolver,
    TAccountOrder,
    TAccountUser,
    TAccountGuard,
    TAccountIxSysvar,
    TAccountRecoveredTokenMint,
    TAccountSolverRecoveredTokenAccount,
    TAccountGuardRecoveredTokenAccount,
    TAccountRecoveredTokenProgram,
    TAccountCollateralTokenMint,
    TAccountSolverCollateralTokenAccount,
    TAccountUserCollateralTokenAccount,
    TAccountGuardCollateralTokenAccount,
    TAccountCollateralTokenProgram
  >,
  config?: { programAddress?: TProgramAddress },
): ClaimTokensInstruction<
  TProgramAddress,
  TAccountSolver,
  TAccountOrder,
  TAccountUser,
  TAccountGuard,
  TAccountIxSysvar,
  TAccountRecoveredTokenMint,
  TAccountSolverRecoveredTokenAccount,
  TAccountGuardRecoveredTokenAccount,
  TAccountRecoveredTokenProgram,
  TAccountCollateralTokenMint,
  TAccountSolverCollateralTokenAccount,
  TAccountUserCollateralTokenAccount,
  TAccountGuardCollateralTokenAccount,
  TAccountCollateralTokenProgram
> {
  // Program address.
  const programAddress = config?.programAddress ?? SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS;

  // Original accounts.
  const originalAccounts = {
    solver: { value: input.solver ?? null, isWritable: true },
    order: { value: input.order ?? null, isWritable: true },
    user: { value: input.user ?? null, isWritable: true },
    guard: { value: input.guard ?? null, isWritable: false },
    ixSysvar: { value: input.ixSysvar ?? null, isWritable: false },
    recoveredTokenMint: {
      value: input.recoveredTokenMint ?? null,
      isWritable: false,
    },
    solverRecoveredTokenAccount: {
      value: input.solverRecoveredTokenAccount ?? null,
      isWritable: true,
    },
    guardRecoveredTokenAccount: {
      value: input.guardRecoveredTokenAccount ?? null,
      isWritable: true,
    },
    recoveredTokenProgram: {
      value: input.recoveredTokenProgram ?? null,
      isWritable: false,
    },
    collateralTokenMint: {
      value: input.collateralTokenMint ?? null,
      isWritable: false,
    },
    solverCollateralTokenAccount: {
      value: input.solverCollateralTokenAccount ?? null,
      isWritable: true,
    },
    userCollateralTokenAccount: {
      value: input.userCollateralTokenAccount ?? null,
      isWritable: true,
    },
    guardCollateralTokenAccount: {
      value: input.guardCollateralTokenAccount ?? null,
      isWritable: true,
    },
    collateralTokenProgram: {
      value: input.collateralTokenProgram ?? null,
      isWritable: false,
    },
  };
  const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedAccount>;

  // Resolve default values.
  if (!accounts.ixSysvar.value) {
    accounts.ixSysvar.value =
      'Sysvar1nstructions1111111111111111111111111' as Address<'Sysvar1nstructions1111111111111111111111111'>;
  }

  const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
  const instruction = {
    accounts: [
      getAccountMeta(accounts.solver),
      getAccountMeta(accounts.order),
      getAccountMeta(accounts.user),
      getAccountMeta(accounts.guard),
      getAccountMeta(accounts.ixSysvar),
      getAccountMeta(accounts.recoveredTokenMint),
      getAccountMeta(accounts.solverRecoveredTokenAccount),
      getAccountMeta(accounts.guardRecoveredTokenAccount),
      getAccountMeta(accounts.recoveredTokenProgram),
      getAccountMeta(accounts.collateralTokenMint),
      getAccountMeta(accounts.solverCollateralTokenAccount),
      getAccountMeta(accounts.userCollateralTokenAccount),
      getAccountMeta(accounts.guardCollateralTokenAccount),
      getAccountMeta(accounts.collateralTokenProgram),
    ],
    programAddress,
    data: getClaimTokensInstructionDataEncoder().encode({}),
  } as ClaimTokensInstruction<
    TProgramAddress,
    TAccountSolver,
    TAccountOrder,
    TAccountUser,
    TAccountGuard,
    TAccountIxSysvar,
    TAccountRecoveredTokenMint,
    TAccountSolverRecoveredTokenAccount,
    TAccountGuardRecoveredTokenAccount,
    TAccountRecoveredTokenProgram,
    TAccountCollateralTokenMint,
    TAccountSolverCollateralTokenAccount,
    TAccountUserCollateralTokenAccount,
    TAccountGuardCollateralTokenAccount,
    TAccountCollateralTokenProgram
  >;

  return instruction;
}

export type ParsedClaimTokensInstruction<
  TProgram extends string = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
  TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
> = {
  programAddress: Address<TProgram>;
  accounts: {
    /** Solver that has successfully executed the order and claims tokens */
    solver: TAccountMetas[0];
    /** Order data */
    order: TAccountMetas[1];
    /** User account that will receive lamports after closing Order account */
    user: TAccountMetas[2];
    /** Guard address, that protects this order execution */
    guard: TAccountMetas[3];
    /**
     * the supplied Sysvar could be anything else.
     * The Instruction Sysvar has not been implemented
     * in the Anchor framework yet, so this is the safe approach.
     */

    ixSysvar: TAccountMetas[4];
    /** Recovered token mint */
    recoveredTokenMint: TAccountMetas[5];
    /**
     * Solver token account to which tokens IN or stablecoins will be sent.
     * - Must be either Token IN account or stablecoin account
     * - Must be same token as Guard token account
     */

    solverRecoveredTokenAccount: TAccountMetas[6];
    /**
     * Guard token account from which tokens IN or stablecoins will be sent to the solver
     * - Must be either Token IN account or stablecoin account
     * - Must be same token as Guard token account
     */

    guardRecoveredTokenAccount: TAccountMetas[7];
    /** Recovered token program */
    recoveredTokenProgram: TAccountMetas[8];
    /** Recovered token mint */
    collateralTokenMint: TAccountMetas[9];
    /** Solver collateral token account to which locked collateral will be sent. */
    solverCollateralTokenAccount: TAccountMetas[10];
    /** User collateral token account to which taken collateral will be sent. */
    userCollateralTokenAccount?: TAccountMetas[11] | undefined;
    /** Guard collateral token account from which locked and taken collateral will be sent. */
    guardCollateralTokenAccount: TAccountMetas[12];
    /** Solana token program */
    collateralTokenProgram: TAccountMetas[13];
  };
  data: ClaimTokensInstructionData;
};

export function parseClaimTokensInstruction<TProgram extends string, TAccountMetas extends readonly IAccountMeta[]>(
  instruction: IInstruction<TProgram> & IInstructionWithAccounts<TAccountMetas> & IInstructionWithData<Uint8Array>,
): ParsedClaimTokensInstruction<TProgram, TAccountMetas> {
  if (instruction.accounts.length < 14) {
    // TODO: Coded error.
    throw new Error('Not enough accounts');
  }
  let accountIndex = 0;
  const getNextAccount = () => {
    const accountMeta = instruction.accounts![accountIndex]!;
    accountIndex += 1;
    return accountMeta;
  };
  const getNextOptionalAccount = () => {
    const accountMeta = getNextAccount();
    return accountMeta.address === SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS ? undefined : accountMeta;
  };
  return {
    programAddress: instruction.programAddress,
    accounts: {
      solver: getNextAccount(),
      order: getNextAccount(),
      user: getNextAccount(),
      guard: getNextAccount(),
      ixSysvar: getNextAccount(),
      recoveredTokenMint: getNextAccount(),
      solverRecoveredTokenAccount: getNextAccount(),
      guardRecoveredTokenAccount: getNextAccount(),
      recoveredTokenProgram: getNextAccount(),
      collateralTokenMint: getNextAccount(),
      solverCollateralTokenAccount: getNextAccount(),
      userCollateralTokenAccount: getNextOptionalAccount(),
      guardCollateralTokenAccount: getNextAccount(),
      collateralTokenProgram: getNextAccount(),
    },
    data: getClaimTokensInstructionDataDecoder().decode(instruction.data),
  };
}