@shogun-sdk/intents-sdk 1.2.1 → 1.2.2

package/src/core/sui/order-transaction.ts

@@ -16,12 +16,16 @@ import type { CrossChainOrder } from '../orders/cross-chain.js';
 /**
  * Generates Sui order transaction for creating an order
  * @param order The order to generate transaction for
+ * @param client The Sui client instance (optional, creates new if not provided)
  * @returns Object containing the transaction
  */
-export async function getSuiOrderTransaction(order: CrossChainOrder): Promise<Transaction> {
+export async function getSuiOrderTransaction(
+  order: CrossChainOrder,
+  client?: ReturnType<typeof createSuiClient>
+): Promise<Transaction> {
   const userAddress = order.user;
-  const client = createSuiClient();
-  const coins = await client.getCoins({
+  const suiClient = client || createSuiClient();
+  const coins = await suiClient.getCoins({
     owner: userAddress,
     coinType: order.sourceTokenAddress,
   });
@@ -62,7 +66,7 @@ export async function getSuiOrderTransaction(order: CrossChainOrder): Promise<Tr
 
   tx.moveCall({
     package: SUI_PACKAGE_ID,
-    module: 'source_chain_guard',
+    module: 'cross_chain_limit_orders',
     function: 'create_order',
     arguments: [
       tx.object(guardAddress), // arg0: &Guard<T0, T2>

package/src/core/sui/sdk.ts

@@ -102,7 +102,7 @@ export class SuiSDK extends BaseSDK {
   protected override async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
     const signer = this.getKeyPair();
 
-    const transaction = await getSuiOrderTransaction(order);
+    const transaction = await getSuiOrderTransaction(order, this.client);
 
     const tx = await this.client.signAndExecuteTransaction({
       signer,

package/src/core/sui/single-chain-dca-order.ts

@@ -0,0 +1,139 @@
+import { bcs, fromHex } from '@mysten/bcs';
+import { keccak256 } from "js-sha3";
+import { normalizeStructTag, normalizeSuiAddress, normalizeSuiObjectId } from "@mysten/sui/utils";
+import { Transaction } from '@mysten/sui/transactions';
+import { ValidationError } from '../../errors/index.js';
+import { createSuiClient } from './client.js';
+import { SUI_PACKAGE_ID, SUI_GUARD_COLLATERAL_TYPE, SUI_GUARD_STABLECOIN_TYPE, NATIVE_SUI_TOKEN_ADDRESS } from '../../constants.js';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
+
+/**
+ * Generates secret hash based on types, addresses and secret number for single chain DCA orders
+ * @param coinOutType Type tag of Coin OUT
+ * @param receiver Main Coins OUT receiver
+ * @param secretNumber Secret number, for hash randomness
+ * @param extraTransferCoinOut Type tag of extra transfer coin OUT
+ * @param extraTransferReceiver Receiver of extra transfer
+ */
+export function getDcaSecretHash(
+  coinOutType: string,
+  receiver: string,
+  secretNumber: string,
+  extraTransferCoinOut?: string,
+  extraTransferReceiver?: string,
+) {
+  const coinOutTypeBytes = Buffer.from(
+    normalizeStructTag(coinOutType).replace("0x", ""),
+    "utf8"
+  );
+  const receiverBytes = fromHex(normalizeSuiAddress(receiver));
+
+  let resBytes = [
+    ...coinOutTypeBytes,
+    ...receiverBytes,
+  ];
+  if (extraTransferCoinOut && extraTransferReceiver) {
+    const extraTransferCoinOutBytes = Buffer.from(
+      normalizeStructTag(extraTransferCoinOut).replace("0x", ""),
+      "utf8"
+    );
+    const extraTransferReceiverBytes = fromHex(normalizeSuiAddress(extraTransferReceiver));
+
+    resBytes = [
+      ...resBytes,
+      ...extraTransferCoinOutBytes,
+      ...extraTransferReceiverBytes,
+    ];
+  }
+
+  resBytes = [
+    ...resBytes,
+    ...bcs.u64().serialize(secretNumber).toBytes(),
+  ];
+
+  return keccak256.array(resBytes);
+}
+
+/**
+ * Generates Sui single-chain DCA order transaction
+ * @param order The DCA order to generate transaction for
+ * @param secretHash The secret hash for the order
+ * @param guardAddress The guard contract address
+ * @param client The Sui client instance
+ * @returns Transaction object for creating the DCA order
+ */
+export async function getSuiSingleChainDcaOrderTransaction(
+  order: DcaSingleChainOrder,
+  secretHash: Uint8Array,
+  guardAddress: string,
+  client?: ReturnType<typeof createSuiClient>
+): Promise<Transaction> {
+  const userAddress = order.user;
+  const suiClient = client || createSuiClient();
+  const totalAmountIn = order.getTotalAmountIn();
+  
+  const coins = await suiClient.getCoins({
+    owner: userAddress,
+    coinType: order.tokenIn,
+  });
+
+  const sourceTokenInCoins = coins.data.sort((a, b) => Number(b.balance) - Number(a.balance));
+
+  if (sourceTokenInCoins.length === 0) {
+    throw new ValidationError(`No token (${order.tokenIn}) to create order`);
+  }
+
+  const coinsInSum = sourceTokenInCoins.reduce((acc, coin) => acc + BigInt(coin.balance), 0n);
+
+  if (coinsInSum < totalAmountIn) {
+    throw new ValidationError(
+      `Insufficient balance to create order. Total coins is ${coinsInSum}, but order requires ${totalAmountIn}`,
+    );
+  }
+
+  const spendingGasCoin =
+    normalizeSuiObjectId(order.tokenIn) === normalizeSuiObjectId(NATIVE_SUI_TOKEN_ADDRESS);
+
+  const tx = new Transaction();
+  const coinInArg = spendingGasCoin ? tx.gas : sourceTokenInCoins[0]!.coinObjectId;
+
+  if (sourceTokenInCoins.length > 1) {
+    // Merging coins IN into a single object just in case
+    tx.mergeCoins(
+      // merge into 1st coin object
+      coinInArg,
+      // merge the rest of coins
+      sourceTokenInCoins.slice(1).map((coin) => coin.coinObjectId),
+    );
+  }
+
+  const [coinIn] = tx.splitCoins(coinInArg, [totalAmountIn]);
+
+  // Get extra transfer amount - only first extra transfer is supported on Sui
+  const extraTransferAmount = order.extraTransfers && order.extraTransfers.length > 0 
+    ? BigInt(order.extraTransfers[0]!.amount) 
+    : 0n;
+
+  tx.moveCall({
+    package: SUI_PACKAGE_ID,
+    module: 'single_chain_dca_orders',
+    function: 'create_dca_order',
+    arguments: [
+      tx.object(guardAddress), // arg0: &Guard<T0, T2>
+      coinIn, // arg1: Coin<T1>
+      tx.pure.u64(order.amountInPerInterval), // arg2: amount_in_per_interval
+      tx.pure.u64(order.amountOutMin), // arg3: amount_out_min
+      tx.pure.u64(extraTransferAmount), // arg4: extra_transfer_amount_out_min
+      tx.pure.u64(order.deadline * 1000), // arg5: deadline (converted to milliseconds)
+      tx.pure.u32(order.totalIntervals), // arg6: total_intervals
+      tx.pure.u64(order.intervalDuration * 1000), // arg7: interval_duration (converted to milliseconds)
+      tx.pure.vector('u8', [...secretHash]), // arg8: secret_hash
+      tx.object.clock(), // arg9: &Clock
+    ],
+    typeArguments: [SUI_GUARD_COLLATERAL_TYPE, order.tokenIn, SUI_GUARD_STABLECOIN_TYPE],
+  });
+
+  tx.setSender(userAddress);
+
+  return tx;
+}

package/src/core/sui/single-chain-limit-order.ts

@@ -0,0 +1,143 @@
+import { bcs, fromHex } from '@mysten/bcs';
+import { keccak256 } from "js-sha3";
+import { normalizeStructTag, normalizeSuiAddress, normalizeSuiObjectId } from "@mysten/sui/utils";
+import { Transaction } from '@mysten/sui/transactions';
+import { ValidationError } from '../../errors/index.js';
+import { createSuiClient } from './client.js';
+import { SUI_PACKAGE_ID, SUI_GUARD_COLLATERAL_TYPE, SUI_GUARD_STABLECOIN_TYPE, NATIVE_SUI_TOKEN_ADDRESS } from '../../constants.js';
+import type { SingleChainOrder } from '../orders/single-chain.js';
+
+/**
+ * Generates random U64 number
+ */
+export function getRandomU64Number() {
+  return BigInt("0x" + [...crypto.getRandomValues(new Uint8Array(8))]
+      .map(n => n.toString(16))
+      .join("")).toString();
+}
+
+/**
+ * Generates secret hash based on types, addresses and secret number for single chain limit orders
+ * @param coinOutType Type tag of Coin OUT
+ * @param receiver Main Coins OUT receiver
+ * @param secretNumber Secret number, for hash randomness
+ * @param extraTransferCoinOut Type tag of extra transfer coin OUT
+ * @param extraTransferReceiver Receiver of extra transfer
+ */
+export function getSecretHash(
+  coinOutType: string,
+  receiver: string,
+  secretNumber: string,
+  extraTransferCoinOut?: string,
+  extraTransferReceiver?: string,
+) {
+  const coinOutTypeBytes = Buffer.from(
+    normalizeStructTag(coinOutType).replace("0x", ""),
+    "utf8"
+  );
+  const receiverBytes = fromHex(normalizeSuiAddress(receiver));
+
+  let resBytes = [
+    ...coinOutTypeBytes,
+    ...receiverBytes,
+  ];
+  if (extraTransferCoinOut && extraTransferReceiver) {
+    const extraTransferCoinOutBytes = Buffer.from(
+      normalizeStructTag(extraTransferCoinOut).replace("0x", ""),
+      "utf8"
+    );
+    const extraTransferReceiverBytes = fromHex(normalizeSuiAddress(extraTransferReceiver));
+
+    resBytes = [
+      ...resBytes,
+      ...extraTransferCoinOutBytes,
+      ...extraTransferReceiverBytes,
+    ];
+  }
+
+  resBytes = [
+    ...resBytes,
+    ...bcs.u64().serialize(secretNumber).toBytes(),
+  ];
+
+  return keccak256.array(resBytes);
+}
+
+/**
+ * Generates Sui single-chain limit order transaction
+ * @param order The single-chain order to generate transaction for
+ * @param secretHash The secret hash for the order
+ * @param guardAddress The guard contract address
+ * @param client The Sui client instance
+ * @returns Transaction object for creating the limit order
+ */
+export async function getSuiSingleChainLimitOrderTransaction(
+  order: SingleChainOrder,
+  secretHash: Uint8Array,
+  guardAddress: string,
+  client?: ReturnType<typeof createSuiClient>
+): Promise<Transaction> {
+  const userAddress = order.user;
+  const suiClient = client || createSuiClient();
+  const coins = await suiClient.getCoins({
+    owner: userAddress,
+    coinType: order.tokenIn,
+  });
+
+  const sourceTokenInCoins = coins.data.sort((a, b) => Number(b.balance) - Number(a.balance));
+
+  if (sourceTokenInCoins.length === 0) {
+    throw new ValidationError(`No token (${order.tokenIn}) to create order`);
+  }
+
+  const coinsInSum = sourceTokenInCoins.reduce((acc, coin) => acc + BigInt(coin.balance), 0n);
+
+  if (coinsInSum < order.amountIn) {
+    throw new ValidationError(
+      `Insufficient balance to create order. Total coins is ${coinsInSum}, but order requires ${order.amountIn}`,
+    );
+  }
+
+  const spendingGasCoin =
+    normalizeSuiObjectId(order.tokenIn) === normalizeSuiObjectId(NATIVE_SUI_TOKEN_ADDRESS);
+
+  const tx = new Transaction();
+  const coinInArg = spendingGasCoin ? tx.gas : sourceTokenInCoins[0]!.coinObjectId;
+
+  if (sourceTokenInCoins.length > 1) {
+    // Merging coins IN into a single object just in case
+    tx.mergeCoins(
+      // merge into 1st coin object
+      coinInArg,
+      // merge the rest of coins
+      sourceTokenInCoins.slice(1).map((coin) => coin.coinObjectId),
+    );
+  }
+
+  const [coinIn] = tx.splitCoins(coinInArg, [order.amountIn]);
+
+  // Get extra transfer amount - only first extra transfer is supported on Sui
+  const extraTransferAmount = order.extraTransfers && order.extraTransfers.length > 0 
+    ? BigInt(order.extraTransfers[0]!.amount) 
+    : 0n;
+
+  tx.moveCall({
+    package: SUI_PACKAGE_ID,
+    module: 'single_chain_limit_orders',
+    function: 'create_limit_order',
+    arguments: [
+      tx.object(guardAddress), // arg0: &Guard<T0, T2>
+      coinIn, // arg1: Coin<T1>
+      tx.pure.u64(order.amountOutMin), // arg2: amount_out_min
+      tx.pure.u64(extraTransferAmount), // arg3: extra_transfer_amount_out_min
+      tx.pure.u64(order.deadline * 1000), // arg4: deadline (converted to milliseconds)
+      tx.pure.vector('u8', [...secretHash]), // arg5: secret_hash
+      tx.object.clock(), // arg6: &Clock
+    ],
+    typeArguments: [SUI_GUARD_COLLATERAL_TYPE, order.tokenIn, SUI_GUARD_STABLECOIN_TYPE],
+  });
+
+  tx.setSender(userAddress);
+
+  return tx;
+}

package/src/core/sui/validator.ts

@@ -1,7 +1,6 @@
 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+$/;
 
@@ -36,6 +35,6 @@ export class SuiValidator extends BaseValidator {
   }
 
   override validateDcaSingleChainOrderFeasability(): Promise<void> {
-    throw new ValidationError('DCA orders are not supported on Sui');
+    return Promise.resolve();
   }
 }

package/src/index.ts

@@ -1,3 +1,5 @@
+export { DcaSingleChainOrder, type CreateDcaSingleChainOrderParams } from './core/orders/dca-single-chain.js';
+
 export { ChainID, ChainType, SupportedChains, isSupportedChain, chainIdToChainTypeMap, isEvmChain } from './chains.js';
 export type { SupportedEvmChain, SupportedChain } from './chains.js';
 
@@ -47,8 +49,61 @@ export {
 } from './core/solana/cancel-order.js';
 export { getSuiOrderTransaction } from './core/sui/order-transaction.js';
 export { getSuiCancelCrossChainOrder } from './core/sui/cancel.js';
+export { getDcaSecretHash, getSuiSingleChainDcaOrderTransaction } from './core/sui/single-chain-dca-order.js';
+export { getSecretHash, getRandomU64Number as getSuiRandomU64Number, getSuiSingleChainLimitOrderTransaction } from './core/sui/single-chain-limit-order.js';
+export { generateExecutionDetailsHash } from './core/sui/cross-chain-limit-order.js';
+export {
+  createSuiSingleChainLimitOrderIntentRequest,
+  createSuiSingleChainDcaOrderIntentRequest,
+  createSuiCrossChainOrderIntentRequest,
+  generateSuiLimitOrderSecretData,
+  generateSuiDcaOrderSecretData,
+  type CreateSuiSingleChainLimitOrderIntentParams,
+  type CreateSuiSingleChainDcaOrderIntentParams,
+  type CreateSuiCrossChainOrderIntentParams,
+} from './core/sui/intent-helpers.js';
+
+export * from './constants.js'
+
+export { getSolanaDcaSingleChainOrderInstructions } from './core/solana/dca/create-order.js';
+
+export { signSingleChainDcaOrder } from './core/evm/single-chain-dca-order.js';
+export { signSingleChainLimitOrder } from './core/evm/single-chain-limit-order.js';
 
 export { QuoteProvider } from './utils/quote/aggregator.js';
 export type { QuoteResponse } from './utils/quote/aggregator.js';
 
 export { CROSS_CHAIN_GUARD_ADDRESSES, SINGLE_CHAIN_GUARD_ADDRESSES, PERMIT2_ADDRESS } from './constants.js';
+
+export { prepareDcaSecretData, } from './core/solana/dca/single-chain-dca-order.js'
+export { prepareSecretData } from './core/solana/dca/single-chain-limit-order.js'
+
+// EVM Intent Helpers
+export {
+  createEvmSingleChainLimitOrderIntentRequest,
+  createEvmSingleChainDcaOrderIntentRequest,
+  createEvmCrossChainOrderIntentRequest,
+  generateEvmSingleChainLimitOrderTypedData,
+  generateEvmSingleChainDcaOrderTypedData,
+  generateEvmCrossChainOrderTypedData,
+  generateEvmRandomNonce,
+  type CreateEvmSingleChainLimitOrderIntentParams,
+  type CreateEvmSingleChainDcaOrderIntentParams,
+  type CreateEvmCrossChainOrderIntentParams,
+} from './core/evm/intent-helpers.js';
+
+// Solana Intent Helpers
+export {
+  createSolanaSingleChainLimitOrderIntentRequest,
+  createSolanaSingleChainDcaOrderIntentRequest,
+  createSolanaCrossChainOrderIntentRequest,
+  generateSolanaSingleChainLimitOrderInstructions,
+  generateSolanaSingleChainDcaOrderInstructions,
+  generateSolanaCrossChainOrderInstructions,
+  generateSolanaLimitOrderSecretData,
+  generateSolanaDcaOrderSecretData,
+  generateSolanaRandomSecretNumber,
+  type CreateSolanaSingleChainLimitOrderIntentParams,
+  type CreateSolanaSingleChainDcaOrderIntentParams,
+  type CreateSolanaCrossChainOrderIntentParams,
+} from './core/solana/intent-helpers.js';

package/src/types/intent.ts

@@ -35,11 +35,15 @@ export type EvmPreparedData = {
 export type SuiPreparedData = {
   /** Transaction hash of the successful order creation transaction */
   transactionHash: string;
+  /** Secret number for single-chain orders (optional for cross-chain) */
+  secretNumber?: string;
 };
 
 export type SolanaPreparedData = {
   /** Public key of the created order account on Solana */
   orderPubkey: string;
+  /** Secret number for single-chain orders (optional for cross-chain) */
+  secretNumber?: string;
 };
 
 /**
@@ -78,8 +82,9 @@ export type CrossChainUserIntentRequest = {
     /** Solana-specific data */
     Solana?: SolanaPreparedData;
     /** Sui-specific data */
-    Sui?: SolanaPreparedData;
+    Sui?: SuiPreparedData;
   };
+  
 };
 
 export type SingleChainUserIntentRequest = {
@@ -87,7 +92,7 @@ export type SingleChainUserIntentRequest = {
   chainSpecificData: {
     EVM?: EvmPreparedData;
     Solana?: SolanaPreparedData;
-    Sui?: SolanaPreparedData;
+    Sui?: SuiPreparedData;
   };
 };
 
@@ -110,6 +115,7 @@ export type SingleChainSolanaPreparedData = {
 
 export type SingleChainSuiPreparedData = {
   transactionHash: string;
+  secretNumber: string;
 };
 
 export type SingleChainPreparedData =
@@ -122,12 +128,17 @@ export type SingleChainOrderPrepared = {
   preparedData: SingleChainPreparedData;
 };
 
+export type DcaSingleChainSuiPreparedData = {
+  transactionHash: string;
+  secretNumber: string;
+};
+
 export type DcaSingleChainUserIntentRequest = {
   genericData: DcaSingleChainOrder;
   chainSpecificData: {
     EVM?: DcaSingleChainEVMPreparedData;
     Solana?: DcaSingleChainSolanaPreparedData;
-    Sui?: never; // DCA not supported on Sui
+    Sui?: DcaSingleChainSuiPreparedData; // DCA is now supported on Sui
   };
 };
 
@@ -141,7 +152,7 @@ export type DcaSingleChainSolanaPreparedData = {
   orderPubkey: string;
 };
 
-export type DcaSingleChainPreparedData = DcaSingleChainEVMPreparedData | DcaSingleChainSolanaPreparedData;
+export type DcaSingleChainPreparedData = DcaSingleChainEVMPreparedData | DcaSingleChainSolanaPreparedData | DcaSingleChainSuiPreparedData;
 
 export type DcaSingleChainOrderPrepared = {
   order: DcaSingleChainOrder;