@shogun-sdk/intents-sdk 1.2.0 → 1.2.2

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

@@ -0,0 +1,273 @@
+import { ChainID } 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 { getSolanaCrossChainOrderInstructions, getSolanaSingleChainOrderInstructions } from './order-instructions.js';
+import { getSolanaDcaSingleChainOrderInstructions } from './dca/create-order.js';
+import { prepareDcaSecretData } from './dca/single-chain-dca-order.js';
+import { prepareSecretData } from './dca/single-chain-limit-order.js';
+
+export type CreateSolanaSingleChainLimitOrderIntentParams = {
+  user: string;
+  tokenIn: string;
+  tokenOut: string;
+  amountIn: bigint;
+  amountOutMin: bigint;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  orderPubkey?: string;
+  secretNumber?: string;
+  stopLossMaxOut?: bigint;
+  takeProfitMinOut?: bigint;
+};
+
+export type CreateSolanaSingleChainDcaOrderIntentParams = {
+  user: string;
+  tokenIn: string;
+  tokenOut: string;
+  amountInPerInterval: bigint;
+  totalIntervals: number;
+  intervalDuration: number;
+  amountOutMin: bigint;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  startTime: number;
+  orderPubkey?: string;
+  secretNumber?: string;
+};
+
+export type CreateSolanaCrossChainOrderIntentParams = {
+  user: string;
+  sourceChainId: number;
+  sourceTokenAddress: string;
+  sourceTokenAmount: bigint;
+  destinationChainId: number;
+  destinationTokenAddress: string;
+  destinationTokenMinAmount?: bigint;
+  destinationAddress: string;
+  minStablecoinAmount?: bigint;
+  deadline: number;
+  extraTransfers?: ExtraTransfer[];
+  orderPubkey?: string;
+  stopLossMaxOut?: bigint;
+  takeProfitMinOut?: bigint;
+};
+
+/**
+ * Creates a Solana 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 createSolanaSingleChainLimitOrderIntentRequest(
+  params: CreateSolanaSingleChainLimitOrderIntentParams
+): SingleChainUserIntentRequest {
+  const secretNumber = params.secretNumber || generateSolanaRandomSecretNumber();
+  
+  const order: SingleChainOrder = {
+    user: params.user,
+    chainId: ChainID.Solana,
+    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: {
+      Solana: {
+        secretNumber,
+        orderPubkey: params.orderPubkey || 'DFNAjFAvS4GF98Tp1kiyLvEHM3wjGXibCfF86nnmhuVc',
+      },
+    },
+  };
+}
+
+/**
+ * Creates a Solana 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 createSolanaSingleChainDcaOrderIntentRequest(
+  params: CreateSolanaSingleChainDcaOrderIntentParams
+): DcaSingleChainUserIntentRequest {
+  const secretNumber = params.secretNumber || generateSolanaRandomSecretNumber();
+  
+  const order: DcaSingleChainOrder = {
+    user: params.user,
+    chainId: ChainID.Solana,
+    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: {
+      Solana: {
+        secretNumber,
+        orderPubkey: params.orderPubkey || 'DFNAjFAvS4GF98Tp1kiyLvEHM3wjGXibCfF86nnmhuVc',
+      },
+    },
+  };
+}
+
+/**
+ * Creates a Solana cross-chain order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+export function createSolanaCrossChainOrderIntentRequest(
+  params: CreateSolanaCrossChainOrderIntentParams
+): 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: {
+      Solana: {
+        orderPubkey: params.orderPubkey || 'DFNAjFAvS4GF98Tp1kiyLvEHM3wjGXibCfF86nnmhuVc',
+      },
+    },
+  };
+}
+
+/**
+ * Generates instruction bytes for Solana single-chain limit orders
+ * @param order The single-chain order
+ * @returns Promise resolving to instruction bytes
+ */
+export async function generateSolanaSingleChainLimitOrderInstructions(order: SingleChainOrder) {
+  return getSolanaSingleChainOrderInstructions(order);
+}
+
+/**
+ * Generates instruction bytes for Solana single-chain DCA orders
+ * @param order The DCA order
+ * @returns Promise resolving to instruction bytes
+ */
+export async function generateSolanaSingleChainDcaOrderInstructions(order: DcaSingleChainOrder) {
+  return getSolanaDcaSingleChainOrderInstructions(order);
+}
+
+/**
+ * Generates instruction bytes for Solana cross-chain orders
+ * @param order The cross-chain order
+ * @returns Promise resolving to instruction bytes
+ */
+export async function generateSolanaCrossChainOrderInstructions(order: CrossChainOrder) {
+  return getSolanaCrossChainOrderInstructions(order);
+}
+
+/**
+ * Generates secret data for Solana single-chain limit orders
+ * @param tokenOut Output token mint address
+ * @param receiver Receiver public key
+ * @param secretNumber Secret number (optional, generates random if not provided)
+ * @param extraTransfers Extra transfers array
+ * @returns Object containing secret number and prepared secret data
+ */
+export function generateSolanaLimitOrderSecretData(
+  tokenOut: string,
+  receiver: string,
+  secretNumber?: string,
+  extraTransfers?: ExtraTransfer[]
+): { secretNumber: string; secretData: any } {
+  const secret = secretNumber || generateSolanaRandomSecretNumber();
+  
+  const { PublicKey } = require('@solana/web3.js');
+  const secretData = prepareSecretData(
+    new PublicKey(tokenOut),
+    new PublicKey(receiver),
+    extraTransfers?.map(t => ({
+      token: new PublicKey(t.token),
+      receiver: new PublicKey(t.receiver),
+      amount: t.amount.toString(),
+    })) || []
+  );
+
+  return {
+    secretNumber: secret,
+    secretData,
+  };
+}
+
+/**
+ * Generates secret data for Solana single-chain DCA orders
+ * @param tokenOut Output token mint address
+ * @param receiver Receiver public key
+ * @param secretNumber Secret number (optional, generates random if not provided)
+ * @param extraTransfers Extra transfers array
+ * @returns Object containing secret number and prepared secret data
+ */
+export function generateSolanaDcaOrderSecretData(
+  tokenOut: string,
+  receiver: string,
+  secretNumber?: string,
+  extraTransfers?: ExtraTransfer[]
+): { secretNumber: string; secretData: any } {
+  const secret = secretNumber || generateSolanaRandomSecretNumber();
+  
+  const { PublicKey } = require('@solana/web3.js');
+  const secretData = prepareDcaSecretData(
+    new PublicKey(tokenOut),
+    new PublicKey(receiver),
+    extraTransfers?.map(t => ({
+      token: new PublicKey(t.token),
+      receiver: new PublicKey(t.receiver),
+      amount: t.amount.toString(),
+    })) || []
+  );
+
+  return {
+    secretNumber: secret,
+    secretData,
+  };
+}
+
+/**
+ * Generates a random secret number for Solana orders
+ * @returns Random secret number as string
+ */
+export function generateSolanaRandomSecretNumber(): string {
+  return String(Math.floor(Math.random() * 10000000));
+}

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

@@ -18,7 +18,7 @@ import {
   getAddressEncoder,
   getProgramDerivedAddress,
   getTransactionCodec,
-  type IInstruction,
+  type Instruction,
   partiallySignTransactionMessageWithSigners,
   pipe,
   type ReadonlyUint8Array,
@@ -69,7 +69,7 @@ export async function getSolanaSingleChainOrderInstructions(
 
   const guardAddress = address(SINGLE_CHAIN_GUARD_ADDRESSES[ChainID.Solana]);
   const addressEncoder = getAddressEncoder();
-  const instructions: Array<IInstruction> = [];
+  const instructions: Array<Instruction> = [];
 
   const [tokenInProgramAccount] = await getProgramDerivedAddress({
     programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
@@ -191,7 +191,7 @@ export async function getSolanaCrossChainOrderInstructions(
     ],
   });
 
-  const instructions: Array<IInstruction> = [];
+  const instructions: Array<Instruction> = [];
 
   const userTokenInAccount = await fetchEncodedAccount(rpc, tokenInProgramAccount);
 

package/src/core/solana/sdk.ts

@@ -12,10 +12,13 @@ import {
   getTransactionCodec,
   type KeyPairSigner,
   partiallySignTransaction,
+  signTransaction,
   pipe,
   setTransactionMessageFeePayerSigner,
   setTransactionMessageLifetimeUsingBlockhash,
-  signTransaction,
+  type Transaction,
+  type TransactionWithLifetime,
+  assertIsSendableTransaction,
 } from '@solana/kit';
 import type { SolanaConfig } from '../../config.js';
 import { BaseSDK } from '../sdk.js';
@@ -95,6 +98,8 @@ export class SolanaSDK extends BaseSDK {
     const myTx = compileTransaction(transactionMessage);
 
     const signature = await signTransaction([signerKeyPair], myTx);
+    
+    assertIsSendableTransaction(signature);
 
     await this.client.sendAndConfirmTransaction(signature, {
       commitment: this.config.commitment,
@@ -125,6 +130,8 @@ export class SolanaSDK extends BaseSDK {
 
     const signature = await signTransaction([signerKeyPair], myTx);
 
+    assertIsSendableTransaction(signature);
+
     await this.client.sendAndConfirmTransaction(signature, {
       commitment: this.config.commitment,
     });
@@ -213,7 +220,7 @@ export class SolanaSDK extends BaseSDK {
 
     const transactionCodec = getTransactionCodec();
 
-    const tx = transactionCodec.decode(txBytes);
+    const tx = transactionCodec.decode(txBytes) as Transaction & TransactionWithLifetime;
 
     const signedTx = await signTransaction([signerKeyPair], tx);
 
@@ -238,7 +245,7 @@ export class SolanaSDK extends BaseSDK {
 
     const transactionCodec = getTransactionCodec();
 
-    const tx = transactionCodec.decode(txBytes);
+    const tx = transactionCodec.decode(txBytes) as Transaction & TransactionWithLifetime;
 
     const signedTx = await partiallySignTransaction([signerKeyPair], tx);
 
@@ -278,6 +285,8 @@ export class SolanaSDK extends BaseSDK {
 
     const signature = await signTransaction([signerKeyPair], myTx);
 
+    assertIsSendableTransaction(signature);
+
     await this.client.sendAndConfirmTransaction(signature, {
       commitment: this.config.commitment,
     });
@@ -294,7 +303,7 @@ export class SolanaSDK extends BaseSDK {
 
     const transactionCodec = getTransactionCodec();
 
-    const tx = transactionCodec.decode(txBytes);
+    const tx = transactionCodec.decode(txBytes) as Transaction & TransactionWithLifetime;
 
     const signedTx = await partiallySignTransaction([signerKeyPair], tx);
 

package/src/core/sui/cancel.ts

@@ -34,7 +34,7 @@ export async function getSuiCancelCrossChainOrder(orderId: string): Promise<Tran
 
   tx.moveCall({
     package: SUI_PACKAGE_ID,
-    module: 'source_chain_guard',
+    module: 'cross_chain_limit_orders',
     function: 'cancel_order',
     arguments: [tx.object(orderId), tx.object.clock()],
     typeArguments,

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

@@ -0,0 +1,34 @@
+import { createHash } from "crypto";
+import type { Hex } from "viem";
+
+/**
+ * Generates random U64 number
+ */
+export function getRandomU64Number() {
+  return BigInt("0x" + [...crypto.getRandomValues(new Uint8Array(8))]
+      .map(n => n.toString(16))
+      .join("")).toString();
+}
+
+/**
+ * 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,
+): Hex {
+  const executionDetails = JSON.stringify({
+    destChainId,
+    destinationAddress,
+    tokenOut,
+    amountOutMin,
+  });
+  
+  return ("0x" + createHash('sha256').update(executionDetails).digest('hex')) as `0x${string}`;
+}

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

@@ -0,0 +1,235 @@
+import { ChainID } from '../../chains.js';
+import type { SingleChainUserIntentRequest, CrossChainUserIntentRequest, DcaSingleChainUserIntentRequest } from '../../types/intent.js';
+import type { SingleChainOrder } from '../orders/single-chain.js';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
+import type { ExtraTransfer } from '../orders/common.js';
+import { getSecretHash, getRandomU64Number } from './single-chain-limit-order.js';
+import { getDcaSecretHash } from './single-chain-dca-order.js';
+import { generateExecutionDetailsHash } from './cross-chain-limit-order.js';
+
+export type CreateSuiSingleChainLimitOrderIntentParams = {
+  user: string;
+  tokenIn: string;
+  tokenOut: string;
+  amountIn: bigint;
+  amountOutMin: bigint;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  transactionHash: string;
+  secretNumber?: string;
+  stopLossMaxOut?: bigint;
+  takeProfitMinOut?: bigint;
+};
+
+export type CreateSuiSingleChainDcaOrderIntentParams = {
+  user: string;
+  tokenIn: string;
+  tokenOut: string;
+  amountInPerInterval: bigint;
+  totalIntervals: number;
+  intervalDuration: number;
+  amountOutMin: bigint;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  startTime: number;
+  transactionHash: string;
+  secretNumber?: string;
+};
+
+export type CreateSuiCrossChainOrderIntentParams = {
+  user: string;
+  srcChainId: number;
+  tokenIn: string;
+  amountIn: bigint;
+  minStablecoinsAmount: bigint;
+  deadline: number;
+  destChainId: number;
+  destinationAddress: string;
+  tokenOut: string;
+  amountOutMin: bigint;
+  transactionHash: string;
+  stopLossMaxOut?: bigint;
+  takeProfitMinOut?: bigint;
+};
+
+/**
+ * Creates a Sui 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 createSuiSingleChainLimitOrderIntentRequest(
+  params: CreateSuiSingleChainLimitOrderIntentParams
+): SingleChainUserIntentRequest {
+  const secretNumber = params.secretNumber || getRandomU64Number();
+  
+  const order: SingleChainOrder = {
+    user: params.user,
+    chainId: ChainID.Sui,
+    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: {
+      Sui: {
+        transactionHash: params.transactionHash,
+        secretNumber,
+      },
+    },
+  };
+}
+
+/**
+ * Creates a Sui 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 createSuiSingleChainDcaOrderIntentRequest(
+  params: CreateSuiSingleChainDcaOrderIntentParams
+): DcaSingleChainUserIntentRequest {
+  const secretNumber = params.secretNumber || getRandomU64Number();
+  
+  const order: DcaSingleChainOrder = {
+    user: params.user,
+    chainId: ChainID.Sui,
+    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: {
+      Sui: {
+        transactionHash: params.transactionHash,
+        secretNumber,
+      },
+    },
+  };
+}
+
+/**
+ * Creates a Sui cross-chain order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+export function createSuiCrossChainOrderIntentRequest(
+  params: CreateSuiCrossChainOrderIntentParams
+): CrossChainUserIntentRequest {
+  const executionDetails = JSON.stringify({
+    destChainId: params.destChainId,
+    tokenOut: params.tokenOut,
+    amountOutMin: params.amountOutMin,
+    destinationAddress: params.destinationAddress,
+  });
+
+  const executionDetailsHash = generateExecutionDetailsHash(
+    params.destChainId,
+    params.destinationAddress,
+    params.tokenOut,
+    params.amountOutMin.toString()
+  );
+
+  const genericData = {
+    user: params.user,
+    srcChainId: params.srcChainId,
+    tokenIn: params.tokenIn,
+    amountIn: params.amountIn,
+    minStablecoinsAmount: params.minStablecoinsAmount,
+    deadline: params.deadline,
+    executionDetailsHash: executionDetailsHash as `0x${string}`,
+    stopLossMaxOut: params.stopLossMaxOut,
+    takeProfitMinOut: params.takeProfitMinOut,
+  };
+
+  return {
+    genericData,
+    executionDetails,
+    chainSpecificData: {
+      Sui: {
+        transactionHash: params.transactionHash,
+      },
+    },
+  };
+}
+
+/**
+ * Generates secret hash for Sui single-chain limit orders
+ * @param tokenOut Output token address
+ * @param receiver Receiver address
+ * @param secretNumber Secret number (optional, generates random if not provided)
+ * @param extraTransfers Extra transfers array
+ * @returns Object containing secret number and secret hash
+ */
+export function generateSuiLimitOrderSecretData(
+  tokenOut: string,
+  receiver: string,
+  secretNumber?: string,
+  extraTransfers?: ExtraTransfer[]
+): { secretNumber: string; secretHash: Uint8Array } {
+  const secret = secretNumber || getRandomU64Number();
+  const extraTransferCoinOut = extraTransfers?.[0]?.token;
+  const extraTransferReceiver = extraTransfers?.[0]?.receiver;
+  
+  const secretHash = getSecretHash(
+    tokenOut,
+    receiver,
+    secret,
+    extraTransferCoinOut,
+    extraTransferReceiver
+  );
+
+  return {
+    secretNumber: secret,
+    secretHash: new Uint8Array(secretHash),
+  };
+}
+
+/**
+ * Generates secret hash for Sui single-chain DCA orders
+ * @param tokenOut Output token address
+ * @param receiver Receiver address
+ * @param secretNumber Secret number (optional, generates random if not provided)
+ * @param extraTransfers Extra transfers array
+ * @returns Object containing secret number and secret hash
+ */
+export function generateSuiDcaOrderSecretData(
+  tokenOut: string,
+  receiver: string,
+  secretNumber?: string,
+  extraTransfers?: ExtraTransfer[]
+): { secretNumber: string; secretHash: Uint8Array } {
+  const secret = secretNumber || getRandomU64Number();
+  const extraTransferCoinOut = extraTransfers?.[0]?.token;
+  const extraTransferReceiver = extraTransfers?.[0]?.receiver;
+  
+  const secretHash = getDcaSecretHash(
+    tokenOut,
+    receiver,
+    secret,
+    extraTransferCoinOut,
+    extraTransferReceiver
+  );
+
+  return {
+    secretNumber: secret,
+    secretHash: new Uint8Array(secretHash),
+  };
+}

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,