@shogun-sdk/intents-sdk 1.1.1 → 1.2.0

package/src/core/evm/validator.ts

@@ -7,6 +7,7 @@ import type { CreateCrossChainOrderParams } from '../orders/cross-chain.js';
 import { ERC20ABI } from './abi/erc20.js';
 import { ChainProvider } from './chain-provider.js';
 import type { CreateSingleChainOrderParams } from '../orders/single-chain.js';
+import type { CreateDcaSingleChainOrderParams } from '../orders/dca-single-chain.js';
 
 /**
  * Chain-specific validator implementations
@@ -119,4 +120,35 @@ export class EvmValidator extends BaseValidator {
     //   );
     // }
   }
+
+  override async validateDcaSingleChainOrderFeasability(
+    order: CreateDcaSingleChainOrderParams & { user: string },
+  ): Promise<void> {
+    const chain = order.chainId as SupportedEvmChain;
+
+    const client = ChainProvider.getClient(chain);
+    const user = order.user as Address;
+
+    if (isNativeEvmToken(order.tokenIn)) {
+      throw new ValidationError('Native token is not supported for DCA orders.');
+    }
+
+    const ERC20Contract = getContract({
+      address: order.tokenIn as Address,
+      abi: ERC20ABI,
+      client: {
+        public: client,
+        chain,
+      },
+    });
+
+    const totalAmountIn = order.amountInPerInterval * BigInt(order.totalIntervals);
+    const balance = await ERC20Contract.read.balanceOf([user]);
+
+    if (balance < totalAmountIn) {
+      throw new InsufficientBalanceError(
+        `Insufficient balance for DCA order. Token: ${order.tokenIn}. Current balance: ${balance}. Required total: ${totalAmountIn}`,
+      );
+    }
+  }
 }

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

@@ -19,4 +19,3 @@ export async function fetchUserOrders(jwtToken: string): Promise<ApiUserOrders>
 
   return data.data!;
 }
-

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);

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;

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;
+}