@robertprp/intents-sdk/src/core/solana/generated/cross-chain/instructions/cancelOrder.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 CANCEL_ORDER_DISCRIMINATOR = new Uint8Array([95, 129, 237, 240, 8, 49, 223, 132]);

export function getCancelOrderDiscriminatorBytes() {
  return fixEncoderSize(getBytesEncoder(), 8).encode(CANCEL_ORDER_DISCRIMINATOR);
}

export type CancelOrderInstruction<
  TProgram extends string = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
  TAccountUser extends string | IAccountMeta<string> = string,
  TAccountOrder extends string | IAccountMeta<string> = string,
  TAccountGuard extends string | IAccountMeta<string> = string,
  TAccountRecoveredTokenMint extends string | IAccountMeta<string> = string,
  TAccountUserRecoveredTokenAccount extends string | IAccountMeta<string> = string,
  TAccountGuardRecoveredTokenAccount extends string | IAccountMeta<string> = string,
  TAccountRecoveredTokenProgram extends string | IAccountMeta<string> = string,
  TAccountCollateralTokenMint 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<
    [
      TAccountUser extends string
        ? WritableSignerAccount<TAccountUser> & IAccountSignerMeta<TAccountUser>
        : TAccountUser,
      TAccountOrder extends string ? WritableAccount<TAccountOrder> : TAccountOrder,
      TAccountGuard extends string ? ReadonlyAccount<TAccountGuard> : TAccountGuard,
      TAccountRecoveredTokenMint extends string
        ? ReadonlyAccount<TAccountRecoveredTokenMint>
        : TAccountRecoveredTokenMint,
      TAccountUserRecoveredTokenAccount extends string
        ? WritableAccount<TAccountUserRecoveredTokenAccount>
        : TAccountUserRecoveredTokenAccount,
      TAccountGuardRecoveredTokenAccount extends string
        ? WritableAccount<TAccountGuardRecoveredTokenAccount>
        : TAccountGuardRecoveredTokenAccount,
      TAccountRecoveredTokenProgram extends string
        ? ReadonlyAccount<TAccountRecoveredTokenProgram>
        : TAccountRecoveredTokenProgram,
      TAccountCollateralTokenMint extends string
        ? ReadonlyAccount<TAccountCollateralTokenMint>
        : TAccountCollateralTokenMint,
      TAccountUserCollateralTokenAccount extends string
        ? WritableAccount<TAccountUserCollateralTokenAccount>
        : TAccountUserCollateralTokenAccount,
      TAccountGuardCollateralTokenAccount extends string
        ? WritableAccount<TAccountGuardCollateralTokenAccount>
        : TAccountGuardCollateralTokenAccount,
      TAccountCollateralTokenProgram extends string
        ? ReadonlyAccount<TAccountCollateralTokenProgram>
        : TAccountCollateralTokenProgram,
      ...TRemainingAccounts,
    ]
  >;

export type CancelOrderInstructionData = { discriminator: ReadonlyUint8Array };

export type CancelOrderInstructionDataArgs = {};

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

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

export function getCancelOrderInstructionDataCodec(): Codec<
  CancelOrderInstructionDataArgs,
  CancelOrderInstructionData
> {
  return combineCodec(getCancelOrderInstructionDataEncoder(), getCancelOrderInstructionDataDecoder());
}

export type CancelOrderInput<
  TAccountUser extends string = string,
  TAccountOrder extends string = string,
  TAccountGuard extends string = string,
  TAccountRecoveredTokenMint extends string = string,
  TAccountUserRecoveredTokenAccount extends string = string,
  TAccountGuardRecoveredTokenAccount extends string = string,
  TAccountRecoveredTokenProgram extends string = string,
  TAccountCollateralTokenMint extends string = string,
  TAccountUserCollateralTokenAccount extends string = string,
  TAccountGuardCollateralTokenAccount extends string = string,
  TAccountCollateralTokenProgram extends string = string,
> = {
  /** User that is order creator which wants to cancel the order */
  user: TransactionSigner<TAccountUser>;
  /** Order data */
  order: Address<TAccountOrder>;
  /** Guard address, that protects this order execution */
  guard: Address<TAccountGuard>;
  /** Recovered token mint */
  recoveredTokenMint: Address<TAccountRecoveredTokenMint>;
  /**
   * User 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
   */
  userRecoveredTokenAccount: Address<TAccountUserRecoveredTokenAccount>;
  /**
   * Guard token account from which tokens IN or stablecoins will be sent to the user
   * - 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>;
  /** User collateral token account to which taken collateral (if any) will be sent. */
  userCollateralTokenAccount?: Address<TAccountUserCollateralTokenAccount>;
  /** Guard collateral token account to which taken collateral (if any) will be sent. */
  guardCollateralTokenAccount: Address<TAccountGuardCollateralTokenAccount>;
  /** Solana token program */
  collateralTokenProgram: Address<TAccountCollateralTokenProgram>;
};

export function getCancelOrderInstruction<
  TAccountUser extends string,
  TAccountOrder extends string,
  TAccountGuard extends string,
  TAccountRecoveredTokenMint extends string,
  TAccountUserRecoveredTokenAccount extends string,
  TAccountGuardRecoveredTokenAccount extends string,
  TAccountRecoveredTokenProgram extends string,
  TAccountCollateralTokenMint extends string,
  TAccountUserCollateralTokenAccount extends string,
  TAccountGuardCollateralTokenAccount extends string,
  TAccountCollateralTokenProgram extends string,
  TProgramAddress extends Address = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
>(
  input: CancelOrderInput<
    TAccountUser,
    TAccountOrder,
    TAccountGuard,
    TAccountRecoveredTokenMint,
    TAccountUserRecoveredTokenAccount,
    TAccountGuardRecoveredTokenAccount,
    TAccountRecoveredTokenProgram,
    TAccountCollateralTokenMint,
    TAccountUserCollateralTokenAccount,
    TAccountGuardCollateralTokenAccount,
    TAccountCollateralTokenProgram
  >,
  config?: { programAddress?: TProgramAddress },
): CancelOrderInstruction<
  TProgramAddress,
  TAccountUser,
  TAccountOrder,
  TAccountGuard,
  TAccountRecoveredTokenMint,
  TAccountUserRecoveredTokenAccount,
  TAccountGuardRecoveredTokenAccount,
  TAccountRecoveredTokenProgram,
  TAccountCollateralTokenMint,
  TAccountUserCollateralTokenAccount,
  TAccountGuardCollateralTokenAccount,
  TAccountCollateralTokenProgram
> {
  // Program address.
  const programAddress = config?.programAddress ?? SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS;

  // Original accounts.
  const originalAccounts = {
    user: { value: input.user ?? null, isWritable: true },
    order: { value: input.order ?? null, isWritable: true },
    guard: { value: input.guard ?? null, isWritable: false },
    recoveredTokenMint: {
      value: input.recoveredTokenMint ?? null,
      isWritable: false,
    },
    userRecoveredTokenAccount: {
      value: input.userRecoveredTokenAccount ?? null,
      isWritable: true,
    },
    guardRecoveredTokenAccount: {
      value: input.guardRecoveredTokenAccount ?? null,
      isWritable: true,
    },
    recoveredTokenProgram: {
      value: input.recoveredTokenProgram ?? null,
      isWritable: false,
    },
    collateralTokenMint: {
      value: input.collateralTokenMint ?? null,
      isWritable: false,
    },
    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>;

  const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
  const instruction = {
    accounts: [
      getAccountMeta(accounts.user),
      getAccountMeta(accounts.order),
      getAccountMeta(accounts.guard),
      getAccountMeta(accounts.recoveredTokenMint),
      getAccountMeta(accounts.userRecoveredTokenAccount),
      getAccountMeta(accounts.guardRecoveredTokenAccount),
      getAccountMeta(accounts.recoveredTokenProgram),
      getAccountMeta(accounts.collateralTokenMint),
      getAccountMeta(accounts.userCollateralTokenAccount),
      getAccountMeta(accounts.guardCollateralTokenAccount),
      getAccountMeta(accounts.collateralTokenProgram),
    ],
    programAddress,
    data: getCancelOrderInstructionDataEncoder().encode({}),
  } as CancelOrderInstruction<
    TProgramAddress,
    TAccountUser,
    TAccountOrder,
    TAccountGuard,
    TAccountRecoveredTokenMint,
    TAccountUserRecoveredTokenAccount,
    TAccountGuardRecoveredTokenAccount,
    TAccountRecoveredTokenProgram,
    TAccountCollateralTokenMint,
    TAccountUserCollateralTokenAccount,
    TAccountGuardCollateralTokenAccount,
    TAccountCollateralTokenProgram
  >;

  return instruction;
}

export type ParsedCancelOrderInstruction<
  TProgram extends string = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
  TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
> = {
  programAddress: Address<TProgram>;
  accounts: {
    /** User that is order creator which wants to cancel the order */
    user: TAccountMetas[0];
    /** Order data */
    order: TAccountMetas[1];
    /** Guard address, that protects this order execution */
    guard: TAccountMetas[2];
    /** Recovered token mint */
    recoveredTokenMint: TAccountMetas[3];
    /**
     * User 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
     */

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

    guardRecoveredTokenAccount: TAccountMetas[5];
    /** Recovered token program */
    recoveredTokenProgram: TAccountMetas[6];
    /** Recovered token mint */
    collateralTokenMint: TAccountMetas[7];
    /** User collateral token account to which taken collateral (if any) will be sent. */
    userCollateralTokenAccount?: TAccountMetas[8] | undefined;
    /** Guard collateral token account to which taken collateral (if any) will be sent. */
    guardCollateralTokenAccount: TAccountMetas[9];
    /** Solana token program */
    collateralTokenProgram: TAccountMetas[10];
  };
  data: CancelOrderInstructionData;
};

export function parseCancelOrderInstruction<TProgram extends string, TAccountMetas extends readonly IAccountMeta[]>(
  instruction: IInstruction<TProgram> & IInstructionWithAccounts<TAccountMetas> & IInstructionWithData<Uint8Array>,
): ParsedCancelOrderInstruction<TProgram, TAccountMetas> {
  if (instruction.accounts.length < 11) {
    // 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: {
      user: getNextAccount(),
      order: getNextAccount(),
      guard: getNextAccount(),
      recoveredTokenMint: getNextAccount(),
      userRecoveredTokenAccount: getNextAccount(),
      guardRecoveredTokenAccount: getNextAccount(),
      recoveredTokenProgram: getNextAccount(),
      collateralTokenMint: getNextAccount(),
      userCollateralTokenAccount: getNextOptionalAccount(),
      guardCollateralTokenAccount: getNextAccount(),
      collateralTokenProgram: getNextAccount(),
    },
    data: getCancelOrderInstructionDataDecoder().decode(instruction.data),
  };
}