@shogun-sdk/intents-sdk 1.1.1 → 1.2.1

package/src/index.ts

@@ -14,7 +14,15 @@ export { fetchUserOrders } from './core/orders/api/fetch.js';
 export { AuctioneerAPI } from './core/orders/api/index.js';
 export { type FetchJWTParams, type FetchSiweMessageParams, fetchJWTToken, fetchSiweMessage } from './auth/siwe.js';
 export { ValidationError } from './errors/index.js';
-export { type ApiCrossChainOrder, type ApiResponse, type ApiSingleChainOrder, type ApiUserOrders, type ChainOrderStatus, isErrorApiResponse, isSuccessApiResponse } from './types/api.js';
+export {
+  type ApiCrossChainOrder,
+  type ApiResponse,
+  type ApiSingleChainOrder,
+  type ApiUserOrders,
+  type ChainOrderStatus,
+  isErrorApiResponse,
+  isSuccessApiResponse,
+} from './types/api.js';
 export { calculateAmounts, getCoinFromResponse, getTokensData } from './utils/defillama.js';
 export type { DefiLlamaCoinData, DefiLlamaTokensResponse } from './utils/defillama.js';
 export {
@@ -24,8 +32,11 @@ export {
   type CancelCrossChainOrderParams,
   getInvalidateNoncesRawData,
 } from './core/evm/cancel-order.js';
+export { cancelDcaSingleChainOrderInstructions } from './core/solana/dca/cancel-order.js';
 export { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData } from './core/evm/order-signature.js';
 
+export { getSolanaOrdersWithLockedFunds } from './core/solana/inspect.js';
+
 export {
   getSolanaCrossChainOrderInstructions,
   getSolanaSingleChainOrderInstructions,

package/src/types/api.ts

@@ -75,4 +75,4 @@ export function isErrorApiResponse<T extends ValidResponseData>(
   response: ApiResponse<T>,
 ): response is ApiResponse<T> & { success: false; error: unknown } {
   return !response.success;
-}
+}

package/src/types/intent.ts

@@ -2,6 +2,7 @@ import type { SupportedChain } from '../chains.js';
 import type { CrossChainOrder } from '../core/orders/cross-chain.js';
 import type { ExtraTransfer } from '../core/orders/common.js';
 import type { SingleChainOrder } from '../core/orders/single-chain.js';
+import type { DcaSingleChainOrder } from '../core/orders/dca-single-chain.js';
 
 /**
  * Details required to execute the order on the destination chain
@@ -120,3 +121,29 @@ export type SingleChainOrderPrepared = {
   order: SingleChainOrder;
   preparedData: SingleChainPreparedData;
 };
+
+export type DcaSingleChainUserIntentRequest = {
+  genericData: DcaSingleChainOrder;
+  chainSpecificData: {
+    EVM?: DcaSingleChainEVMPreparedData;
+    Solana?: DcaSingleChainSolanaPreparedData;
+    Sui?: never; // DCA not supported on Sui
+  };
+};
+
+export type DcaSingleChainEVMPreparedData = {
+  nonce: string;
+  signature: string | Hash;
+};
+
+export type DcaSingleChainSolanaPreparedData = {
+  secretNumber: string;
+  orderPubkey: string;
+};
+
+export type DcaSingleChainPreparedData = DcaSingleChainEVMPreparedData | DcaSingleChainSolanaPreparedData;
+
+export type DcaSingleChainOrderPrepared = {
+  order: DcaSingleChainOrder;
+  preparedData: DcaSingleChainPreparedData;
+};

package/src/utils/base-validator.ts

@@ -1,4 +1,5 @@
 import type { CreateCrossChainOrderParams } from '../core/orders/cross-chain.js';
+import type { CreateDcaSingleChainOrderParams } from '../core/orders/dca-single-chain.js';
 import type { CreateSingleChainOrderParams } from '../core/orders/single-chain.js';
 import { ValidationError } from '../errors/index.js';
 import type { IChainValidator } from './order-validator.js';
@@ -59,6 +60,45 @@ export abstract class BaseValidator implements IChainValidator {
     }
   }
 
+  abstract validateDcaSingleChainOrderFeasability(
+    order: CreateDcaSingleChainOrderParams & { user: string },
+  ): Promise<void>;
+
+  async validateDcaSingleChainOrder(order: CreateDcaSingleChainOrderParams & { user: string }): Promise<void> {
+    this.validateTokenAddress(order.tokenIn);
+    this.validateTokenAddress(order.tokenOut);
+    this.validateAmount(order.amountInPerInterval);
+    this.validateAmount(order.amountOutMin ?? 1n);
+    this.validateAddress(order.destinationAddress);
+
+    // Validate DCA-specific parameters
+    if (order.totalIntervals <= 0) {
+      throw new ValidationError('Total intervals must be greater than 0');
+    }
+
+    if (order.intervalDuration <= 0) {
+      throw new ValidationError('Interval duration must be greater than 0');
+    }
+
+    if (order.startTime < 0) {
+      throw new ValidationError('Start time must be non-negative');
+    }
+
+    // Validate total amount doesn't overflow
+    const totalAmount = order.amountInPerInterval * BigInt(order.totalIntervals);
+    this.validateAmount(totalAmount);
+
+    if (order.extraTransfers) {
+      for (const extraTransfer of order.extraTransfers) {
+        this.validateAddress(extraTransfer.receiver);
+        this.validateTokenAddress(extraTransfer.token);
+        this.validateAmount(extraTransfer.amount);
+      }
+    }
+
+    await this.validateDcaSingleChainOrderFeasability(order);
+  }
+
   /**
    * Helper methods that throw specific validation errors
    */

package/src/utils/order-validator.ts

@@ -26,6 +26,7 @@ export interface IChainValidator extends IAddressValidator, ITokenValidator, IAm
   validateSourceChain(order: CreateCrossChainOrderParams & { user: string }): Promise<void>;
   validateDestinationChain(order: CreateCrossChainOrderParams): void;
   validateSingleChainOrder(order: CreateSingleChainOrderParams & { user: string }): Promise<void>;
+  validateDcaSingleChainOrder(order: CreateDcaSingleChainOrderParams & { user: string }): Promise<void>;
 }
 
 /**
@@ -99,3 +100,40 @@ export class SingleChainOrderValidator {
     chainValidator.validateSingleChainOrder(order);
   }
 }
+
+import type { CreateDcaSingleChainOrderParams } from '../core/orders/dca-single-chain.js';
+
+export interface IDcaValidator {
+  validateDcaSingleChainOrder(order: CreateDcaSingleChainOrderParams & { user: string }): Promise<void>;
+}
+
+export class DcaSingleChainOrderValidator {
+  private readonly commonValidator = new CommonValidator();
+
+  async validateOrder(order: CreateDcaSingleChainOrderParams & { user: string }): Promise<void> {
+    this.commonValidator.validateDeadline(order.deadline);
+
+    // Validate start time is in the future or current time
+    if (order.startTime < Math.floor(Date.now() / 1000)) {
+      throw new ValidationError('Start time must be in the future or current time');
+    }
+
+    // Validate intervals
+    if (order.totalIntervals <= 0) {
+      throw new ValidationError('Total intervals must be greater than 0');
+    }
+
+    if (order.intervalDuration <= 0) {
+      throw new ValidationError('Interval duration must be greater than 0');
+    }
+
+    // Validate that the order will complete before deadline
+    const estimatedCompletionTime = order.startTime + order.totalIntervals * order.intervalDuration;
+    if (estimatedCompletionTime > order.deadline) {
+      throw new ValidationError('Order would complete after deadline');
+    }
+
+    const chainValidator = ValidatorFactory.getValidatorForChain(order.chainId);
+    await chainValidator.validateDcaSingleChainOrder(order);
+  }
+}

package/src/utils/quote/aggregator.ts

@@ -89,8 +89,8 @@ export class QuoteProvider {
   private static async getQuoteFromRouters(params: QuoteParams): Promise<QuoteResponse> {
     const bridgeTokenSymbol = QuoteProvider.DEFAULT_BRIDGE_TOKEN;
 
-    const sourceBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.sourceChainId]!;
-    const destBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.destChainId]!;
+    const sourceBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.sourceChainId] || '';
+    const destBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.destChainId] || '';
 
     const sourceSingleChainQuoteParams: SingleChainQuoteParams = {
       chainId: params.sourceChainId,

package/src/utils/quote/liquidswap.ts

@@ -18,8 +18,8 @@ const LIQUID_SWAP_API_URL = 'https://api.liqd.ag';
 
 export class LiquidSwapQuoteProvider {
   public async getQuote(liquidSwapParams: LiquidSwapQuoteParams): Promise<LiquidSwapQuoteResponse> {
-    const params = {...liquidSwapParams};
-    
+    const params = { ...liquidSwapParams };
+
     if (isNativeEvmToken(params.tokenOut)) {
       params.tokenOut = WRAPPED_ETH_ADDRESSES[ChainID.Hyperliquid];
     }