@robertprp/intents-sdk/src/core/solana/dca/cancel-order.ts

Shogun Network Intent-based cross-chain swaps SDK

import {
  address,
  createNoopSigner,
  createSolanaRpc,
  fetchEncodedAccount,
  getAddressEncoder,
  getProgramDerivedAddress,
  type Address,
  type IInstruction,
} from '@solana/kit';
import { getDefaultSolanaRPC } from '../client.js';
import { fetchMaybeDcaOrder, getCancelDcaOrderInstruction } from '../generated/single-chain/index.js';
import {
  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
  fetchMint,
  getCreateAssociatedTokenInstructionAsync,
} from '@solana-program/token';
import { SINGLE_CHAIN_GUARD_ADDRESSES } from '../../../constants.js';
import { ChainID } from '../../../chains.js';

export async function cancelDcaSingleChainOrderInstructions(
  orderAddress: string,
  options?: { rpcUrl?: string },
): Promise<IInstruction[]> {
  const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();

  const orderId = address(orderAddress);
  const chainOrder = await fetchMaybeDcaOrder(rpc, orderId);

  if (!chainOrder.exists) {
    throw new Error(`Order with address ${orderAddress} not found`);
  }

  const instructions: IInstruction[] = [];
  const orderUserAddress = chainOrder.data.user;

  const tokenInMint = chainOrder.data.tokenInMint;

  const tokenMintProgram = await fetchMint(rpc, tokenInMint);

  const addressEncoder = getAddressEncoder();

  const [tokenInProgramAccount] = await getProgramDerivedAddress({
    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
    seeds: [
      addressEncoder.encode(orderUserAddress),
      addressEncoder.encode(tokenMintProgram.programAddress),
      addressEncoder.encode(tokenInMint),
    ],
  });

  const guardAddress = SINGLE_CHAIN_GUARD_ADDRESSES[ChainID.Solana] as Address;
  const [guardProgramAccount] = await getProgramDerivedAddress({
    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
    seeds: [
      // Owner
      addressEncoder.encode(guardAddress),
      // Token program
      addressEncoder.encode(tokenMintProgram.programAddress),
      // mint address
      addressEncoder.encode(tokenInMint),
    ],
  });

  const userTokenInAccount = await fetchEncodedAccount(rpc, tokenInProgramAccount);

  if (!userTokenInAccount.exists) {
    const createTokenIx = await getCreateAssociatedTokenInstructionAsync({
      mint: tokenInMint,
      owner: orderUserAddress,
      payer: createNoopSigner(orderUserAddress),
      tokenProgram: tokenMintProgram.programAddress,
    });

    instructions.push(createTokenIx);
  }

  const cancelLimitOrderIx = getCancelDcaOrderInstruction({
    user: createNoopSigner(orderUserAddress),
    order: orderId,
    guard: guardAddress,
    tokenInMint: chainOrder.data.tokenInMint,
    userTokenInAccount: userTokenInAccount.address,
    guardTokenInAccount: guardProgramAccount,
    tokenInProgram: tokenMintProgram.programAddress,
  });

  instructions.push(cancelLimitOrderIx);

  return instructions;
}