@shogun-sdk/intents-sdk 1.1.0 → 1.2.0

package/src/constants.ts

@@ -1,69 +1,101 @@
-import { address, type Address as SolanaAddress } from '@solana/kit';
-import type { Address, Hex } from 'viem';
+import { type Address as SolanaAddress } from '@solana/kit';
+import type { Address as EvmAddress } from 'viem';
 import type { SupportedChain, SupportedEvmChain, SupportedSuiChain } from './chains.js';
 import { ChainID } from './chains.js';
 
-const useProdConfig = true;
+const useProdConfig = false;
 
 export enum OrderType {
   CROSS_CHAIN_LIMIT = 'CROSS_CHAIN_LIMIT',
   SINGLE_CHAIN_LIMIT = 'SINGLE_CHAIN_LIMIT',
 }
 
-export const PERMIT2_ADDRESS: Record<SupportedEvmChain, Address> = {
-  [ChainID.Arbitrum]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as Address,
-  [ChainID.Optimism]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as Address,
-  [ChainID.Base]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as Address,
-  [ChainID.Hyperliquid]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as Address,
+export const PERMIT2_ADDRESS: Record<SupportedEvmChain, EvmAddress> = {
+  [ChainID.Arbitrum]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as EvmAddress,
+  [ChainID.Optimism]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as EvmAddress,
+  [ChainID.Base]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as EvmAddress,
+  [ChainID.Hyperliquid]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as EvmAddress,
 };
 
 // Production guard addresses
-export const PROD_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, SolanaAddress | Hex> = {
-  [ChainID.Arbitrum]: '0x921ab91ee3dc38fd47aefd6218fd6b0bd9d64c18' as Address,
-  [ChainID.Optimism]: '0xa89b2aae94769bf4a5dc9982eabe2c513564d1ea' as Address,
-  [ChainID.Base]: '0x5173e9f12e2485f990ce4dac877d8545fb4ec81a' as Address,
-  [ChainID.Hyperliquid]: '0x6595bcc70e0c34ecf9174bb72881eea89b075021' as Address,
-  [ChainID.Solana]: address('4kD6otCKkKZQej8YNQkWdzG9xMo5XYN8T1BbUrJUE63E'),
+export const PROD_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, SolanaAddress | EvmAddress> = {
+  [ChainID.Arbitrum]: '0x921ab91ee3dc38fd47aefd6218fd6b0bd9d64c18' as EvmAddress,
+  [ChainID.Optimism]: '0xa89b2aae94769bf4a5dc9982eabe2c513564d1ea' as EvmAddress,
+  [ChainID.Base]: '0x5173e9f12e2485f990ce4dac877d8545fb4ec81a' as EvmAddress,
+  [ChainID.Hyperliquid]: '0x6595bcc70e0c34ecf9174bb72881eea89b075021' as EvmAddress,
+  [ChainID.Solana]:
+    '4kD6otCKkKZQej8YNQkWdzG9xMo5XYN8T1BbUrJUE63E' as SolanaAddress<'4kD6otCKkKZQej8YNQkWdzG9xMo5XYN8T1BbUrJUE63E'>,
   [ChainID.Sui]: '0x88a47715f41c5e47ff6d6dcfc0285f3802ae1587a9f411d0daff20269245a1b0',
 };
 
 // Test guard addresses
-export const TEST_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, SolanaAddress | Hex> = {
-  [ChainID.Arbitrum]: '0x8cfacbe4e236c0ca0a7b4b9fc5b696aa9f07cc41' as Address,
-  [ChainID.Optimism]: '0x66fbcccbd3ffe2d347bc2776ef8a6561ff29998e' as Address,
-  [ChainID.Base]: '0xa895a53634854756ae8e902065e3be26ee36381d' as Address,
-  [ChainID.Hyperliquid]: '0xB8ec423b5f03b138Ad47c85Ea5F7AAEBB116D65e' as Address,
-  [ChainID.Solana]: address('FAKnXTY7cNz9wMTpH1wwsU9a1xzBAiMwAn2NXmGMLynP'),
+export const TEST_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, SolanaAddress | EvmAddress> = {
+  [ChainID.Arbitrum]: '0x8cfacbe4e236c0ca0a7b4b9fc5b696aa9f07cc41' as EvmAddress,
+  [ChainID.Optimism]: '0x66fbcccbd3ffe2d347bc2776ef8a6561ff29998e' as EvmAddress,
+  [ChainID.Base]: '0xa895a53634854756ae8e902065e3be26ee36381d' as EvmAddress,
+  [ChainID.Hyperliquid]: '0xB8ec423b5f03b138Ad47c85Ea5F7AAEBB116D65e' as EvmAddress,
+  [ChainID.Solana]:
+    'FAKnXTY7cNz9wMTpH1wwsU9a1xzBAiMwAn2NXmGMLynP' as SolanaAddress<'FAKnXTY7cNz9wMTpH1wwsU9a1xzBAiMwAn2NXmGMLynP'>,
   [ChainID.Sui]: '0xd5057237ba5fe3d9aa00bb2a1555c3d3de77fd5653e72ce70f4aa0561fa9f04d',
 };
 
 // Prod guard addresses
-export const PROD_SINGLE_CHAIN_GUARD_ADDRESSES: Record<Exclude<ChainID, SupportedSuiChain>, SolanaAddress | Hex> = {
-  [ChainID.Arbitrum]: '0x0' as Address,
-  [ChainID.Optimism]: '0x0' as Address,
-  [ChainID.Base]: '0x449808a27f42518c57791d4c2c6626f0069a0ed9' as Address,
-  [ChainID.Hyperliquid]: '0x618ee9b6829261108d811b91581e00da192b0b75' as Address,
-  [ChainID.Solana]: address('CwWkajHjBCWMKZdwR5D1P5M6Fgf9dAyxqZ1qDZgZGo1e'),
+export const PROD_SINGLE_CHAIN_GUARD_ADDRESSES: Record<
+  Exclude<ChainID, SupportedSuiChain>,
+  SolanaAddress | EvmAddress
+> = {
+  [ChainID.Arbitrum]: '0x0' as EvmAddress,
+  [ChainID.Optimism]: '0x0' as EvmAddress,
+  [ChainID.Base]: '0x449808a27f42518c57791d4c2c6626f0069a0ed9' as EvmAddress,
+  [ChainID.Hyperliquid]: '0x618ee9b6829261108d811b91581e00da192b0b75' as EvmAddress,
+  [ChainID.Solana]:
+    'CwWkajHjBCWMKZdwR5D1P5M6Fgf9dAyxqZ1qDZgZGo1e' as SolanaAddress<'CwWkajHjBCWMKZdwR5D1P5M6Fgf9dAyxqZ1qDZgZGo1e'>,
 };
 
 // Test guard addresses
-export const TEST_SINGLE_CHAIN_GUARD_ADDRESSES: Record<Exclude<ChainID, SupportedSuiChain>, SolanaAddress | Hex> = {
-  [ChainID.Arbitrum]: '0x0' as Address,
-  [ChainID.Optimism]: '0x0' as Address,
-  [ChainID.Base]: '0x5602cedc725564694162a320c5bb91b5b4b25fca' as Address,
-  [ChainID.Hyperliquid]: '0x6a2f41f905035fa89b7329c0661061b580b1eb92' as Address,
-  [ChainID.Solana]: address('4wi5wsgSs9q9WV55s9AvKWTdeMNPcDXhzcbx5SoRRFcg'),
+export const TEST_SINGLE_CHAIN_GUARD_ADDRESSES: Record<
+  Exclude<ChainID, SupportedSuiChain>,
+  SolanaAddress | EvmAddress
+> = {
+  [ChainID.Arbitrum]: '0x0' as EvmAddress,
+  [ChainID.Optimism]: '0x0' as EvmAddress,
+  [ChainID.Base]: '0x5602cedc725564694162a320c5bb91b5b4b25fca' as EvmAddress,
+  [ChainID.Hyperliquid]: '0x6a2f41f905035fa89b7329c0661061b580b1eb92' as EvmAddress,
+  [ChainID.Solana]:
+    '4wi5wsgSs9q9WV55s9AvKWTdeMNPcDXhzcbx5SoRRFcg' as SolanaAddress<'4wi5wsgSs9q9WV55s9AvKWTdeMNPcDXhzcbx5SoRRFcg'>,
+};
+
+export const PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, EvmAddress> = {
+  [ChainID.Arbitrum]: '0x0000000000000000000000000000000000000000' as EvmAddress,
+  [ChainID.Optimism]: '0x0000000000000000000000000000000000000000' as EvmAddress,
+  [ChainID.Base]: '0x1ab119e95a87ff59a57eba6dec6599aff8b2d7e4' as EvmAddress,
+  [ChainID.Hyperliquid]: '0x490911e5236f68ba921cbecc4b82b5e01b745731' as EvmAddress,
+};
+
+// Test guard addresses
+export const TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, EvmAddress> = {
+  [ChainID.Arbitrum]: '0x0000000000000000000000000000000000000000' as EvmAddress,
+  [ChainID.Optimism]: '0x0000000000000000000000000000000000000000' as EvmAddress,
+  [ChainID.Base]: '0x79fd6a458066396c8938823049b6e614ce6b71f2' as EvmAddress,
+  [ChainID.Hyperliquid]: '0x5156e6c7b7a1c60ed4d6b2175f88f1f6875c78d8' as EvmAddress,
 };
 
 export const CROSS_CHAIN_GUARD_ADDRESSES = useProdConfig
   ? PROD_CROSS_CHAIN_GUARD_ADDRESSES
   : TEST_CROSS_CHAIN_GUARD_ADDRESSES;
+
 export const SINGLE_CHAIN_GUARD_ADDRESSES = useProdConfig
   ? PROD_SINGLE_CHAIN_GUARD_ADDRESSES
   : TEST_SINGLE_CHAIN_GUARD_ADDRESSES;
 
-export const NATIVE_SOLANA_TOKEN_ADDRESS = address('So11111111111111111111111111111111111111111');
-export const WRAPPED_SOL_MINT_ADDRESS = address('So11111111111111111111111111111111111111112');
+export const DCA_SINGLE_CHAIN_GUARD_ADDRESSES = useProdConfig
+  ? PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES
+  : TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES;
+
+export const NATIVE_SOLANA_TOKEN_ADDRESS =
+  'So11111111111111111111111111111111111111111' as SolanaAddress<'So11111111111111111111111111111111111111111'>;
+export const WRAPPED_SOL_MINT_ADDRESS =
+  'So11111111111111111111111111111111111111112' as SolanaAddress<'So11111111111111111111111111111111111111112'>;
 
 type SolanaMint = {
   name: string;
@@ -109,14 +141,15 @@ export const NATIVE_EVM_ETH_ADDRESSES = [
   '0x0000000000000000000000000000000000000000',
 ];
 
-export const WRAPPED_ETH_ADDRESSES: Record<SupportedEvmChain, Address> = {
-  [ChainID.Arbitrum]: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1' as Address,
-  [ChainID.Optimism]: '0x4200000000000000000000000000000000000006' as Address,
-  [ChainID.Base]: '0x4200000000000000000000000000000000000006' as Address,
-  [ChainID.Hyperliquid]: '0x5555555555555555555555555555555555555555' as Address,
+export const WRAPPED_ETH_ADDRESSES: Record<SupportedEvmChain, EvmAddress> = {
+  [ChainID.Arbitrum]: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1' as EvmAddress,
+  [ChainID.Optimism]: '0x4200000000000000000000000000000000000006' as EvmAddress,
+  [ChainID.Base]: '0x4200000000000000000000000000000000000006' as EvmAddress,
+  [ChainID.Hyperliquid]: '0x5555555555555555555555555555555555555555' as EvmAddress,
 };
 
 export const NATIVE_SUI_TOKEN_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+
 export function isNativeEvmToken(tokenAddress: string): boolean {
   const normalizedAddress = tokenAddress.toLowerCase();
 

package/src/core/evm/connectors/hyperevm.ts

@@ -16,7 +16,7 @@ export const hyperEVM = defineChain({
   blockExplorers: {
     default: {
       name: 'HyperEVM Explorer',
-      url: 'https://hyperevmscan.io/', 
+      url: 'https://hyperevmscan.io/',
     },
   },
   testnet: false,

package/src/core/evm/intent-provider.ts

@@ -1,13 +1,32 @@
 import { type Address } from 'viem';
 import { type SupportedEvmChain } from '../../chains.js';
 import type { EVMConfig } from '../../config.js';
-import { SINGLE_CHAIN_GUARD_ADDRESSES, CROSS_CHAIN_GUARD_ADDRESSES, MAX_UINT_32 } from '../../constants.js';
-import { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData } from './order-signature.js';
-import { type CrossChainPermitTransferFrom, type SingleChainPermitTransferFrom, type TransferData } from './permit2.js';
+import {
+  SINGLE_CHAIN_GUARD_ADDRESSES,
+  CROSS_CHAIN_GUARD_ADDRESSES,
+  MAX_UINT_32,
+  DCA_SINGLE_CHAIN_GUARD_ADDRESSES,
+} from '../../constants.js';
+import {
+  getEVMCrossChainOrderTypedData,
+  getEVMDcaSingleChainOrderTypedData,
+  getEVMSingleChainOrderTypedData,
+} from './order-signature.js';
+import {
+  type CrossChainPermitTransferFrom,
+  type DcaSingleChainPermitTransferFrom,
+  type SingleChainPermitTransferFrom,
+  type TransferData,
+} from './permit2.js';
 import { ChainProvider } from './chain-provider.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
-import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import type {
+  CrossChainOrderPrepared,
+  DcaSingleChainOrderPrepared,
+  SingleChainOrderPrepared,
+} from '../../types/intent.js';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
 
 export class EVMIntentProvider {
   provider: ChainProvider;
@@ -119,4 +138,69 @@ export class EVMIntentProvider {
   static getRandomNonce(): bigint {
     return BigInt(Math.floor(Math.random() * Number(MAX_UINT_32)));
   }
+
+  async prepareDcaSingleChainOrder(order: DcaSingleChainOrder): Promise<DcaSingleChainOrderPrepared> {
+    const { orderTypedData: dataToSign, nonce } = await getEVMDcaSingleChainOrderTypedData(order);
+
+    const signature = await this.provider.walletClient.signTypedData({
+      message: dataToSign.message,
+      primaryType: dataToSign.primaryType,
+      types: dataToSign.types,
+      domain: dataToSign.domain,
+      account: this.provider.getAccount(),
+    });
+
+    return {
+      order,
+      preparedData: {
+        nonce: nonce.toString(),
+        signature: signature.slice(2),
+      },
+    };
+  }
+
+  static getDcaSingleChainPermissionMessage(
+    order: DcaSingleChainOrder,
+    nonce: bigint,
+  ): DcaSingleChainPermitTransferFrom {
+    const spender = DCA_SINGLE_CHAIN_GUARD_ADDRESSES[order.chainId as SupportedEvmChain] as Address;
+
+    const requestedOutput: TransferData = {
+      token: order.tokenOut as Address,
+      receiver: order.destinationAddress as Address,
+      amount: BigInt(order.amountOutMin),
+    };
+
+    const extraTransfers: TransferData[] =
+      order.extraTransfers?.map((transfer) => ({
+        token: transfer.token as Address,
+        receiver: transfer.receiver as Address,
+        amount: transfer.amount,
+      })) || [];
+
+    const totalAmountIn = BigInt(order.amountInPerInterval) * BigInt(order.totalIntervals);
+
+    return {
+      permitted: {
+        token: order.tokenIn as Address,
+        amount: totalAmountIn,
+      },
+      spender,
+      nonce,
+      deadline: BigInt(order.deadline),
+      witness: {
+        user: order.user as Address,
+        tokenIn: order.tokenIn as Address,
+        startTime: order.startTime,
+        amountInPerInterval: BigInt(order.amountInPerInterval),
+        totalIntervals: order.totalIntervals,
+        intervalDuration: order.intervalDuration,
+        requestedOutput,
+        encodedExternalCallData: '0x', // TODO: Update when external call data is supported
+        extraTransfers,
+        deadline: order.deadline,
+        nonce,
+      },
+    };
+  }
 }

package/src/core/evm/order-signature.ts

@@ -2,7 +2,13 @@ import type { TypedDataDefinition } from 'viem';
 import type { SupportedEvmChain } from '../../chains.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
 import { EVMIntentProvider } from './intent-provider.js';
-import { CROSS_CHAIN_PERMIT2_TYPES, PERMIT2_DOMAIN, SINGLE_CHAIN_LIMIT_PERMIT2_TYPES } from './permit2.js';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
+import {
+  CROSS_CHAIN_PERMIT2_TYPES,
+  DCA_SINGLE_CHAIN_PERMIT2_TYPES,
+  PERMIT2_DOMAIN,
+  SINGLE_CHAIN_LIMIT_PERMIT2_TYPES,
+} from './permit2.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
 
 export async function getEVMSingleChainOrderTypedData(
@@ -41,3 +47,19 @@ export async function getEVMCrossChainOrderTypedData(
 
   return { orderTypedData, nonce: randomNonce };
 }
+
+export async function getEVMDcaSingleChainOrderTypedData(
+  order: DcaSingleChainOrder,
+): Promise<{ orderTypedData: TypedDataDefinition; nonce: bigint }> {
+  const randomNonce = EVMIntentProvider.getRandomNonce();
+  const permissionMessage = EVMIntentProvider.getDcaSingleChainPermissionMessage(order, randomNonce);
+
+  const orderTypedData = {
+    domain: PERMIT2_DOMAIN(order.chainId as SupportedEvmChain),
+    types: DCA_SINGLE_CHAIN_PERMIT2_TYPES,
+    primaryType: 'PermitWitnessTransferFrom',
+    message: permissionMessage,
+  };
+
+  return { orderTypedData, nonce: randomNonce };
+}

package/src/core/evm/permit2.ts

@@ -100,7 +100,6 @@ export const CROSS_CHAIN_PERMIT2_TYPES = {
   ],
 } as const;
 
-// Single-chain limit order types
 export const SINGLE_CHAIN_LIMIT_PERMIT2_TYPES = {
   TokenPermissions: TOKEN_PERMISSIONS_TYPE,
   TransferData: TRANSFER_DATA_TYPE,
@@ -128,3 +127,50 @@ export const PERMIT2_DOMAIN = (chainId: SupportedEvmChain): TypedDataDomain => (
   chainId,
   verifyingContract: PERMIT2_ADDRESS[chainId],
 });
+
+type DcaSingleChainOrderWitness = {
+  user: Address;
+  tokenIn: Address;
+  startTime: number;
+  amountInPerInterval: bigint;
+  totalIntervals: number;
+  intervalDuration: number;
+  requestedOutput: TransferData;
+  extraTransfers: TransferData[];
+  encodedExternalCallData: Hex;
+  deadline: number;
+  nonce: bigint;
+};
+
+export type DcaSingleChainPermitTransferFrom = {
+  permitted: TokenPermissions;
+  spender: Address;
+  nonce: bigint;
+  deadline: bigint;
+  witness: DcaSingleChainOrderWitness;
+};
+
+export const DCA_SINGLE_CHAIN_PERMIT2_TYPES = {
+  TokenPermissions: TOKEN_PERMISSIONS_TYPE,
+  TransferData: TRANSFER_DATA_TYPE,
+  SingleChainDcaOrder: [
+    { type: 'address', name: 'user' },
+    { type: 'address', name: 'tokenIn' },
+    { type: 'uint32', name: 'startTime' },
+    { type: 'uint256', name: 'amountInPerInterval' },
+    { type: 'uint24', name: 'totalIntervals' },
+    { type: 'uint32', name: 'intervalDuration' },
+    { type: 'TransferData', name: 'requestedOutput' },
+    { type: 'TransferData[]', name: 'extraTransfers' },
+    { type: 'bytes', name: 'encodedExternalCallData' },
+    { type: 'uint32', name: 'deadline' },
+    { type: 'uint256', name: 'nonce' },
+  ],
+  PermitWitnessTransferFrom: [
+    { name: 'permitted', type: 'TokenPermissions' },
+    { name: 'spender', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+    { name: 'witness', type: 'SingleChainDcaOrder' },
+  ],
+} as const;

package/src/core/evm/sdk.ts

@@ -12,10 +12,13 @@ import {
 import type { ExtraTransfer } from '../orders/common.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
-import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
-import type { ApiUserOrders } from '../../types/api.js';
+import type {
+  CrossChainOrderPrepared,
+  DcaSingleChainOrderPrepared,
+  SingleChainOrderPrepared,
+} from '../../types/intent.js';
 import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
-import { fetchUserOrders } from '../orders/api/fetch.js';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
 
 type CancelSingleChainOrderParams = {
   orderId: string;
@@ -47,7 +50,6 @@ type CancelCrossChainOrderParams = {
 export class EVMSDK extends BaseSDK {
   private readonly config: EVMConfig;
   private readonly evmIntentProvider: EVMIntentProvider;
-  private token?: string;
 
   constructor(config: EVMConfig) {
     super();
@@ -187,22 +189,6 @@ export class EVMSDK 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;
-  }
-
   /**
    * Gets the user's Ethereum address derived from their private key
    * @returns Promise resolving to the user's Ethereum address as a 0x-prefixed string
@@ -240,8 +226,16 @@ export class EVMSDK extends BaseSDK {
     return this.evmIntentProvider.prepareCrossChainOrder(order);
   }
 
-  protected async prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared> {
+  protected override async prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared> {
     await this.approveAllowanceIfNeeded(order.tokenIn as Address, order.amountIn);
     return this.evmIntentProvider.prepareSingleChainOrder(order);
   }
+
+  protected override async prepareDcaSingleChainOrder(
+    order: DcaSingleChainOrder,
+  ): Promise<DcaSingleChainOrderPrepared> {
+    const totalAmountIn = order.getTotalAmountIn();
+    await this.approveAllowanceIfNeeded(order.tokenIn as Address, totalAmountIn);
+    return this.evmIntentProvider.prepareDcaSingleChainOrder(order);
+  }
 }

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/index.ts

@@ -0,0 +1,33 @@
+import { AUCTIONEER_URL } from '../../../constants.js';
+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, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.aggregatedToken}`,
+      },
+    });
+
+    const data: ApiResponse<ApiUserOrders> = await response.json();
+
+    if (!data.success) {
+      throw new Error(`Failed to fetch user orders: ${data.error}`);
+    }
+
+    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);
+  }
+}