@shogun-sdk/intents-sdk 1.2.1 → 1.2.3

package/src/core/evm/cross-chain-limit-order.ts

@@ -0,0 +1,76 @@
+import { ethers, type TypedDataField, type AddressLike, type BigNumberish } from "ethers";
+import { SignatureTransfer } from "@uniswap/permit2-sdk";
+
+export const OrderInfoType: Record<string, TypedDataField[]> = {
+  OrderInfo: [
+    { name: "user", type: "address" },
+    { name: "tokenIn", type: "address" },
+    { name: "srcChainId", type: "uint32" },
+    { name: "deadline", type: "uint32" },
+    { name: "amountIn", type: "uint128" },
+    { name: "minStablecoinsAmount", type: "uint128" },
+    { name: "executionDetailsHash", type: "bytes32" },
+    { name: "nonce", type: "uint256" },
+  ],
+};
+
+export type OrderInfoStruct = {
+  user: AddressLike;
+  tokenIn: AddressLike;
+  srcChainId: BigNumberish;
+  deadline: BigNumberish;
+  amountIn: BigNumberish;
+  minStablecoinsAmount: BigNumberish;
+  executionDetailsHash: string;
+  nonce: BigNumberish;
+};
+
+/**
+ * Signs Permit2 struct with OrderInfo
+ */
+export async function signCrossChainLimitOrder(
+  signer: ethers.Wallet,
+  orderInfo: OrderInfoStruct,
+  chainId: number,
+  guardAddress: string,
+  permit2Address: string
+): Promise<{
+  domain: any;
+  types: any;
+  values: any;
+  signature: string;
+}> {
+  const permitData = SignatureTransfer.getPermitData(
+    {
+      permitted: {
+        token: orderInfo.tokenIn.toString(),
+        amount: orderInfo.amountIn,
+      },
+      spender: guardAddress,
+      nonce: orderInfo.nonce,
+      deadline: orderInfo.deadline,
+    },
+    permit2Address,
+    chainId,
+    {
+      witness: orderInfo,
+      witnessTypeName: "OrderInfo",
+      witnessType: OrderInfoType,
+    }
+  );
+
+  return {
+    domain: permitData.domain,
+    types: permitData.types,
+    values: permitData.values,
+    signature: await signer.signTypedData(
+      {
+        name: permitData.domain.name,
+        chainId: Number(permitData.domain.chainId),
+        verifyingContract: permitData.domain.verifyingContract,
+      },
+      permitData.types,
+      permitData.values
+    ),
+  };
+}

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

@@ -0,0 +1,204 @@
+import type { SupportedEvmChain } from '../../chains.js';
+import type { SingleChainUserIntentRequest, CrossChainUserIntentRequest, DcaSingleChainUserIntentRequest } from '../../types/intent.js';
+import type { SingleChainOrder } from '../orders/single-chain.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
+import type { ExtraTransfer } from '../orders/common.js';
+import { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData, getEVMDcaSingleChainOrderTypedData } from './order-signature.js';
+
+export type CreateEvmSingleChainLimitOrderIntentParams = {
+  user: `0x${string}`;
+  chainId: SupportedEvmChain;
+  tokenIn: string;
+  tokenOut: string;
+  amountIn: bigint;
+  amountOutMin: bigint;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  nonce?: string;
+  signature?: string;
+  stopLossMaxOut?: bigint;
+  takeProfitMinOut?: bigint;
+};
+
+export type CreateEvmSingleChainDcaOrderIntentParams = {
+  user: `0x${string}`;
+  chainId: SupportedEvmChain;
+  tokenIn: string;
+  tokenOut: string;
+  amountInPerInterval: bigint;
+  totalIntervals: number;
+  intervalDuration: number;
+  amountOutMin: bigint;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  startTime: number;
+  nonce?: string;
+  signature?: string;
+};
+
+export type CreateEvmCrossChainOrderIntentParams = {
+  user: `0x${string}`;
+  sourceChainId: SupportedEvmChain;
+  sourceTokenAddress: string;
+  sourceTokenAmount: bigint;
+  destinationChainId: number;
+  destinationTokenAddress: string;
+  destinationTokenMinAmount?: bigint;
+  destinationAddress: string;
+  minStablecoinAmount?: bigint;
+  deadline: number;
+  extraTransfers?: ExtraTransfer[];
+  nonce?: string;
+  signature?: string;
+  stopLossMaxOut?: bigint;
+  takeProfitMinOut?: bigint;
+};
+
+/**
+ * Creates an EVM single-chain limit order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+export function createEvmSingleChainLimitOrderIntentRequest(
+  params: CreateEvmSingleChainLimitOrderIntentParams
+): SingleChainUserIntentRequest {
+  const order: SingleChainOrder = {
+    user: params.user,
+    chainId: params.chainId,
+    amountIn: params.amountIn,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    amountOutMin: params.amountOutMin,
+    destinationAddress: params.destinationAddress,
+    extraTransfers: params.extraTransfers,
+    deadline: params.deadline,
+    stopLossMaxOut: params.stopLossMaxOut,
+    takeProfitMinOut: params.takeProfitMinOut,
+  } as SingleChainOrder;
+
+  return {
+    genericData: order,
+    chainSpecificData: {
+      EVM: {
+        nonce: params.nonce || String(Math.floor(Math.random() * 10000000)),
+        signature: params.signature || '0x0000000000000000000000000000000000000000000000000000000000000000',
+      },
+    },
+  };
+}
+
+/**
+ * Creates an EVM single-chain DCA order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+export function createEvmSingleChainDcaOrderIntentRequest(
+  params: CreateEvmSingleChainDcaOrderIntentParams
+): DcaSingleChainUserIntentRequest {
+  const order: DcaSingleChainOrder = {
+    user: params.user,
+    chainId: params.chainId,
+    tokenIn: params.tokenIn,
+    tokenOut: params.tokenOut,
+    destinationAddress: params.destinationAddress,
+    startTime: params.startTime,
+    amountInPerInterval: params.amountInPerInterval,
+    totalIntervals: params.totalIntervals,
+    intervalDuration: params.intervalDuration,
+    amountOutMin: params.amountOutMin,
+    extraTransfers: params.extraTransfers,
+    deadline: params.deadline,
+  } as DcaSingleChainOrder;
+
+  return {
+    genericData: order,
+    chainSpecificData: {
+      EVM: {
+        nonce: params.nonce || String(Math.floor(Math.random() * 10000000)),
+        signature: params.signature || '0x0000000000000000000000000000000000000000000000000000000000000000',
+      },
+    },
+  };
+}
+
+/**
+ * Creates an EVM cross-chain order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+export function createEvmCrossChainOrderIntentRequest(
+  params: CreateEvmCrossChainOrderIntentParams
+): CrossChainUserIntentRequest {
+  const executionDetails = JSON.stringify({
+    destChainId: params.destinationChainId,
+    tokenOut: params.destinationTokenAddress,
+    amountOutMin: params.destinationTokenMinAmount || 1n,
+    destinationAddress: params.destinationAddress,
+    extraTransfers: params.extraTransfers,
+  });
+
+  // Calculate execution details hash
+  const executionDetailsHash = `0x${require('crypto').createHash('sha256').update(executionDetails).digest('hex')}` as `0x${string}`;
+
+  const genericData = {
+    user: params.user,
+    srcChainId: params.sourceChainId,
+    tokenIn: params.sourceTokenAddress,
+    amountIn: params.sourceTokenAmount,
+    minStablecoinsAmount: params.minStablecoinAmount || 1n,
+    deadline: params.deadline,
+    executionDetailsHash,
+    extraTransfers: params.extraTransfers,
+    stopLossMaxOut: params.stopLossMaxOut,
+    takeProfitMinOut: params.takeProfitMinOut,
+  };
+
+  return {
+    genericData,
+    executionDetails,
+    chainSpecificData: {
+      EVM: {
+        nonce: params.nonce || String(Math.floor(Math.random() * 10000000)),
+        signature: params.signature || '0x0000000000000000000000000000000000000000000000000000000000000000',
+      },
+    },
+  };
+}
+
+/**
+ * Generates EVM typed data and nonce for single-chain limit orders
+ * @param order The single-chain order
+ * @returns Object containing typed data and nonce for signing
+ */
+export async function generateEvmSingleChainLimitOrderTypedData(order: SingleChainOrder) {
+  return getEVMSingleChainOrderTypedData(order);
+}
+
+/**
+ * Generates EVM typed data and nonce for single-chain DCA orders
+ * @param order The DCA order
+ * @returns Object containing typed data and nonce for signing
+ */
+export async function generateEvmSingleChainDcaOrderTypedData(order: DcaSingleChainOrder) {
+  return getEVMDcaSingleChainOrderTypedData(order);
+}
+
+/**
+ * Generates EVM typed data and nonce for cross-chain orders
+ * @param order The cross-chain order
+ * @returns Object containing typed data and nonce for signing
+ */
+export async function generateEvmCrossChainOrderTypedData(order: CrossChainOrder) {
+  return getEVMCrossChainOrderTypedData(order);
+}
+
+/**
+ * Generates a random nonce for EVM orders
+ * @returns Random nonce as string
+ */
+export function generateEvmRandomNonce(): string {
+  return String(Math.floor(Math.random() * 10000000));
+}

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

@@ -0,0 +1,85 @@
+import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from "ethers";
+import { SignatureTransfer } from "@uniswap/permit2-sdk";
+import { TransferDataType, type TransferDataStruct } from "./types.js";
+
+export const SingleChainDcaOrderType: Record<string, TypedDataField[]> = {
+  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" },
+  ],
+  TransferData: TransferDataType.TransferData!,
+};
+
+export type SingleChainDcaOrderStruct = {
+  user: AddressLike;
+  tokenIn: AddressLike;
+  startTime: BigNumberish;
+  amountInPerInterval: BigNumberish;
+  totalIntervals: BigNumberish;
+  intervalDuration: BigNumberish;
+  requestedOutput: TransferDataStruct;
+  extraTransfers: TransferDataStruct[];
+  encodedExternalCallData: BytesLike;
+  deadline: BigNumberish;
+  nonce: BigNumberish;
+};
+
+/**
+ * Signs Permit2 struct with SingleChainDcaOrder
+ */
+export async function signSingleChainDcaOrder(
+  signer: ethers.Wallet,
+  order: SingleChainDcaOrderStruct,
+  chainId: number,
+  guardAddress: string,
+  permit2Address: string
+): Promise<{
+  domain: any;
+  types: any;
+  values: any;
+  signature: string;
+}> {
+  const amountIn = BigInt(order.totalIntervals) * BigInt(order.amountInPerInterval);
+  const permitData = SignatureTransfer.getPermitData(
+    {
+      permitted: {
+        token: order.tokenIn.toString(),
+        amount: amountIn,
+      },
+      spender: guardAddress,
+      nonce: order.nonce,
+      deadline: order.deadline,
+    },
+    permit2Address,
+    chainId,
+    {
+      witness: order,
+      witnessTypeName: "SingleChainDcaOrder",
+      witnessType: SingleChainDcaOrderType,
+    }
+  );
+
+  return {
+    domain: permitData.domain,
+    types: permitData.types,
+    values: permitData.values,
+    signature: await signer.signTypedData(
+      {
+        name: permitData.domain.name,
+        chainId: Number(permitData.domain.chainId),
+        verifyingContract: permitData.domain.verifyingContract,
+      },
+      permitData.types,
+      permitData.values
+    ),
+  };
+}

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

@@ -0,0 +1,78 @@
+import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from "ethers";
+import { SignatureTransfer } from "@uniswap/permit2-sdk";
+import { TransferDataType, type TransferDataStruct } from "./types.js";
+
+export const SingleChainLimitOrderType: Record<string, TypedDataField[]> = {
+  SingleChainLimitOrder: [
+    { type: "address", name: "user" },
+    { type: "address", name: "tokenIn" },
+    { type: "uint256", name: "amountIn" },
+    { type: "TransferData", name: "requestedOutput" },
+    { type: "TransferData[]", name: "extraTransfers" },
+    { type: "bytes", name: "encodedExternalCallData" },
+    { type: "uint32", name: "deadline" },
+    { type: "uint256", name: "nonce" },
+  ],
+  TransferData: TransferDataType.TransferData!,
+};
+
+export type SingleChainLimitOrderStruct = {
+  user: AddressLike;
+  tokenIn: AddressLike;
+  amountIn: BigNumberish;
+  requestedOutput: TransferDataStruct;
+  extraTransfers: TransferDataStruct[];
+  encodedExternalCallData: BytesLike;
+  deadline: BigNumberish;
+  nonce: BigNumberish;
+};
+
+/**
+ * Signs Permit2 struct with SingleChainLimitOrder
+ */
+export async function signSingleChainLimitOrder(
+  signer: ethers.Wallet,
+  order: SingleChainLimitOrderStruct,
+  chainId: number,
+  guardAddress: string,
+  permit2Address: string
+): Promise<{
+  domain: any;
+  types: any;
+  values: any;
+  signature: string;
+}> {
+  const permitData = SignatureTransfer.getPermitData(
+    {
+      permitted: {
+        token: order.tokenIn.toString(),
+        amount: order.amountIn,
+      },
+      spender: guardAddress,
+      nonce: order.nonce,
+      deadline: order.deadline,
+    },
+    permit2Address,
+    chainId,
+    {
+      witness: order,
+      witnessTypeName: "SingleChainLimitOrder",
+      witnessType: SingleChainLimitOrderType,
+    }
+  );
+
+  return {
+    domain: permitData.domain,
+    types: permitData.types,
+    values: permitData.values,
+    signature: await signer.signTypedData(
+      {
+        name: permitData.domain.name,
+        chainId: Number(permitData.domain.chainId),
+        verifyingContract: permitData.domain.verifyingContract,
+      },
+      permitData.types,
+      permitData.values
+    ),
+  };
+}

package/src/core/evm/types.ts

@@ -0,0 +1,15 @@
+import type { AddressLike, BigNumberish, TypedDataField } from "ethers";
+
+export const TransferDataType: Record<string, TypedDataField[]> = {
+  TransferData: [
+    { type: "address", name: "token" },
+    { type: "address", name: "receiver" },
+    { type: "uint256", name: "amount" },
+  ],
+};
+
+export type TransferDataStruct = {
+  token: AddressLike;
+  receiver: AddressLike;
+  amount: BigNumberish;
+};

package/src/core/orders/common.ts

@@ -1,4 +1,4 @@
-import { OrderType } from '../../constants.js';
+import { IntentsOrderType } from '../../constants.js';
 import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
 
 export type ExtraTransfer = {
@@ -10,10 +10,10 @@ export type ExtraTransfer = {
   amount: bigint;
 };
 
-export function getOrderType(order: SingleChainOrderPrepared | CrossChainOrderPrepared): OrderType {
+export function getOrderType(order: SingleChainOrderPrepared | CrossChainOrderPrepared): IntentsOrderType {
   if ('tokenIn' in order.order) {
-    return OrderType.SINGLE_CHAIN_LIMIT;
+    return IntentsOrderType.SINGLE_CHAIN_LIMIT;
   }
 
-  return OrderType.CROSS_CHAIN_LIMIT;
+  return IntentsOrderType.CROSS_CHAIN_LIMIT;
 }

package/src/core/orders/cross-chain.ts

@@ -317,11 +317,11 @@ export class CrossChainOrder {
     return getSolanaCrossChainOrderInstructions(this);
   }
 
-  public async toSuiTransaction() {
+  public async toSuiTransaction(client?: any) {
     if (this.sourceChainId !== ChainID.Sui) {
       throw new ValidationError('Source chain is not Sui');
     }
 
-    return getSuiOrderTransaction(this);
+    return getSuiOrderTransaction(this, client);
   }
 }

package/src/core/orders/dca-single-chain.ts

@@ -94,7 +94,10 @@ export class DcaSingleChainOrder {
         };
       }
       case 'Sui': {
-        throw new ValidationError('DCA orders are not supported on Sui');
+        return {
+          secretNumber: randomNumber,
+          transactionHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        };
       }
 
       default: {

package/src/core/orders/single-chain.ts

@@ -94,7 +94,7 @@ export class SingleChainOrder {
       }
       case 'Sui': {
         const digest = 'FQWndwYJhNQUoHyvR8UuhGURC2EKx9eWErFm9Tc2DggF';
-        return { transactionHash: digest };
+        return { transactionHash: digest, secretNumber: randomNumber };
       }
 
       default: {
@@ -178,4 +178,13 @@ export class SingleChainOrder {
 
     return getSolanaSingleChainOrderInstructions(this);
   }
+
+  public async toSuiTransaction(secretHash: Uint8Array, guardAddress: string, client?: any) {
+    if (this.chainId !== ChainID.Sui) {
+      throw new ValidationError('Chain id is not Sui');
+    }
+
+    const { getSuiSingleChainLimitOrderTransaction } = await import('../sui/single-chain-limit-order.js');
+    return getSuiSingleChainLimitOrderTransaction(this, secretHash, guardAddress, client);
+  }
 }

package/src/core/solana/cancel-order.ts

@@ -13,7 +13,7 @@ import {
   setTransactionMessageFeePayerSigner,
   setTransactionMessageLifetimeUsingBlockhash,
   type Address,
-  type IInstruction,
+  type Instruction,
   type ReadonlyUint8Array,
   type TransactionMessageBytes,
 } from '@solana/kit';
@@ -31,7 +31,7 @@ import { fetchMaybeOrder, getCancelOrderInstruction } from './generated/cross-ch
 export async function cancelSingleChainOrderInstructions(
   orderAddress: string,
   options?: { rpcUrl?: string },
-): Promise<IInstruction[]> {
+): Promise<Instruction[]> {
   const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
 
   const orderId = address(orderAddress);
@@ -41,7 +41,7 @@ export async function cancelSingleChainOrderInstructions(
     throw new Error(`Order with address ${orderAddress} not found`);
   }
 
-  const instructions: IInstruction[] = [];
+  const instructions: Instruction[] = [];
   const orderUserAddress = chainOrder.data.user;
 
   const tokenInMint = chainOrder.data.tokenInMint;
@@ -149,7 +149,7 @@ export async function cancelSingleChainOrderInstructionsAsBytes(
 export async function cancelCrossChainOrderInstructions(
   orderAddress: string,
   options?: { rpcUrl?: string },
-): Promise<IInstruction[]> {
+): Promise<Instruction[]> {
   const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
   const orderId = address(orderAddress);
 
@@ -158,7 +158,7 @@ export async function cancelCrossChainOrderInstructions(
     throw new Error(`Order with address ${orderAddress} not found`);
   }
 
-  const instructions: IInstruction[] = [];
+  const instructions: Instruction[] = [];
   const orderUserAddress = chainOrder.data.user;
   const guardAddress = CROSS_CHAIN_GUARD_ADDRESSES[ChainID.Solana] as Address;
   const addressEncoder = getAddressEncoder();

package/src/core/solana/client.ts

@@ -5,7 +5,7 @@ import {
   type RpcSubscriptions,
   type SolanaRpcApiMainnet,
   type SolanaRpcSubscriptionsApi,
-  sendAndConfirmTransactionFactory,
+  sendAndConfirmTransactionFactory
 } from '@solana/kit';
 import type { SolanaConfig } from '../../config.js';
 

package/src/core/solana/cross-chain-limit-order.ts

@@ -0,0 +1,24 @@
+import { createHash } from "crypto";
+
+/**
+ * Generate execution details hash for cross-chain orders
+ * @param destChainId Destination chain ID
+ * @param destinationAddress Destination address on target chain
+ * @param tokenOut Token address on destination chain
+ * @param amountOutMin Minimum amount out
+ */
+export function generateExecutionDetailsHash(
+  destChainId: number,
+  destinationAddress: string,
+  tokenOut: string,
+  amountOutMin: string,
+): Uint8Array {
+  const executionDetails = JSON.stringify({
+    destChainId,
+    destinationAddress,
+    tokenOut,
+    amountOutMin,
+  });
+  
+  return new Uint8Array(createHash('sha256').update(executionDetails).digest());
+}

package/src/core/solana/dca/cancel-order.ts

@@ -6,7 +6,7 @@ import {
   getAddressEncoder,
   getProgramDerivedAddress,
   type Address,
-  type IInstruction,
+  type Instruction,
 } from '@solana/kit';
 import { getDefaultSolanaRPC } from '../client.js';
 import { fetchMaybeDcaOrder, getCancelDcaOrderInstruction } from '../generated/single-chain/index.js';
@@ -21,7 +21,7 @@ import { ChainID } from '../../../chains.js';
 export async function cancelDcaSingleChainOrderInstructions(
   orderAddress: string,
   options?: { rpcUrl?: string },
-): Promise<IInstruction[]> {
+): Promise<Instruction[]> {
   const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
 
   const orderId = address(orderAddress);
@@ -31,7 +31,7 @@ export async function cancelDcaSingleChainOrderInstructions(
     throw new Error(`Order with address ${orderAddress} not found`);
   }
 
-  const instructions: IInstruction[] = [];
+  const instructions: Instruction[] = [];
   const orderUserAddress = chainOrder.data.user;
 
   const tokenInMint = chainOrder.data.tokenInMint;

package/src/core/solana/dca/create-order.ts

@@ -15,7 +15,7 @@ import {
   setTransactionMessageFeePayerSigner,
   setTransactionMessageLifetimeUsingBlockhash,
   type Address,
-  type IInstruction,
+  type Instruction,
 } from '@solana/kit';
 import type { DcaSingleChainOrder } from '../../orders/dca-single-chain.js';
 import type { SolanaOrderInstructionResult } from '../order-instructions.js';
@@ -59,7 +59,7 @@ export async function getSolanaDcaSingleChainOrderInstructions(
 
   const guardAddress = address(SINGLE_CHAIN_GUARD_ADDRESSES[ChainID.Solana]); // Assuming DCA uses same guard
   const addressEncoder = getAddressEncoder();
-  const instructions: Array<IInstruction> = [];
+  const instructions: Array<Instruction> = [];
 
   const [tokenInProgramAccount] = await getProgramDerivedAddress({
     programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,

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

@@ -0,0 +1,32 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { keccak256 } from "js-sha3";
+import type { ExtraTransfer } from "./single-chain-limit-order.js";
+
+/**
+ * Generate secret number and prepare secret hash for single chain DCA orders
+ * @param tokenOut Token OUT Pubkey
+ * @param receiver Token OUT receiver Pubkey
+ * @param extraTransfers Requested extra transfers
+ */
+export function prepareDcaSecretData(
+  tokenOut: PublicKey,
+  receiver: PublicKey,
+  extraTransfers: ExtraTransfer[],
+) {
+  const secretNumber = new BN(crypto.getRandomValues(new Uint8Array(8)));
+  const secretHash = [...Uint8Array.from(Buffer.from(
+    keccak256([
+      ...tokenOut.toBuffer(),
+      ...receiver.toBuffer(),
+      ...Buffer.concat(extraTransfers.map(t => Buffer.concat([
+        t.token.toBuffer(),
+        t.receiver.toBuffer(),
+      ]))),
+      ...secretNumber.toBuffer('le', 8),
+    ]),
+    'hex'
+  ))];
+
+  return { secretHash, secretNumber };
+}