@shogun-sdk/intents-sdk 1.1.1 → 1.2.1

package/src/core/orders/api/index.ts

@@ -3,15 +3,15 @@ import type { ApiResponse, ApiUserOrders } from '../../../types/api.js';
 
 export class AuctioneerAPI {
   public aggregatedToken: string;
-  
+
   constructor(aggregatedToken: string) {
     this.aggregatedToken = aggregatedToken;
   }
-  
+
   public extend(token: string) {
     this.aggregatedToken = token;
   }
-  
+
   public async getUserOrders() {
     const url = `${AUCTIONEER_URL}/user_intent`;
     const response = await fetch(url, {
@@ -30,4 +30,4 @@ export class AuctioneerAPI {
 
     return data.data!;
   }
-}
+}

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

@@ -112,6 +112,10 @@ export class CrossChainOrder {
       user: input.user,
     });
 
+    if (isEvmChain(order.sourceChainId)) {
+      return order;
+    }
+
     const randomPreparedData = order.getRandomPreparedData();
     const intentRequest = order.toIntentRequest(randomPreparedData);
     await BaseSDK.validateCrossChainOrder(intentRequest);
@@ -244,7 +248,7 @@ export class CrossChainOrder {
    * @returns Object containing source chain-specific data
    */
   public toSourceChainData() {
-    let data: SourceChainData = {
+    const data: SourceChainData = {
       user: this.user,
       srcChainId: this.sourceChainId,
       tokenIn: this.sourceTokenAddress,

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

@@ -0,0 +1,143 @@
+// src/core/orders/dca-single-chain.ts
+import { ChainID, chainIdToChainTypeMap, isEvmChain, type SupportedChain } from '../../chains.js';
+import { ValidationError } from '../../errors/index.js';
+import type { ApiResponse } from '../../types/api.js';
+import type { DcaSingleChainPreparedData, DcaSingleChainUserIntentRequest } from '../../types/intent.js';
+import { DcaSingleChainOrderValidator } from '../../utils/order-validator.js';
+import { BaseSDK } from '../sdk.js';
+import { getEVMDcaSingleChainOrderTypedData } from '../evm/order-signature.js';
+import { type ExtraTransfer } from './common.js';
+import { getSolanaDcaSingleChainOrderInstructions } from '../solana/dca/create-order.js';
+
+export type CreateDcaSingleChainOrderParams = {
+  chainId: SupportedChain;
+  tokenIn: string;
+  tokenOut: string;
+  destinationAddress: string;
+  startTime: number;
+  amountInPerInterval: bigint;
+  totalIntervals: number;
+  intervalDuration: number;
+  amountOutMin?: bigint;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+};
+
+export class DcaSingleChainOrder {
+  public user: string;
+  public chainId: SupportedChain;
+  public tokenIn: string;
+  public tokenOut: string;
+  public destinationAddress: string;
+  public startTime: number;
+  public amountInPerInterval: bigint | number;
+  public totalIntervals: number;
+  public intervalDuration: number;
+  public amountOutMin: bigint | number;
+  public extraTransfers?: ExtraTransfer[];
+  public deadline: number;
+
+  private constructor(params: CreateDcaSingleChainOrderParams & { user: string }) {
+    this.user = params.user;
+    this.chainId = params.chainId;
+    this.tokenIn = params.tokenIn;
+    this.tokenOut = params.tokenOut;
+    this.destinationAddress = params.destinationAddress;
+    this.startTime = params.startTime;
+    this.amountInPerInterval = params.amountInPerInterval;
+    this.totalIntervals = params.totalIntervals;
+    this.intervalDuration = params.intervalDuration;
+    this.amountOutMin = params.amountOutMin ?? 1n;
+    this.extraTransfers = params.extraTransfers;
+    this.deadline = params.deadline;
+  }
+
+  public static async create(input: CreateDcaSingleChainOrderParams & { user: string }): Promise<DcaSingleChainOrder> {
+    new DcaSingleChainOrderValidator().validateOrder(input);
+
+    const order = new DcaSingleChainOrder({
+      ...input,
+      user: input.user,
+    });
+
+    if (isEvmChain(order.chainId)) {
+      return order;
+    }
+
+    const preparedRandomData = order.getRandomPreparedData();
+    const intentRequest = order.toIntentRequest(preparedRandomData);
+    await BaseSDK.validateDcaSingleChainOrder(intentRequest);
+
+    return order;
+  }
+
+  /// This is needed because API requires the prepared data to be sent
+  /// In the cases of Solana and Sui, if we want the real data, we must send the order on-chain before validating.
+  /// And that is something we cannot do before validating the order on the API side.
+  private getRandomPreparedData(): DcaSingleChainPreparedData {
+    const chainId = this.chainId;
+    const chainType = chainIdToChainTypeMap[chainId];
+
+    const randomNumber = String(Math.floor(Math.random() * 10000000));
+
+    switch (chainType) {
+      case 'EVM': {
+        return {
+          nonce: randomNumber,
+          signature: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        };
+      }
+      case 'Solana': {
+        return {
+          secretNumber: randomNumber,
+          orderPubkey: 'DFNAjFAvS4GF98Tp1kiyLvEHM3wjGXibCfF86nnmhuVc',
+        };
+      }
+      case 'Sui': {
+        throw new ValidationError('DCA orders are not supported on Sui');
+      }
+
+      default: {
+        throw new Error('Chain type not supported');
+      }
+    }
+  }
+
+  public getTotalAmountIn(): bigint {
+    return BigInt(this.amountInPerInterval) * BigInt(this.totalIntervals);
+  }
+
+  public toIntentRequest(preparedData: DcaSingleChainPreparedData): DcaSingleChainUserIntentRequest {
+    const sourceChainType = chainIdToChainTypeMap[this.chainId];
+
+    return {
+      genericData: this,
+      chainSpecificData: {
+        [sourceChainType]: preparedData,
+      },
+    };
+  }
+
+  public sendToAuctioneer(preparedData: DcaSingleChainPreparedData): Promise<ApiResponse> {
+    return BaseSDK.sendDcaSingleChainOrder({
+      order: this,
+      preparedData,
+    });
+  }
+
+  public async toEVMTypedData() {
+    if (!isEvmChain(this.chainId)) {
+      throw new ValidationError('Chain id is not an Ethereum compatible chain');
+    }
+
+    return getEVMDcaSingleChainOrderTypedData(this);
+  }
+
+  public async toSolanaInstructionsByteArray() {
+    if (this.chainId !== ChainID.Solana) {
+      throw new ValidationError('Chain id is not Solana');
+    }
+
+    return getSolanaDcaSingleChainOrderInstructions(this);
+  }
+}

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;
@@ -106,7 +112,7 @@ export class SingleChainOrder {
     });
 
     switch (scenario) {
-      case 'QUOTE_REQUIRED':
+      case 'QUOTE_REQUIRED': {
         const quote = await QuoteProvider.getSingleChainQuote({
           tokenIn: input.tokenIn,
           amount: input.amountIn,
@@ -114,6 +120,7 @@ export class SingleChainOrder {
           tokenOut: input.tokenOut,
         });
         return (quote.amountOut * 93n) / 100n; // Add 7% reduced fixed amount to cover fees
+      }
 
       case 'USE_PROVIDED_AMOUNT':
         return amountOutMin!;

package/src/core/sdk.ts

@@ -4,119 +4,69 @@ 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 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> {
@@ -125,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,
+  };
+}