@shogun-sdk/intents-sdk 1.0.2 → 1.1.1

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

@@ -1,40 +1,157 @@
+import { getTransferSolInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  fetchMint,
+  getCreateAssociatedTokenInstructionAsync,
+  getSyncNativeInstruction,
+} from '@solana-program/token';
 import {
   type Address,
   address,
+  addSignersToTransactionMessage,
+  appendTransactionMessageInstructions,
   createNoopSigner,
+  createSolanaRpc,
+  createTransactionMessage,
   fetchEncodedAccount,
   generateKeyPairSigner,
   getAddressEncoder,
   getProgramDerivedAddress,
+  getTransactionCodec,
   type IInstruction,
-  type KeyPairSigner,
+  partiallySignTransactionMessageWithSigners,
+  pipe,
+  type ReadonlyUint8Array,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash,
 } from '@solana/kit';
-import { getTransferSolInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
-import {
-  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-  fetchMint,
-  getCreateAssociatedTokenInstructionAsync,
-  getSyncNativeInstruction,
-} from '@solana-program/token';
 import { ChainID } from '../../chains.js';
-import { NATIVE_SOLANA_TOKEN_ADDRESS, SRC_CHAIN_GUARD, WRAPPED_SOL_MINT_ADDRESS } from '../../constants.js';
-import type { Order } from '../order.js';
+import {
+  CROSS_CHAIN_GUARD_ADDRESSES,
+  NATIVE_SOLANA_TOKEN_ADDRESS,
+  SINGLE_CHAIN_GUARD_ADDRESSES,
+  WRAPPED_SOL_MINT_ADDRESS,
+} from '../../constants.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
+import type { SingleChainOrder } from '../orders/single-chain.js';
 import { getDefaultSolanaRPC } from './client.js';
-import { getCreateOrderInstruction } from './generated/index.js';
-import type { ApiResponse } from '../../types/api.js';
-import type { PreparedOrder } from '../../types/intent.js';
-import { BaseSDK } from '../sdk.js';
-
-/**
- * Generates Solana order instructions for creating an order
- * @param order The order to generate instructions
- * @returns Object containing the order public key and instructions
- */
-export async function getSolanaOrderInstructions(order: Order): Promise<{
-  orderKeyPair: KeyPairSigner<string>;
-  instructions: IInstruction[];
-}> {
-  const rpc = getDefaultSolanaRPC();
+import { getCreateOrderInstruction } from './generated/cross-chain/index.js';
+import { getCreateLimitOrderInstructionAsync } from './generated/single-chain/index.js';
+import { genSecretHashAndNumber } from './utils.js';
+
+export type SolanaOrderInstructionResult = {
+  // Order address
+  orderAddress: string;
+  // Encoded transaction bytes to be later deserialized into a transaction type
+  txBytes: ReadonlyUint8Array;
+};
+
+export async function getSolanaSingleChainOrderInstructions(
+  order: SingleChainOrder,
+  options?: { rpcUrl?: string },
+): Promise<SolanaOrderInstructionResult & { secretNumber: string }> {
+  const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderSigner = await generateKeyPairSigner();
+  const signer = createNoopSigner(order.user as Address);
+
+  let tokenInMint = address(order.tokenIn);
+
+  const { secretHash, secretNumber } = genSecretHashAndNumber(order);
+
+  const orderUserAddress = address(order.user);
+  const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
+
+  if (spendingNative) {
+    tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
+  }
+
+  const tokenMintProgram = await fetchMint(rpc, tokenInMint);
+
+  const guardAddress = address(SINGLE_CHAIN_GUARD_ADDRESSES[ChainID.Solana]);
+  const addressEncoder = getAddressEncoder();
+  const instructions: Array<IInstruction> = [];
+
+  const [tokenInProgramAccount] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      addressEncoder.encode(orderUserAddress),
+      addressEncoder.encode(tokenMintProgram.programAddress),
+      addressEncoder.encode(tokenInMint),
+    ],
+  });
+
+  const userTokenInAccount = await fetchEncodedAccount(rpc, tokenInProgramAccount);
+
+  if (!userTokenInAccount.exists) {
+    const createAccountIx = await getCreateAssociatedTokenInstructionAsync({
+      payer: signer,
+      ata: tokenInProgramAccount,
+      owner: orderUserAddress,
+      mint: tokenMintProgram.address,
+      tokenProgram: tokenMintProgram.programAddress,
+    });
+
+    instructions.push(createAccountIx);
+  }
+
+  if (spendingNative) {
+    const transferIx = getTransferSolInstruction({
+      amount: order.amountIn,
+      destination: userTokenInAccount.address,
+      source: signer,
+    });
+
+    instructions.push(transferIx);
+
+    const syncNativeIx = getSyncNativeInstruction({
+      account: userTokenInAccount.address,
+    });
+
+    instructions.push(syncNativeIx);
+  }
+
+  const createSingleChainLimitOrderIx = await getCreateLimitOrderInstructionAsync({
+    user: signer,
+    order: orderSigner,
+    guard: guardAddress,
+    tokenInMint: tokenInMint,
+    userTokenInAccount: userTokenInAccount.address,
+    tokenInProgram: tokenMintProgram.programAddress,
+    amountIn: order.amountIn,
+    deadline: order.deadline,
+    amountOutMin: order.amountOutMin,
+    secretHash: Uint8Array.from(secretHash),
+    extraTransfersAmounts: [], // TODO
+  });
+
+  instructions.push(createSingleChainLimitOrderIx);
+
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();
+
+  const txMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    (tx) => appendTransactionMessageInstructions(instructions, tx),
+    (tx) => addSignersToTransactionMessage([orderSigner], tx),
+  );
+
+  const partiallySignedTransaction = await partiallySignTransactionMessageWithSigners(txMessage);
+
+  const txBytes = getTransactionCodec().encode(partiallySignedTransaction);
+
+  return {
+    orderAddress: orderSigner.address,
+    txBytes,
+    secretNumber,
+  };
+}
+
+export async function getSolanaCrossChainOrderInstructions(
+  order: CrossChainOrder,
+  options?: { rpcUrl?: string },
+): Promise<SolanaOrderInstructionResult> {
+  const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
   const orderSigner = await generateKeyPairSigner();
   const signer = createNoopSigner(order.user as Address);
 
@@ -49,7 +166,7 @@ export async function getSolanaOrderInstructions(order: Order): Promise<{
 
   const tokenMintProgram = await fetchMint(rpc, tokenInMint);
 
-  const guardAddress = address(SRC_CHAIN_GUARD[ChainID.Solana]);
+  const guardAddress = address(CROSS_CHAIN_GUARD_ADDRESSES[ChainID.Solana]);
 
   const addressEncoder = getAddressEncoder();
 
@@ -76,12 +193,11 @@ export async function getSolanaOrderInstructions(order: Order): Promise<{
 
   const instructions: Array<IInstruction> = [];
 
-  // Handle native SOL
+  const userTokenInAccount = await fetchEncodedAccount(rpc, tokenInProgramAccount);
+
   if (spendingNative) {
     order.sourceTokenAddress = WRAPPED_SOL_MINT_ADDRESS;
 
-    const userTokenInAccount = await fetchEncodedAccount(rpc, tokenInProgramAccount);
-
     if (!userTokenInAccount.exists) {
       const createAccountIx = await getCreateAssociatedTokenInstructionAsync({
         payer: signer,
@@ -104,7 +220,8 @@ export async function getSolanaOrderInstructions(order: Order): Promise<{
       account: userTokenInAccount.address,
     });
 
-    instructions.push(transferIx, syncNativeIx);
+    instructions.push(transferIx);
+    instructions.push(syncNativeIx);
   }
 
   const executionHashUint8Array = order.executionDetailsHashToBytes();
@@ -112,11 +229,11 @@ export async function getSolanaOrderInstructions(order: Order): Promise<{
   const createOrderIx = getCreateOrderInstruction({
     user: signer,
     order: orderSigner,
-    guard: address(SRC_CHAIN_GUARD[ChainID.Solana]),
+    guard: address(CROSS_CHAIN_GUARD_ADDRESSES[ChainID.Solana]),
     systemProgram: SYSTEM_PROGRAM_ADDRESS,
     associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     tokenInMint: tokenInMint,
-    userTokenInAccount: tokenInProgramAccount,
+    userTokenInAccount: userTokenInAccount.address,
     guardTokenInAccount: guardProgramAccount,
     tokenInProgram: tokenMintProgram.programAddress,
     amountIn: order.sourceTokenAmount,
@@ -127,25 +244,22 @@ export async function getSolanaOrderInstructions(order: Order): Promise<{
 
   instructions.push(createOrderIx);
 
-  return {
-    instructions,
-    orderKeyPair: orderSigner,
-  };
-}
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();
 
-export async function sendSolanaRequest({
-  order,
-  orderPubkey,
-}: {
-  order: Order;
-  orderPubkey: string;
-}): Promise<ApiResponse> {
-  const preparedOrder: PreparedOrder = {
-    order,
-    preparedData: {
-      orderPubkey,
-    },
-  };
+  const txMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    (tx) => appendTransactionMessageInstructions(instructions, tx),
+    (tx) => addSignersToTransactionMessage([orderSigner], tx),
+  );
 
-  return BaseSDK.sendOrder(preparedOrder);
-}
+  const partiallySignedTransaction = await partiallySignTransactionMessageWithSigners(txMessage);
+
+  const txBytes = getTransactionCodec().encode(partiallySignedTransaction);
+
+  return {
+    orderAddress: orderSigner.address,
+    txBytes: Uint8Array.from(txBytes),
+  };
+}

package/src/core/solana/sdk.ts

@@ -4,22 +4,30 @@ import {
   compileTransaction,
   createKeyPairFromBytes,
   createNoopSigner,
+  createSignableMessage,
   createSignerFromKeyPair,
   createTransactionMessage,
   getBase58Encoder,
+  getBase64EncodedWireTransaction,
+  getTransactionCodec,
   type KeyPairSigner,
+  partiallySignTransaction,
   pipe,
   setTransactionMessageFeePayerSigner,
   setTransactionMessageLifetimeUsingBlockhash,
   signTransaction,
 } from '@solana/kit';
 import type { SolanaConfig } from '../../config.js';
-import type { PreparedOrder } from '../../types/intent.js';
-import { Order } from '../order.js';
 import { BaseSDK } from '../sdk.js';
 import { createSolanaClient, type SolanaClient } from './client.js';
-import { getSolanaOrderInstructions } from './order-instructions.js';
-import { fetchMaybeOrder } from './generated/index.js';
+import { cancelCrossChainOrderInstructions, cancelSingleChainOrderInstructions } from './cancel-order.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
+import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import { getSolanaCrossChainOrderInstructions, getSolanaSingleChainOrderInstructions } from './order-instructions.js';
+import type { SingleChainOrder } from '../orders/single-chain.js';
+import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
+import { ChainID } from '../../chains.js';
+import { bytesToHex } from 'viem';
 
 /**
  * Solana-specific SDK implementation
@@ -59,16 +67,62 @@ export class SolanaSDK extends BaseSDK {
     return signer.address;
   }
 
-  protected override async cancelOrderInternal(orderId: string): Promise<string> {
-    const rpc = this.client.rpc;
-    const orderAddress = address(orderId);
-    const orderData = await fetchMaybeOrder(rpc, orderAddress);
+  public async cancelCrossChainOrder(orderId: string): Promise<string> {
+    const instructions = await cancelCrossChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
+    const signer = await this.getUserSigner();
+    const signerKeyPair = await this.getUserCryptoKeypair();
 
-    if (!orderData) {
-      throw new Error('Order not found');
-    }
+    const noopSigner = createNoopSigner(signer.address);
+
+    const { value: latestBlockhash } = await this.client.rpc
+      .getLatestBlockhash({ commitment: this.config.commitment })
+      .send();
 
-    throw new Error('Method not implemented.');
+    const transactionMessage = pipe(
+      createTransactionMessage({ version: 0 }),
+      (tx) => setTransactionMessageFeePayerSigner(noopSigner, tx),
+      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+      (tx) => appendTransactionMessageInstructions(instructions, tx),
+    );
+
+    const myTx = compileTransaction(transactionMessage);
+
+    const signature = await signTransaction([signerKeyPair], myTx);
+
+    await this.client.sendAndConfirmTransaction(signature, {
+      commitment: this.config.commitment,
+    });
+
+    return orderId;
+  }
+
+  public async cancelSingleChainOrder(orderId: string): Promise<string> {
+    const instructions = await cancelSingleChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
+    const signer = await this.getUserSigner();
+    const signerKeyPair = await this.getUserCryptoKeypair();
+
+    const noopSigner = createNoopSigner(signer.address);
+
+    const { value: latestBlockhash } = await this.client.rpc
+      .getLatestBlockhash({ commitment: this.config.commitment })
+      .send();
+
+    const transactionMessage = pipe(
+      createTransactionMessage({ version: 0 }),
+      (tx) => setTransactionMessageFeePayerSigner(noopSigner, tx),
+      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+      (tx) => appendTransactionMessageInstructions(instructions, tx),
+    );
+
+    const myTx = compileTransaction(transactionMessage);
+
+    const signature = await signTransaction([signerKeyPair], myTx);
+
+    await this.client.sendAndConfirmTransaction(signature, {
+      commitment: this.config.commitment,
+    });
+
+    return orderId;
   }
 
   /**
@@ -98,6 +152,40 @@ export class SolanaSDK extends BaseSDK {
     return createSignerFromKeyPair(signer);
   }
 
+  public async authenticate(token?: string): Promise<string> {
+    const wallet = await this.getUserAddress();
+    const response = await fetchSiweMessage({
+      chainId: ChainID.Solana,
+      wallet,
+    });
+
+    const message = response.data!;
+
+    const signableMessage = createSignableMessage(message);
+    const signer = await this.getUserSigner();
+    const signatureArray = await signer.signMessages([signableMessage]);
+
+    const signatureBytes = signatureArray.map((signature) => signature[address(wallet)])[0];
+
+    if (!signatureBytes) {
+      throw new Error('No signature bytes found');
+    }
+
+    const hexSignature = bytesToHex(signatureBytes);
+
+    const jwt = await fetchJWTToken(
+      {
+        message,
+        signature: hexSignature,
+      },
+      token,
+    );
+
+    const newToken = jwt.data!;
+
+    return newToken;
+  }
+
   /**
    * Prepares a Solana order for submission
    *
@@ -111,38 +199,53 @@ export class SolanaSDK extends BaseSDK {
    * @returns Promise resolving to a prepared order with Solana-specific data
    * @protected
    */
-  protected async prepareOrder(order: Order): Promise<PreparedOrder> {
-    const signer = await this.getUserSigner();
+  protected async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
     const signerKeyPair = await this.getUserCryptoKeypair();
 
-    const { orderKeyPair, instructions } = await getSolanaOrderInstructions(order);
+    const { orderAddress, txBytes } = await getSolanaCrossChainOrderInstructions(order);
 
-    const noopSigner = createNoopSigner(signer.address);
+    const transactionCodec = getTransactionCodec();
 
-    const { value: latestBlockhash } = await this.client.rpc
-      .getLatestBlockhash({ commitment: this.config.commitment })
+    const tx = transactionCodec.decode(txBytes);
+
+    const signedTx = await signTransaction([signerKeyPair], tx);
+
+    const encodedTransaction = getBase64EncodedWireTransaction(signedTx);
+
+    await this.client.rpc
+      .sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: 'base64' })
       .send();
 
-    // TODO: Think if we should include transaction message on getSolanaOrderInstructions
-    const transactionMessage = pipe(
-      createTransactionMessage({ version: 0 }),
-      (tx) => setTransactionMessageFeePayerSigner(noopSigner, tx),
-      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
-      (tx) => appendTransactionMessageInstructions(instructions, tx),
-    );
+    return {
+      order,
+      preparedData: {
+        orderPubkey: orderAddress,
+      },
+    };
+  }
 
-    const myTx = compileTransaction(transactionMessage);
+  protected async prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared> {
+    const signerKeyPair = await this.getUserCryptoKeypair();
 
-    const signature = await signTransaction([signerKeyPair, orderKeyPair.keyPair], myTx);
+    const { orderAddress, txBytes, secretNumber } = await getSolanaSingleChainOrderInstructions(order);
 
-    await this.client.sendAndConfirmTransaction(signature, {
-      commitment: this.config.commitment,
-    });
+    const transactionCodec = getTransactionCodec();
+
+    const tx = transactionCodec.decode(txBytes);
+
+    const signedTx = await partiallySignTransaction([signerKeyPair], tx);
+
+    const encodedTransaction = getBase64EncodedWireTransaction(signedTx);
+
+    await this.client.rpc
+      .sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: 'base64' })
+      .send();
 
     return {
       order,
       preparedData: {
-        orderPubkey: orderKeyPair.address,
+        orderPubkey: orderAddress,
+        secretNumber,
       },
     };
   }

package/src/core/solana/utils.ts

@@ -0,0 +1,31 @@
+import BN from 'bn.js';
+import type { SingleChainOrder } from '../orders/single-chain.js';
+import { PublicKey } from '@solana/web3.js';
+import sha3 from 'js-sha3';
+
+export function genSecretHashAndNumber(order: SingleChainOrder): {
+  secretHash: number[];
+  secretNumber: string;
+} {
+  const tokenOut = new PublicKey(order.tokenOut);
+  const receiver = new PublicKey(order.destinationAddress);
+
+  const extraTransfers = order.extraTransfers ?? [];
+  const secretNumber = new BN(crypto.getRandomValues(new Uint8Array(8)));
+
+  const fullArray = [
+    ...tokenOut.toBuffer(),
+    ...receiver.toBuffer(),
+    ...Buffer.concat(
+      extraTransfers.map((t) =>
+        Buffer.concat([new PublicKey(t.token).toBuffer(), new PublicKey(t.receiver).toBuffer()]),
+      ),
+    ),
+    ...secretNumber.toArrayLike(Buffer, 'le', 8),
+  ];
+
+  const value = sha3.keccak256(Uint8Array.from(fullArray));
+  const secretHash = [...Uint8Array.from(Buffer.from(value, 'hex'))];
+
+  return { secretHash, secretNumber: secretNumber.toString() };
+}

package/src/core/solana/validator.ts

@@ -3,6 +3,10 @@ import { MAX_UINT_64 } from '../../constants.js';
 import { BaseValidator } from '../../utils/base-validator.js';
 
 export class SolanaValidator extends BaseValidator {
+  override validateSingleChainOrderFeasability(): Promise<void> {
+    return Promise.resolve();
+  }
+
   isValidAddress(address: string): boolean {
     return isSolanaAddress(address);
   }
@@ -19,7 +23,7 @@ export class SolanaValidator extends BaseValidator {
     return 'Solana';
   }
 
-  public async chainSpecificValidation(): Promise<void> {
+  public async validateCrossChainOrderFeasability(): Promise<void> {
     // No chain-specific validation implemented for now for Solana
     return;
   }

package/src/core/sui/cancel.ts

@@ -0,0 +1,44 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { createSuiClient } from './client.js';
+import { SUI_PACKAGE_ID } from '../../constants.js';
+
+export async function getSuiCancelCrossChainOrder(orderId: string): Promise<Transaction> {
+  const client = createSuiClient();
+  const order = await client.getObject({
+    id: orderId,
+    options: {
+      showContent: true,
+    },
+  });
+
+  if (!order.data) {
+    throw new Error(`Order ${orderId} not found`);
+  }
+
+  if (!order.data.content || order.data.content.dataType !== 'moveObject') {
+    throw new Error(`Order ${orderId} is not a move object`);
+  }
+
+  if (!order?.data?.content?.type) {
+    throw new Error(`Order ${orderId} has no type`);
+  }
+
+  const matched = order.data.content.type.match(/<([^>]+)>/)!;
+
+  if (!matched[1]) {
+    throw new Error(`Order ${orderId} has no type arguments`);
+  }
+
+  const typeArguments = matched[1].split(', ');
+  const tx = new Transaction();
+
+  tx.moveCall({
+    package: SUI_PACKAGE_ID,
+    module: 'source_chain_guard',
+    function: 'cancel_order',
+    arguments: [tx.object(orderId), tx.object.clock()],
+    typeArguments,
+  });
+
+  return tx;
+}

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

@@ -1,26 +1,24 @@
 import { Transaction } from '@mysten/sui/transactions';
-import { normalizeSuiObjectId, SUI_TYPE_ARG } from '@mysten/sui/utils';
+import { normalizeSuiObjectId } from '@mysten/sui/utils';
 
 import { ChainID } from '../../chains.js';
 import {
-  SRC_CHAIN_GUARD,
+  CROSS_CHAIN_GUARD_ADDRESSES,
+  NATIVE_SUI_TOKEN_ADDRESS,
   SUI_GUARD_COLLATERAL_TYPE,
   SUI_GUARD_STABLECOIN_TYPE,
   SUI_PACKAGE_ID,
 } from '../../constants.js';
 import { ValidationError } from '../../errors/index.js';
-import type { Order } from '../order.js';
 import { createSuiClient } from './client.js';
-import { BaseSDK } from '../sdk.js';
-import type { ApiResponse } from '../../types/api.js';
-import type { PreparedOrder } from '../../types/intent.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
 
 /**
  * Generates Sui order transaction for creating an order
  * @param order The order to generate transaction for
  * @returns Object containing the transaction
  */
-export async function getSuiOrderTransaction(order: Order): Promise<Transaction> {
+export async function getSuiOrderTransaction(order: CrossChainOrder): Promise<Transaction> {
   const userAddress = order.user;
   const client = createSuiClient();
   const coins = await client.getCoins({
@@ -28,7 +26,7 @@ export async function getSuiOrderTransaction(order: Order): Promise<Transaction>
     coinType: order.sourceTokenAddress,
   });
 
-  const guardAddress = SRC_CHAIN_GUARD[ChainID.Sui];
+  const guardAddress = CROSS_CHAIN_GUARD_ADDRESSES[ChainID.Sui];
 
   const sourceTokenInCoins = coins.data.sort((a, b) => Number(b.balance) - Number(a.balance));
 
@@ -44,7 +42,8 @@ export async function getSuiOrderTransaction(order: Order): Promise<Transaction>
     );
   }
 
-  const spendingGasCoin = normalizeSuiObjectId(order.sourceTokenAddress) === normalizeSuiObjectId(SUI_TYPE_ARG);
+  const spendingGasCoin =
+    normalizeSuiObjectId(order.sourceTokenAddress) === normalizeSuiObjectId(NATIVE_SUI_TOKEN_ADDRESS);
 
   const tx = new Transaction();
   const coinInArg = spendingGasCoin ? tx.gas : sourceTokenInCoins[0]!.coinObjectId;
@@ -66,11 +65,12 @@ export async function getSuiOrderTransaction(order: Order): Promise<Transaction>
     module: 'source_chain_guard',
     function: 'create_order',
     arguments: [
-      tx.object(guardAddress),
-      coinIn,
-      tx.pure.u64(order.minStablecoinAmount),
-      tx.pure.u64(order.deadline * 1000), // Convert to milliseconds
-      tx.pure.vector('u8', order.executionDetailsHashToBytes()),
+      tx.object(guardAddress), // arg0: &Guard<T0, T2>
+      coinIn, // arg1: Coin<T1>
+      tx.pure.u64(order.minStablecoinAmount), // arg2: min_stablecoins_amount
+      tx.pure.u64(order.deadline * 1000), // arg3: deadline (converted to milliseconds)
+      tx.pure.vector('u8', order.executionDetailsHashToBytes()), // arg4: execution_details_hash
+      tx.object.clock(), // arg5: &Clock
     ],
     typeArguments: [SUI_GUARD_COLLATERAL_TYPE, order.sourceTokenAddress, SUI_GUARD_STABLECOIN_TYPE],
   });
@@ -79,20 +79,3 @@ export async function getSuiOrderTransaction(order: Order): Promise<Transaction>
 
   return tx;
 }
-
-export async function sendSuiRequest({
-  order,
-  transactionDigest,
-}: {
-  order: Order;
-  transactionDigest: string;
-}): Promise<ApiResponse> {
-  const preparedOrder: PreparedOrder = {
-    order,
-    preparedData: {
-      transactionHash: transactionDigest,
-    },
-  };
-
-  return BaseSDK.sendOrder(preparedOrder);
-}