@shogun-sdk/intents-sdk 1.1.0 → 1.2.0

package/src/core/solana/utils.ts

@@ -2,8 +2,9 @@ import BN from 'bn.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
 import { PublicKey } from '@solana/web3.js';
 import sha3 from 'js-sha3';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
 
-export function genSecretHashAndNumber(order: SingleChainOrder): {
+export function genSecretHashAndNumber(order: SingleChainOrder | DcaSingleChainOrder): {
   secretHash: number[];
   secretNumber: string;
 } {

package/src/core/solana/validator.ts

@@ -27,4 +27,8 @@ export class SolanaValidator extends BaseValidator {
     // No chain-specific validation implemented for now for Solana
     return;
   }
+
+  override async validateDcaSingleChainOrderFeasability(): Promise<void> {
+    return Promise.resolve();
+  }
 }

package/src/core/sui/sdk.ts

@@ -5,11 +5,9 @@ import { BaseSDK } from '../sdk.js';
 import { createSuiClient } from './client.js';
 import { getSuiOrderTransaction } from './order-transaction.js';
 import { getSuiCancelCrossChainOrder } from './cancel.js';
-import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import type { CrossChainOrderPrepared } from '../../types/intent.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
-import type { ApiUserOrders } from '../../types/api.js';
 import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
-import { fetchUserOrders } from '../orders/api/fetch.js';
 import { ChainID } from '../../chains.js';
 
 /**
@@ -24,7 +22,6 @@ export class SuiSDK extends BaseSDK {
   private readonly config: SuiConfig;
   /** Client for Sui RPC interactions and transaction handling */
   private client: SuiClient;
-  private token?: string;
 
   /**
    * Creates a new instance of the Sui SDK
@@ -60,10 +57,6 @@ export class SuiSDK extends BaseSDK {
     return Ed25519Keypair.fromSecretKey(this.config.privateKey);
   }
 
-  protected override prepareSingleChainOrder(): Promise<SingleChainOrderPrepared> {
-    throw new Error('Single-chain orders are not supported on Sui');
-  }
-
   public async authenticate(token?: string): Promise<string> {
     const wallet = await this.getUserAddress();
 
@@ -93,21 +86,6 @@ export class SuiSDK extends BaseSDK {
     return newToken;
   }
 
-  public setToken(token: string) {
-    this.token = token;
-
-    return this;
-  }
-
-  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 Sui order for submission
    *
@@ -121,7 +99,7 @@ export class SuiSDK extends BaseSDK {
    * @returns Promise resolving to a prepared order with Sui-specific data
    * @protected
    */
-  protected async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
+  protected override async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
     const signer = this.getKeyPair();
 
     const transaction = await getSuiOrderTransaction(order);

package/src/core/sui/validator.ts

@@ -1,6 +1,7 @@
 import { isValidSuiAddress, normalizeSuiAddress } from '@mysten/sui/utils';
 import { MAX_UINT_64 } from '../../constants.js';
 import { BaseValidator } from '../../utils/base-validator.js';
+import { ValidationError } from '../../errors/index.js';
 
 const SUI_TOKEN_ADDRESS_REGEX = /^0x[a-fA-F0-9]{64}::\w+::\w+$/;
 
@@ -33,4 +34,8 @@ export class SuiValidator extends BaseValidator {
   override validateSingleChainOrderFeasability(): Promise<void> {
     return Promise.resolve();
   }
+
+  override validateDcaSingleChainOrderFeasability(): Promise<void> {
+    throw new ValidationError('DCA orders are not supported on Sui');
+  }
 }

package/src/index.ts

@@ -11,9 +11,18 @@ export { SingleChainOrder } from './core/orders/single-chain.js';
 export type { CreateSingleChainOrderParams } from './core/orders/single-chain.js';
 
 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 {
@@ -23,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/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];
     }