@shogun-sdk/intents-sdk 1.0.1 → 1.1.0

package/src/core/sui/sdk.ts

@@ -1,13 +1,16 @@
 import type { SuiClient } from '@mysten/sui/client';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
-
 import type { SuiConfig } from '../../config.js';
-import { OrderCreationError } from '../../errors/index.js';
-import type { PreparedOrder } from '../../types/intent.js';
-import { Order } from '../order.js';
 import { BaseSDK } from '../sdk.js';
 import { createSuiClient } from './client.js';
 import { getSuiOrderTransaction } from './order-transaction.js';
+import { getSuiCancelCrossChainOrder } from './cancel.js';
+import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
+import type { ApiUserOrders } from '../../types/api.js';
+import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
+import { fetchUserOrders } from '../orders/api/fetch.js';
+import { ChainID } from '../../chains.js';
 
 /**
  * Sui-specific SDK implementation
@@ -21,6 +24,7 @@ export class SuiSDK extends BaseSDK {
   private readonly config: SuiConfig;
   /** Client for Sui RPC interactions and transaction handling */
   private client: SuiClient;
+  private token?: string;
 
   /**
    * Creates a new instance of the Sui SDK
@@ -56,6 +60,54 @@ export class SuiSDK extends BaseSDK {
     return Ed25519Keypair.fromSecretKey(this.config.privateKey);
   }
 
+  protected override prepareSingleChainOrder(): Promise<SingleChainOrderPrepared> {
+    throw new Error('Single-chain orders are not supported on Sui');
+  }
+
+  public async authenticate(token?: string): Promise<string> {
+    const wallet = await this.getUserAddress();
+
+    const response = await fetchSiweMessage({
+      chainId: ChainID.Sui,
+      wallet,
+    });
+
+    const message = response.data!;
+
+    const keypair = this.getKeyPair();
+
+    const messageBytes = new TextEncoder().encode(message);
+
+    const { signature } = await keypair.signPersonalMessage(messageBytes);
+
+    const jwt = await fetchJWTToken(
+      {
+        message,
+        signature,
+      },
+      token,
+    );
+
+    const newToken = jwt.data!;
+
+    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;
+  }
   /**
    * Prepares a Sui order for submission
    *
@@ -69,27 +121,42 @@ export class SuiSDK extends BaseSDK {
    * @returns Promise resolving to a prepared order with Sui-specific data
    * @protected
    */
-  protected async prepareOrder(order: Order): Promise<PreparedOrder> {
-    try {
-      const signer = this.getKeyPair();
-
-      const transaction = await getSuiOrderTransaction(order);
-
-      const tx = await this.client.signAndExecuteTransaction({
-        signer,
-        transaction,
-      });
-
-      await this.client.waitForTransaction({ digest: tx.digest });
-
-      return {
-        order,
-        preparedData: {
-          transactionHash: tx.digest,
-        },
-      };
-    } catch (error) {
-      throw new OrderCreationError('Failed to prepare Sui order', error);
-    }
+  protected async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
+    const signer = this.getKeyPair();
+
+    const transaction = await getSuiOrderTransaction(order);
+
+    const tx = await this.client.signAndExecuteTransaction({
+      signer,
+      transaction,
+    });
+
+    await this.client.waitForTransaction({ digest: tx.digest });
+
+    return {
+      order,
+      preparedData: {
+        transactionHash: tx.digest,
+      },
+    };
+  }
+
+  public async cancelCrossChainOrder(orderId: string): Promise<string> {
+    const signer = this.getKeyPair();
+
+    const transaction = await getSuiCancelCrossChainOrder(orderId);
+
+    const sender = await this.getUserAddress();
+
+    transaction.setSender(sender);
+
+    const tx = await this.client.signAndExecuteTransaction({
+      signer,
+      transaction,
+    });
+
+    await this.client.waitForTransaction({ digest: tx.digest });
+
+    return tx.digest;
   }
 }

package/src/core/sui/validator.ts

@@ -25,8 +25,12 @@ export class SuiValidator extends BaseValidator {
     return 'Sui';
   }
 
-  public async chainSpecificValidation(): Promise<void> {
+  public async validateCrossChainOrderFeasability(): Promise<void> {
     // No chain-specific validation implemented for now for Sui
     return;
   }
+
+  override validateSingleChainOrderFeasability(): Promise<void> {
+    return Promise.resolve();
+  }
 }

package/src/errors/index.ts

@@ -32,29 +32,6 @@ export class BaseError extends Error {
   }
 }
 
-// Chain-specific error classes
-export class EVMError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, EVMError.prototype);
-  }
-}
-
-export class SolanaError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, SolanaError.prototype);
-  }
-}
-
-export class SuiError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, SuiError.prototype);
-  }
-}
-
-// Specific error types
 export class ValidationError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);
@@ -62,13 +39,6 @@ export class ValidationError extends BaseError {
   }
 }
 
-export class OrderCreationError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, OrderCreationError.prototype);
-  }
-}
-
 export class NetworkError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);
@@ -83,19 +53,13 @@ export class InsufficientBalanceError extends BaseError {
   }
 }
 
-export class CalculateAmountError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, CalculateAmountError.prototype);
-  }
-}
-
 export class InsufficientAllowanceError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);
     Object.setPrototypeOf(this, InsufficientAllowanceError.prototype);
   }
 }
+
 export function handleError(error: unknown): BaseError {
   if (error instanceof BaseError) {
     return error;

package/src/index.ts

@@ -1,12 +1,42 @@
-export type { ChainID, ChainType } from './chains.js';
-export { SupportedChains } from './chains.js';
+export { ChainID, ChainType, SupportedChains, isSupportedChain, chainIdToChainTypeMap, isEvmChain } from './chains.js';
+export type { SupportedEvmChain, SupportedChain } from './chains.js';
 
 export type { EVMConfig, SolanaConfig, SuiConfig } from './config.js';
 export { EVMSDK } from './core/evm/sdk.js';
-export { Order } from './core/order.js';
 export { SolanaSDK } from './core/solana/sdk.js';
 export { SuiSDK } from './core/sui/sdk.js';
+export { CrossChainOrder } from './core/orders/cross-chain.js';
+export type { CreateCrossChainOrderParams } from './core/orders/cross-chain.js';
+export { SingleChainOrder } from './core/orders/single-chain.js';
+export type { CreateSingleChainOrderParams } from './core/orders/single-chain.js';
+
+export { fetchUserOrders } from './core/orders/api/fetch.js';
+export { type FetchJWTParams, type FetchSiweMessageParams, fetchJWTToken, fetchSiweMessage } from './auth/siwe.js';
 export { ValidationError } from './errors/index.js';
-export { calculateAmounts, chainIdToDefiLlamaChainMap, createDefiLlamaCoinKey, getCoinFromResponse, getTokensData } from './utils/defillama.js';
+export { type ApiCrossChainOrder, type ApiResponse, type ApiSingleChainOrder, type ApiUserOrders, type ChainOrderStatus, isErrorApiResponse, isSuccessApiResponse } from './types/api.js';
+export { calculateAmounts, getCoinFromResponse, getTokensData } from './utils/defillama.js';
 export type { DefiLlamaCoinData, DefiLlamaTokensResponse } from './utils/defillama.js';
-export type { CreateOrderParams } from './types/intent.js';
+export {
+  getCancelCrossChainOrderRawData,
+  getCancelSingleChainOrderRawData,
+  type CancelSingleChainOrderParams,
+  type CancelCrossChainOrderParams,
+  getInvalidateNoncesRawData,
+} from './core/evm/cancel-order.js';
+export { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData } from './core/evm/order-signature.js';
+
+export {
+  getSolanaCrossChainOrderInstructions,
+  getSolanaSingleChainOrderInstructions,
+} from './core/solana/order-instructions.js';
+export {
+  cancelCrossChainOrderInstructionsAsBytes,
+  cancelSingleChainOrderInstructionsAsBytes,
+} from './core/solana/cancel-order.js';
+export { getSuiOrderTransaction } from './core/sui/order-transaction.js';
+export { getSuiCancelCrossChainOrder } from './core/sui/cancel.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';

package/src/types/api.ts

@@ -0,0 +1,78 @@
+import type { ExtraTransfer } from '../core/orders/common.js';
+
+export type ChainOrderStatus = 'Auction' | 'NoBids' | 'Executing' | 'Fulfilled' | 'Cancelled' | 'Outdated';
+
+export type ApiCrossChainOrder = {
+  orderId: string;
+  // Flattened fields from the API response
+  user: string;
+  srcChainId: number;
+  tokenIn: string;
+  minStablecoinsAmount: string;
+  destChainId: number;
+  tokenOut: string;
+  amountOutMin: string;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  executionDetailsHash: string;
+  amountIn: string;
+  // Cross-chain specific fields
+  executionDetails: string;
+  orderCreationTime: number;
+  orderStatus: ChainOrderStatus;
+  tokensInWereSwappedToStablecoins: boolean;
+  lockedStablecoins: string;
+  nonce?: string;
+  orderFulfillmentTimestamp?: number;
+  transactionHash?: string;
+  amountOut?: string;
+};
+
+export type ApiSingleChainOrder = {
+  orderId: string;
+  // Flattened fields from the API response
+  user: string;
+  chainId: number;
+  tokenIn: string;
+  tokenOut: string;
+  amountOutMin: string;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  amountIn: string;
+  // Single-chain specific fields
+  orderCreationTime: number;
+  orderStatus: ChainOrderStatus;
+  nonce?: string;
+  orderFulfillmentTimestamp?: number;
+  transactionHash?: string;
+  amountOut?: string;
+};
+
+export type ApiUserOrders = {
+  singleChainLimitOrders: ApiSingleChainOrder[];
+  crossChainLimitOrders: ApiCrossChainOrder[];
+};
+
+export type ValidResponseData = ApiUserOrders | string | null;
+
+export type ApiResponse<T extends ValidResponseData = ValidResponseData> = {
+  success: boolean;
+  code: number;
+  data?: T;
+  error?: unknown;
+  extra_error_data?: unknown;
+};
+
+export function isSuccessApiResponse<T extends ValidResponseData>(
+  response: ApiResponse<T>,
+): response is ApiResponse<T> & { success: true; data: T } {
+  return response.success;
+}
+
+export function isErrorApiResponse<T extends ValidResponseData>(
+  response: ApiResponse<T>,
+): response is ApiResponse<T> & { success: false; error: unknown } {
+  return !response.success;
+}

package/src/types/intent.ts

@@ -1,35 +1,7 @@
 import type { SupportedChain } from '../chains.js';
-import type { ExtraTransfer, Order } from '../core/order.js';
-
-/**
- * Parameters for creating a cross-chain order
- * Used as input for the createOrder and createAndSendOrder methods
- */
-export type CreateOrderParams = {
-  /** Chain ID where tokens will be sent from */
-  sourceChainId: SupportedChain;
-  /** Token address on the source chain to be swapped */
-  sourceTokenAddress: string;
-  /** Amount of source tokens to swap, in smallest units (e.g., Wei for ETH) */
-  sourceTokenAmount: bigint;
-
-  /** Chain ID where tokens will be received */
-  destinationChainId: SupportedChain;
-  /** Token address on the destination chain to receive */
-  destinationTokenAddress: string;
-  /** Minimum amount of destination tokens to receive, in smallest units */
-  destinationTokenMinAmount?: bigint;
-  /** Recipient wallet address on the destination chain */
-  destinationAddress: string;
-
-  /** Minimum amount of stablecoins in the intermediate swap, in smallest units */
-  minStablecoinAmount?: bigint;
-  /** Timestamp (in seconds) after which the order expires */
-  deadline: number;
-
-  /** Extra Transfers */
-  extraTransfers?: ExtraTransfer[];
-};
+import type { CrossChainOrder } from '../core/orders/cross-chain.js';
+import type { ExtraTransfer } from '../core/orders/common.js';
+import type { SingleChainOrder } from '../core/orders/single-chain.js';
 
 /**
  * Details required to execute the order on the destination chain
@@ -48,15 +20,10 @@ export type ExecutionDetails = {
   extraTransfers?: ExtraTransfer[];
 };
 
-/** Hex string with 0x prefix, used for various hashes */
 export type Hash = `0x${string}`;
 /** Hash of execution details, used to verify order integrity across chains */
 export type ExecutionDetailsHash = Hash;
 
-/**
- * EVM-specific data required for prepared orders
- * Contains the signature and nonce for Permit2 allowance
- */
 export type EvmPreparedData = {
   /** Random nonce for Permit2 signature, prevents replay attacks */
   nonce: string;
@@ -64,19 +31,11 @@ export type EvmPreparedData = {
   signature: string | Hash;
 };
 
-/**
- * Sui-specific data required for prepared orders
- * Contains the transaction hash of the order creation transaction
- */
 export type SuiPreparedData = {
   /** Transaction hash of the successful order creation transaction */
   transactionHash: string;
 };
 
-/**
- * Solana-specific data required for prepared orders
- * Contains the public key of the created order account
- */
 export type SolanaPreparedData = {
   /** Public key of the created order account on Solana */
   orderPubkey: string;
@@ -101,13 +60,12 @@ export type SourceChainData = {
   deadline: number;
   /** Hash of execution details for cross-chain verification */
   executionDetailsHash: ExecutionDetailsHash;
+  stopLossMaxOut?: bigint;
+  takeProfitMinOut?: bigint;
+  extraTransfers?: ExtraTransfer[];
 };
 
-/**
- * Complete user intent request sent to the auctioneer service
- * Contains all the information needed to execute the cross-chain swap
- */
-export type UserIntentRequest = {
+export type CrossChainUserIntentRequest = {
   /** Generic data common to all chains */
   genericData: SourceChainData;
   /** JSON-stringified execution details for the destination chain */
@@ -123,21 +81,42 @@ export type UserIntentRequest = {
   };
 };
 
-/**
- * Union type of all chain-specific prepared data
- * The actual type depends on the source chain
- */
+export type SingleChainUserIntentRequest = {
+  genericData: SingleChainOrder;
+  chainSpecificData: {
+    EVM?: EvmPreparedData;
+    Solana?: SolanaPreparedData;
+    Sui?: SolanaPreparedData;
+  };
+};
+
 export type ChainPreparedData = EvmPreparedData | SuiPreparedData | SolanaPreparedData;
 
-/**
- * Fully prepared order ready for submission to the auctioneer
- * Contains both the order details and chain-specific prepared data
- */
-export type PreparedOrder = {
-  /** The original order with all cross-chain details */
-  order: Order;
-  /** Chain-specific data needed for order execution */
+export type CrossChainOrderPrepared = {
+  order: CrossChainOrder;
   preparedData: ChainPreparedData;
-  /** Hash related to the start order execution */
-  // txHash: string // TODO: Think if we need this
+};
+
+export type SingleChainEVMPreparedData = {
+  nonce: string;
+  signature: string | Hash;
+};
+
+export type SingleChainSolanaPreparedData = {
+  secretNumber: string;
+  orderPubkey: string;
+};
+
+export type SingleChainSuiPreparedData = {
+  transactionHash: string;
+};
+
+export type SingleChainPreparedData =
+  | SingleChainEVMPreparedData
+  | SingleChainSolanaPreparedData
+  | SingleChainSuiPreparedData;
+
+export type SingleChainOrderPrepared = {
+  order: SingleChainOrder;
+  preparedData: SingleChainPreparedData;
 };

package/src/utils/base-validator.ts

@@ -1,4 +1,5 @@
-import type { OrderInput } from '../core/order.js';
+import type { CreateCrossChainOrderParams } from '../core/orders/cross-chain.js';
+import type { CreateSingleChainOrderParams } from '../core/orders/single-chain.js';
 import { ValidationError } from '../errors/index.js';
 import type { IChainValidator } from './order-validator.js';
 
@@ -11,26 +12,43 @@ export abstract class BaseValidator implements IChainValidator {
   abstract isValidTokenAddress(tokenAddress: string): boolean;
   abstract isValidAmount(amount: bigint): boolean;
   protected abstract getChainName(): string;
-  abstract chainSpecificValidation(order: OrderInput): Promise<void>;
+  abstract validateCrossChainOrderFeasability(order: CreateCrossChainOrderParams & { user: string }): Promise<void>;
+  abstract validateSingleChainOrderFeasability(order: CreateSingleChainOrderParams & { user: string }): Promise<void>;
 
   /**
    * Validate source chain specific parameters of the order
    */
-  async validateSourceChain(order: OrderInput): Promise<void> {
-    this.validateAddress(order.user);
+  async validateSourceChain(order: CreateCrossChainOrderParams & { user: string }): Promise<void> {
     this.validateTokenAddress(order.sourceTokenAddress);
     this.validateAmount(order.sourceTokenAmount);
-    this.validateAmount(order.minStablecoinAmount);
-    await this.chainSpecificValidation(order);
+    this.validateAmount(order.minStablecoinAmount ?? 1n);
+    await this.validateCrossChainOrderFeasability({ ...order, user: order.user });
+  }
+
+  async validateSingleChainOrder(order: CreateSingleChainOrderParams & { user: string }): Promise<void> {
+    this.validateTokenAddress(order.tokenIn);
+    this.validateTokenAddress(order.tokenOut);
+    this.validateAmount(order.amountIn);
+    this.validateAmount(order.amountOutMin ?? 1n);
+
+    if (order.stopLossMaxOut) {
+      this.validateAmount(order.stopLossMaxOut);
+    }
+
+    if (order.takeProfitMinOut) {
+      this.validateAmount(order.takeProfitMinOut);
+    }
+
+    await this.validateSingleChainOrderFeasability(order);
   }
 
   /**
    * Validate destination chain specific parameters of the order
    */
-  validateDestinationChain(order: OrderInput): void {
+  validateDestinationChain(order: CreateCrossChainOrderParams): void {
     this.validateAddress(order.destinationAddress);
     this.validateTokenAddress(order.destinationTokenAddress);
-    this.validateAmount(order.destinationTokenMinAmount);
+    this.validateAmount(order.destinationTokenMinAmount ?? 1n);
 
     if (order.extraTransfers) {
       for (const extraTransfer of order.extraTransfers) {