@shogun-sdk/intents-sdk 1.1.0 → 1.2.0

package/src/core/orders/single-chain.ts

@@ -63,8 +63,14 @@ export class SingleChainOrder {
       user: input.user,
     });
 
+    if (isEvmChain(order.chainId)) {
+      return order;
+    }
+
     const preparedRandomData = order.getRandomPreparedData();
     const intentRequest = order.toIntentRequest(preparedRandomData);
+
+    // Just validate for non EVM
     await BaseSDK.validateSingleChainOrder(intentRequest);
 
     return order;

package/src/core/sdk.ts

@@ -1,123 +1,72 @@
 import { AUCTIONEER_URL } from '../constants.js';
 import { NetworkError } from '../errors/index.js';
-import type { ApiResponse, ApiUserOrders } from '../types/api.js';
+import type { ApiResponse } from '../types/api.js';
 import type {
   CrossChainOrderPrepared,
   CrossChainUserIntentRequest,
+  DcaSingleChainOrderPrepared,
+  DcaSingleChainUserIntentRequest,
   SingleChainOrderPrepared,
   SingleChainUserIntentRequest,
 } from '../types/intent.js';
 import { Parsers } from '../utils/parsers.js';
 import { CrossChainOrder, type CreateCrossChainOrderParams } from './orders/cross-chain.js';
+import { DcaSingleChainOrder, type CreateDcaSingleChainOrderParams } from './orders/dca-single-chain.js';
 import { SingleChainOrder, type CreateSingleChainOrderParams } from './orders/single-chain.js';
 
 /**
  * Base SDK providing common functionality for all blockchain implementations
- *
- * This abstract class serves as the foundation for chain-specific SDK implementations
- * (EVM, Solana, Sui), providing shared functionality for creating and sending orders
- * across different blockchains.
  */
 export abstract class BaseSDK {
-  public abstract getOrders(): Promise<ApiUserOrders>;
   public abstract getUserAddress(): Promise<string>;
-  protected abstract prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared>;
-  protected abstract prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared>;
-
-  public async createSingleChainOrder(params: CreateSingleChainOrderParams): Promise<SingleChainOrderPrepared> {
-    const userAddress = await this.getUserAddress();
-
-    const order = await SingleChainOrder.create({
-      ...params,
-      user: userAddress,
-    });
-
-    return this.prepareSingleChainOrder(order);
-  }
-
-  public async createCrossChainOrder(params: CreateCrossChainOrderParams): Promise<CrossChainOrderPrepared> {
-    const userAddress = await this.getUserAddress();
-
-    const order = await CrossChainOrder.create({
-      ...params,
-      user: userAddress,
-    });
-
-    return this.prepareCrossChainOrder(order);
-  }
-
-  public async createAndSendSingleChainOrder(params: CreateSingleChainOrderParams): Promise<ApiResponse> {
-    const preparedOrder = await this.createSingleChainOrder(params);
-    return BaseSDK.sendSingleChainOrder(preparedOrder);
-  }
 
-  public static async sendSingleChainOrder(preparedOrder: SingleChainOrderPrepared): Promise<ApiResponse> {
-    const intentRequest = preparedOrder.order.toIntentRequest(preparedOrder.preparedData);
-    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+  protected abstract prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared>;
+  protected prepareSingleChainOrder?(order: SingleChainOrder): Promise<SingleChainOrderPrepared>;
+  protected prepareDcaSingleChainOrder?(order: DcaSingleChainOrder): Promise<DcaSingleChainOrderPrepared>;
 
-    const url = `${AUCTIONEER_URL}/user_intent/single_chain/limit_order`;
+  // Generic HTTP request handler
+  private static async makeRequest(url: string, body: string): Promise<ApiResponse> {
     const response = await fetch(url, {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
+      headers: { 'Content-Type': 'application/json' },
       body,
     });
 
     if (!response.ok) {
       const errorJson: ApiResponse = await response.json();
-
+      const mainError = errorJson.error;
       const extraErrorData = errorJson.extra_error_data;
-      throw new NetworkError(`Server error ${extraErrorData}`);
+
+      const errorMessage = mainError
+        ? `${mainError}. Extra error data: ${extraErrorData}`
+        : `Server error ${extraErrorData}`;
+
+      throw new NetworkError(errorMessage);
     }
 
     return response.json();
   }
 
-  public static async validateCrossChainOrder(intentRequest: CrossChainUserIntentRequest): Promise<void> {
+  private static async validateOrder<T>(intentRequest: T, endpoint: string): Promise<void> {
     const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
-
-    const url = `${AUCTIONEER_URL}/validate_intent/cross_chain/limit_order`;
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body,
-    });
-
-    if (!response.ok) {
-      const errorJson: ApiResponse = await response.json();
-
-      const mainError = errorJson.error;
-      const extraErrorData = errorJson.extra_error_data;
-      throw new NetworkError(`Validation error: ${mainError}. Extra error data: ${extraErrorData}`);
-    }
-
-    return;
+    const url = `${AUCTIONEER_URL}${endpoint}`;
+    await BaseSDK.makeRequest(url, body);
   }
 
-  public static async validateSingleChainOrder(intentRequest: SingleChainUserIntentRequest): Promise<void> {
+  private static async sendOrder<T extends { toIntentRequest(preparedData: any): any }>(
+    preparedOrder: { order: T; preparedData: any },
+    endpoint: string,
+  ): Promise<ApiResponse> {
+    const intentRequest = preparedOrder.order.toIntentRequest(preparedOrder.preparedData);
     const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+    const url = `${AUCTIONEER_URL}${endpoint}`;
+    return BaseSDK.makeRequest(url, body);
+  }
 
-    const url = `${AUCTIONEER_URL}/validate_intent/single_chain/limit_order`;
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body,
-    });
-
-    if (!response.ok) {
-      const errorJson: ApiResponse = await response.json();
-
-      const mainError = errorJson.error;
-      const extraErrorData = errorJson.extra_error_data;
-      throw new NetworkError(`Validation error: ${mainError}. Extra error data: ${extraErrorData}`);
-    }
-
-    return;
+  public async createCrossChainOrder(params: CreateCrossChainOrderParams): Promise<CrossChainOrderPrepared> {
+    const userAddress = await this.getUserAddress();
+    const order = await CrossChainOrder.create({ ...params, user: userAddress });
+    return this.prepareCrossChainOrder!(order);
   }
 
   public async createAndSendCrossChainOrder(params: CreateCrossChainOrderParams): Promise<ApiResponse> {
@@ -126,28 +75,50 @@ export abstract class BaseSDK {
   }
 
   public static async sendCrossChainOrder(preparedOrder: CrossChainOrderPrepared): Promise<ApiResponse> {
-    const intentRequest = preparedOrder.order.toIntentRequest(preparedOrder.preparedData);
-    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+    return BaseSDK.sendOrder(preparedOrder, '/user_intent/cross_chain/limit_order');
+  }
 
-    const url = `${AUCTIONEER_URL}/user_intent/cross_chain/limit_order`;
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body,
-    });
+  public static async validateCrossChainOrder(intentRequest: CrossChainUserIntentRequest): Promise<void> {
+    return BaseSDK.validateOrder(intentRequest, '/validate_intent/cross_chain/limit_order');
+  }
 
-    if (!response.ok) {
-      const errorJson: ApiResponse = await response.json();
+  public async createSingleChainOrder(params: CreateSingleChainOrderParams): Promise<SingleChainOrderPrepared> {
+    const userAddress = await this.getUserAddress();
+    const order = await SingleChainOrder.create({ ...params, user: userAddress });
+    return this.prepareSingleChainOrder!(order);
+  }
 
-      const mainError = errorJson.error;
-      const extraErrorData = errorJson.extra_error_data;
-      throw new NetworkError(
-        `Failed to send cross-chain order. Main error: ${mainError}. Extra error data: ${extraErrorData}`,
-      );
-    }
+  public async createAndSendSingleChainOrder(params: CreateSingleChainOrderParams): Promise<ApiResponse> {
+    const preparedOrder = await this.createSingleChainOrder(params);
+    return BaseSDK.sendSingleChainOrder(preparedOrder);
+  }
 
-    return response.json();
+  public static async sendSingleChainOrder(preparedOrder: SingleChainOrderPrepared): Promise<ApiResponse> {
+    return BaseSDK.sendOrder(preparedOrder, '/user_intent/single_chain/limit_order');
+  }
+
+  public static async validateSingleChainOrder(intentRequest: SingleChainUserIntentRequest): Promise<void> {
+    return BaseSDK.validateOrder(intentRequest, '/validate_intent/single_chain/limit_order');
+  }
+
+  public async createDcaSingleChainOrder(
+    params: CreateDcaSingleChainOrderParams,
+  ): Promise<DcaSingleChainOrderPrepared> {
+    const userAddress = await this.getUserAddress();
+    const order = await DcaSingleChainOrder.create({ ...params, user: userAddress });
+    return this.prepareDcaSingleChainOrder!(order);
+  }
+
+  public async createAndSendDcaSingleChainOrder(params: CreateDcaSingleChainOrderParams): Promise<ApiResponse> {
+    const preparedOrder = await this.createDcaSingleChainOrder(params);
+    return BaseSDK.sendDcaSingleChainOrder(preparedOrder);
+  }
+
+  public static async sendDcaSingleChainOrder(preparedOrder: DcaSingleChainOrderPrepared): Promise<ApiResponse> {
+    return BaseSDK.sendOrder(preparedOrder, '/user_intent/single_chain/dca_order');
+  }
+
+  public static async validateDcaSingleChainOrder(intentRequest: DcaSingleChainUserIntentRequest): Promise<void> {
+    return BaseSDK.validateOrder(intentRequest, '/validate_intent/single_chain/dca_order');
   }
 }

package/src/core/solana/cancel-order.ts

@@ -164,7 +164,7 @@ export async function cancelCrossChainOrderInstructions(
   const addressEncoder = getAddressEncoder();
 
   const isRecoveringTokenIn = chainOrder.data.lockedStablecoins === 0n;
-  const recoverTokenMint = isRecoveringTokenIn ? chainOrder.data.tokenInMint : address(SOLANA_MINT_TOKEN.mint); 
+  const recoverTokenMint = isRecoveringTokenIn ? chainOrder.data.tokenInMint : address(SOLANA_MINT_TOKEN.mint);
 
   const recoverTokenMintProgram = await fetchMint(rpc, recoverTokenMint);
 

package/src/core/solana/dca/cancel-order.ts

@@ -0,0 +1,91 @@
+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;
+}

package/src/core/solana/dca/create-order.ts

@@ -0,0 +1,142 @@
+import {
+  address,
+  addSignersToTransactionMessage,
+  appendTransactionMessageInstructions,
+  createNoopSigner,
+  createSolanaRpc,
+  createTransactionMessage,
+  fetchEncodedAccount,
+  generateKeyPairSigner,
+  getAddressEncoder,
+  getProgramDerivedAddress,
+  getTransactionCodec,
+  partiallySignTransactionMessageWithSigners,
+  pipe,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash,
+  type Address,
+  type IInstruction,
+} from '@solana/kit';
+import type { DcaSingleChainOrder } from '../../orders/dca-single-chain.js';
+import type { SolanaOrderInstructionResult } from '../order-instructions.js';
+import { getDefaultSolanaRPC } from '../client.js';
+import { genSecretHashAndNumber } from '../utils.js';
+import {
+  NATIVE_SOLANA_TOKEN_ADDRESS,
+  SINGLE_CHAIN_GUARD_ADDRESSES,
+  WRAPPED_SOL_MINT_ADDRESS,
+} from '../../../constants.js';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  fetchMint,
+  getCreateAssociatedTokenInstructionAsync,
+  getSyncNativeInstruction,
+} from '@solana-program/token';
+import { ChainID } from '../../../chains.js';
+import { getTransferSolInstruction } from '@solana-program/system';
+import { getCreateDcaOrderInstructionAsync } from '../generated/single-chain/index.js';
+
+export async function getSolanaDcaSingleChainOrderInstructions(
+  order: DcaSingleChainOrder,
+  options?: { rpcUrl?: string },
+): Promise<SolanaOrderInstructionResult & { secretNumber: string }> {
+  const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderSigner = await generateKeyPairSigner();
+  const signer = createNoopSigner(order.user as Address);
+
+  let tokenInMint = address(order.tokenIn);
+
+  const { secretHash, secretNumber } = genSecretHashAndNumber(order);
+
+  const orderUserAddress = address(order.user);
+  const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
+
+  if (spendingNative) {
+    tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
+  }
+
+  const tokenMintProgram = await fetchMint(rpc, tokenInMint);
+
+  const guardAddress = address(SINGLE_CHAIN_GUARD_ADDRESSES[ChainID.Solana]); // Assuming DCA uses same guard
+  const addressEncoder = getAddressEncoder();
+  const instructions: Array<IInstruction> = [];
+
+  const [tokenInProgramAccount] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      addressEncoder.encode(orderUserAddress),
+      addressEncoder.encode(tokenMintProgram.programAddress),
+      addressEncoder.encode(tokenInMint),
+    ],
+  });
+
+  const userTokenInAccount = await fetchEncodedAccount(rpc, tokenInProgramAccount);
+
+  if (!userTokenInAccount.exists) {
+    const createAccountIx = await getCreateAssociatedTokenInstructionAsync({
+      payer: signer,
+      ata: tokenInProgramAccount,
+      owner: orderUserAddress,
+      mint: tokenMintProgram.address,
+      tokenProgram: tokenMintProgram.programAddress,
+    });
+
+    instructions.push(createAccountIx);
+  }
+
+  const totalAmountIn = BigInt(order.amountInPerInterval) * BigInt(order.totalIntervals);
+
+  if (spendingNative) {
+    const transferIx = getTransferSolInstruction({
+      amount: totalAmountIn,
+      destination: userTokenInAccount.address,
+      source: signer,
+    });
+
+    instructions.push(transferIx);
+
+    const syncNativeIx = getSyncNativeInstruction({
+      account: userTokenInAccount.address,
+    });
+
+    instructions.push(syncNativeIx);
+  }
+
+  const createDcaOrderIx = await getCreateDcaOrderInstructionAsync({
+    user: signer,
+    order: orderSigner,
+    guard: guardAddress,
+    tokenInMint: tokenInMint,
+    userTokenInAccount: userTokenInAccount.address,
+    tokenInProgram: tokenMintProgram.programAddress,
+    amountInPerInterval: order.amountInPerInterval,
+    totalIntervals: order.totalIntervals,
+    intervalDuration: order.intervalDuration,
+    deadline: order.deadline,
+    amountOutMin: order.amountOutMin,
+    secretHash: Uint8Array.from(secretHash),
+    extraTransfersAmounts: [], // TODO: Implement extra transfers
+  });
+
+  instructions.push(createDcaOrderIx);
+
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();
+
+  const txMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    (tx) => appendTransactionMessageInstructions(instructions, tx),
+    (tx) => addSignersToTransactionMessage([orderSigner], tx),
+  );
+
+  const partiallySignedTransaction = await partiallySignTransactionMessageWithSigners(txMessage);
+
+  const txBytes = getTransactionCodec().encode(partiallySignedTransaction);
+
+  return {
+    orderAddress: orderSigner.address,
+    txBytes,
+    secretNumber,
+  };
+}

package/src/core/solana/inspect.ts

@@ -0,0 +1,50 @@
+import { address, createSolanaRpc, type Base58EncodedBytes } from '@solana/kit';
+import { getDefaultSolanaRPC } from './client.js';
+import { logger } from '../../utils/logger.js';
+
+/**
+ * Inspect Solana guards to find orders that are currently locked on-chain.
+ * @param userAddress - The user's Solana address
+ * @param config - The Solana RPC configuration
+ * @returns An object containing the Solana guard programs for cross-chain and single-chain orders
+ */
+export async function getSolanaOrdersWithLockedFunds(userAddress: string, config?: { rpcUrl?: string }) {
+  const rpc = config?.rpcUrl ? createSolanaRpc(config.rpcUrl) : getDefaultSolanaRPC();
+
+  // const singleChainGuardAddress = SINGLE_CHAIN_GUARD_ADDRESSES[ChainID.Solana];
+
+  const programAccountAddress = address('43cctGU9QJ4WEPzLoNEvo3TPiv6nMUG9puN2pXQSnB6V');
+  const programAccountsConfig = {
+    encoding: 'base64',
+    filters: [
+      {
+        memcmp: {
+          offset: 8n,
+          encoding: 'base58',
+          bytes: userAddress as Base58EncodedBytes,
+        },
+      },
+    ],
+  } as Readonly<unknown>;
+
+  logger.info(`Fetching cross-chain guard programs for user: ${userAddress}`);
+  const crossChainGuardPrograms = await rpc.getProgramAccounts(programAccountAddress, programAccountsConfig).send();
+  logger.info(`Found ${crossChainGuardPrograms.length} cross-chain guard programs`);
+  // const singleChainGuardPrograms = await rpc.getProgramAccounts(address(singleChainGuardAddress), programAccountsConfig).send();
+
+  // const crossChainCodec = getOrderCodec();
+  // const singleChainCodec = getLimitOrderCodec();
+  // const base64Encoder = getBase64Encoder();
+
+  const crossChainGuardProgramsWithOrders = crossChainGuardPrograms.map(({ pubkey, account }) => {
+    logger.info(`Account data: ${account} and pubkey: ${pubkey}`);
+
+    return {
+      pubkey,
+    };
+  });
+
+  return {
+    crossChainGuardPrograms: crossChainGuardProgramsWithOrders,
+  };
+}

package/src/core/solana/order-instructions.ts

@@ -262,4 +262,4 @@ export async function getSolanaCrossChainOrderInstructions(
     orderAddress: orderSigner.address,
     txBytes: Uint8Array.from(txBytes),
   };
-}
+}

package/src/core/solana/sdk.ts

@@ -22,14 +22,19 @@ import { BaseSDK } from '../sdk.js';
 import { createSolanaClient, type SolanaClient } from './client.js';
 import { cancelCrossChainOrderInstructions, cancelSingleChainOrderInstructions } from './cancel-order.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
-import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import type {
+  CrossChainOrderPrepared,
+  DcaSingleChainOrderPrepared,
+  SingleChainOrderPrepared,
+} from '../../types/intent.js';
 import { getSolanaCrossChainOrderInstructions, getSolanaSingleChainOrderInstructions } from './order-instructions.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
-import type { ApiUserOrders } from '../../types/api.js';
 import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
 import { ChainID } from '../../chains.js';
 import { bytesToHex } from 'viem';
-import { fetchUserOrders } from '../orders/api/fetch.js';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
+import { getSolanaDcaSingleChainOrderInstructions } from './dca/create-order.js';
+import { cancelDcaSingleChainOrderInstructions } from './dca/cancel-order.js';
 
 /**
  * Solana-specific SDK implementation
@@ -41,7 +46,6 @@ import { fetchUserOrders } from '../orders/api/fetch.js';
 export class SolanaSDK extends BaseSDK {
   /** Configuration for Solana connection and authentication */
   private readonly config: SolanaConfig;
-  private token?: string;
   /** Client for Solana RPC interactions and transaction handling */
   private client: SolanaClient;
 
@@ -70,12 +74,6 @@ export class SolanaSDK extends BaseSDK {
     return signer.address;
   }
 
-  public setToken(token: string) {
-    this.token = token;
-
-    return this;
-  }
-
   public async cancelCrossChainOrder(orderId: string): Promise<string> {
     const instructions = await cancelCrossChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
     const signer = await this.getUserSigner();
@@ -195,16 +193,6 @@ export class SolanaSDK extends BaseSDK {
     return newToken;
   }
 
-  public override async getOrders(): Promise<ApiUserOrders> {
-    if (!this.token) {
-      throw new Error('No token provided');
-    }
-
-    const orders = await fetchUserOrders(this.token);
-
-    return orders;
-  }
-
   /**
    * Prepares a Solana order for submission
    *
@@ -243,7 +231,7 @@ export class SolanaSDK extends BaseSDK {
     };
   }
 
-  protected async prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared> {
+  protected override async prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared> {
     const signerKeyPair = await this.getUserCryptoKeypair();
 
     const { orderAddress, txBytes, secretNumber } = await getSolanaSingleChainOrderInstructions(order);
@@ -256,6 +244,62 @@ export class SolanaSDK extends BaseSDK {
 
     const encodedTransaction = getBase64EncodedWireTransaction(signedTx);
 
+    await this.client.rpc
+      .sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: 'base64' })
+      .send();
+
+    return {
+      order,
+      preparedData: {
+        orderPubkey: orderAddress,
+        secretNumber,
+      },
+    };
+  }
+  public async cancelDcaSingleChainOrder(orderId: string): Promise<string> {
+    const instructions = await cancelDcaSingleChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
+    const signer = await this.getUserSigner();
+    const signerKeyPair = await this.getUserCryptoKeypair();
+
+    const noopSigner = createNoopSigner(signer.address);
+
+    const { value: latestBlockhash } = await this.client.rpc
+      .getLatestBlockhash({ commitment: this.config.commitment })
+      .send();
+
+    const transactionMessage = pipe(
+      createTransactionMessage({ version: 0 }),
+      (tx) => setTransactionMessageFeePayerSigner(noopSigner, tx),
+      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+      (tx) => appendTransactionMessageInstructions(instructions, tx),
+    );
+
+    const myTx = compileTransaction(transactionMessage);
+
+    const signature = await signTransaction([signerKeyPair], myTx);
+
+    await this.client.sendAndConfirmTransaction(signature, {
+      commitment: this.config.commitment,
+    });
+
+    return orderId;
+  }
+
+  protected override async prepareDcaSingleChainOrder(
+    order: DcaSingleChainOrder,
+  ): Promise<DcaSingleChainOrderPrepared> {
+    const signerKeyPair = await this.getUserCryptoKeypair();
+
+    const { orderAddress, txBytes, secretNumber } = await getSolanaDcaSingleChainOrderInstructions(order);
+
+    const transactionCodec = getTransactionCodec();
+
+    const tx = transactionCodec.decode(txBytes);
+
+    const signedTx = await partiallySignTransaction([signerKeyPair], tx);
+
+    const encodedTransaction = getBase64EncodedWireTransaction(signedTx);
+
     await this.client.rpc
       .sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: 'base64' })
       .send();