@shogun-sdk/intents-sdk 1.0.2 → 1.1.0

package/src/core/evm/sdk.ts

@@ -1,93 +1,97 @@
-// src/core/evm/sdk.ts
-
 import { privateKeyToAccount } from 'viem/accounts';
 import type { EVMConfig } from '../../config.js';
-import { EVMError, OrderCreationError } from '../../errors/index.js';
-import type { PreparedOrder } from '../../types/intent.js';
-import type { Order } from '../order.js';
 import { BaseSDK } from '../sdk.js';
 import { EVMIntentProvider } from './intent-provider.js';
-import { type Hex } from 'viem';
-import { AUCTIONEER_URL, PERMIT2_ADDRESS, SRC_CHAIN_GUARD } from '../../constants.js';
-import type { SupportedEvmChain } from '../../chains.js';
-import type { UserOrder } from '../../types/user-order.js';
+import { type Address, type Hex } from 'viem';
+import {
+  PERMIT2_ADDRESS,
+  CROSS_CHAIN_GUARD_ADDRESSES,
+  SINGLE_CHAIN_GUARD_ADDRESSES,
+  MAX_UINT_256,
+} from '../../constants.js';
+import type { ExtraTransfer } from '../orders/common.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
+import type { SingleChainOrder } from '../orders/single-chain.js';
+import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import type { ApiUserOrders } from '../../types/api.js';
+import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
+import { fetchUserOrders } from '../orders/api/fetch.js';
+
+type CancelSingleChainOrderParams = {
+  orderId: string;
+  user: string;
+  tokenIn: string;
+  amountIn: bigint;
+  requestedOutput: ExtraTransfer;
+  extraTransfers: ExtraTransfer[];
+  encodedExternalCallData: string;
+  deadline: number;
+  nonce: bigint;
+};
+
+type CancelCrossChainOrderParams = {
+  orderId: string;
+  user: string;
+  tokenIn: string;
+  amountIn: bigint;
+  srcChainId: number;
+  deadline: number;
+  minStablecoinsAmount: bigint;
+  executionDetailsHash: string;
+  nonce: bigint;
+};
 
 /**
- * EVM-specific SDK implementation
- *
  * Handles EVM-specific aspects of cross-chain swaps for Ethereum-compatible chains:
- * - Arbitrum
- * - Optimism
- * - Base
- *
- * Uses viem for blockchain interactions and EIP-712 signatures for order authorization.
  */
 export class EVMSDK extends BaseSDK {
-  /** Configuration for EVM chain connections and authentication */
   private readonly config: EVMConfig;
-  /** Provider for EVM-specific order preparation and submission */
   private readonly evmIntentProvider: EVMIntentProvider;
+  private token?: string;
 
-  /**
-   * Creates a new instance of the EVM SDK
-   *
-   * @param config EVM configuration including chainId, privateKey, and optional RPC URL
-   */
   constructor(config: EVMConfig) {
     super();
     this.config = config;
     this.evmIntentProvider = new EVMIntentProvider(config);
   }
 
-  protected async cancelOrderInternal(orderId: string): Promise<string> {
+  public async cancelCrossChainOrder(params: CancelCrossChainOrderParams): Promise<string> {
     const chainId = this.config.chainId;
-    const auctioneerAddress = SRC_CHAIN_GUARD[chainId] as Hex;
+    const auctioneerAddress = CROSS_CHAIN_GUARD_ADDRESSES[chainId] as Hex;
     const userAddress = (await this.getUserAddress()) as Hex;
-    const auctioneerContract = this.evmIntentProvider.provider.getAuctioneerContract(auctioneerAddress);
-    const permit2Contract = this.evmIntentProvider.provider.getPermit2Contract(PERMIT2_ADDRESS[chainId]);
-
-    const userOrders = await this.fetchUserOrders(chainId);
-
-    const userOrder = userOrders.find((order) => order.orderId === orderId);
 
-    if (!userOrder) {
-      throw new Error('Order not found');
-    }
+    const auctioneerContract = this.evmIntentProvider.provider.getCrossChainAuctioneerContract(auctioneerAddress);
+    const permit2Contract = this.evmIntentProvider.provider.getPermit2Contract(PERMIT2_ADDRESS[chainId]);
 
-    const orderIdHex = orderId as Hex;
+    const orderIdHex = params.orderId as Hex;
     let [initialized, deactivated] = await auctioneerContract.read.orderData([orderIdHex]);
-
     let txHash: Hex;
 
-    if (!userOrder.nonce) {
-      throw new Error('Nonce is required for cancellation');
-    }
-
     if (initialized) {
       if (deactivated) {
         throw new Error('Order is already deactivated');
       }
+
       const orderInfo = {
-        user: userOrder.user as `0x${string}`,
-        tokenIn: userOrder.tokenIn as `0x${string}`,
-        srcChainId: userOrder.srcChainId,
-        deadline: userOrder.deadline,
-        amountIn: BigInt(userOrder.amountIn),
-        minStablecoinsAmount: BigInt(userOrder.minStablecoinsAmount),
-        executionDetailsHash: userOrder.executionDetailsHash as `0x${string}`,
-        nonce: BigInt(userOrder.nonce!),
+        user: params.user as Hex,
+        tokenIn: params.tokenIn as Hex,
+        srcChainId: params.srcChainId,
+        deadline: params.deadline,
+        amountIn: BigInt(params.amountIn),
+        minStablecoinsAmount: BigInt(params.minStablecoinsAmount),
+        executionDetailsHash: params.executionDetailsHash as Hex,
+        nonce: BigInt(params.nonce!),
       };
 
       const tx = await auctioneerContract.write.cancelOrder([orderInfo]);
       txHash = tx;
     } else {
-      const nonce = BigInt(userOrder.nonce);
+      const nonce = BigInt(params.nonce);
       let nonceWordPos = nonce >> 8n;
       let nonceBitPos = nonce - nonceWordPos * 256n;
       let mask = 1n << nonceBitPos;
 
       const currentNonceBitmap = await permit2Contract.read.nonceBitmap([userAddress, nonceWordPos]);
-
       if ((currentNonceBitmap & (1n << nonceBitPos)) !== 0n) {
         throw new Error('Nonce is already invalidated');
       }
@@ -99,51 +103,124 @@ export class EVMSDK extends BaseSDK {
     return txHash;
   }
 
-  public async fetchUserOrders(chainId: SupportedEvmChain): Promise<UserOrder[]> {
-    const userAddress = await this.getUserAddress();
-    const siweEndpoint = `${AUCTIONEER_URL}/siwe`;
-    const queryParams = `?chainId=${chainId}&wallet=${userAddress}`;
+  public async cancelSingleChainOrder(params: CancelSingleChainOrderParams): Promise<string> {
+    const chainId = this.config.chainId;
+    const auctioneerAddress = SINGLE_CHAIN_GUARD_ADDRESSES[chainId] as Hex;
+    const userAddress = (await this.getUserAddress()) as Hex;
 
-    const response = await fetch(`${siweEndpoint}${queryParams}`);
-    const { data: message } = await response.json();
+    const auctioneerContract = this.evmIntentProvider.provider.getSingleChainAuctioneerContract(auctioneerAddress);
 
-    const signature = await this.evmIntentProvider.provider.walletClient.signMessage(message);
-    const jwt = await fetch(siweEndpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ message, signature }),
+    const orderHash = params.orderId as Hex;
+    const wasManuallyInitialized = await auctioneerContract.read.orderManuallyInitialized([orderHash]);
+
+    let txHash: Hex;
+
+    if (wasManuallyInitialized) {
+      txHash = await auctioneerContract.write.cancelManuallyCreatedOrder([
+        {
+          amountIn: params.amountIn,
+          tokenIn: params.tokenIn as Hex,
+          deadline: params.deadline as number,
+          nonce: params.nonce,
+          encodedExternalCallData: params.encodedExternalCallData as Hex,
+          extraTransfers: params.extraTransfers.map((transfer) => {
+            return {
+              amount: transfer.amount,
+              receiver: transfer.receiver as Hex,
+              token: transfer.token as Hex,
+            };
+          }),
+          requestedOutput: {
+            amount: params.requestedOutput.amount,
+            receiver: params.requestedOutput.receiver as Hex,
+            token: params.requestedOutput.token as Hex,
+          },
+          user: params.user as Hex,
+        },
+      ]);
+    } else {
+      const permit2Contract = this.evmIntentProvider.provider.getPermit2Contract(PERMIT2_ADDRESS[chainId]);
+
+      const nonce = BigInt(params.nonce);
+      const nonceWordPos = nonce >> 8n;
+      const nonceBitPos = nonce - nonceWordPos * 256n;
+      const mask = 1n << nonceBitPos;
+
+      // Check if nonce is already invalidated
+      const currentNonceBitmap = await permit2Contract.read.nonceBitmap([userAddress, nonceWordPos]);
+      if ((currentNonceBitmap & (1n << nonceBitPos)) !== 0n) {
+        throw new Error('Nonce is already invalidated');
+      }
+
+      txHash = await permit2Contract.write.invalidateUnorderedNonces([nonceWordPos, mask]);
+    }
+
+    return txHash;
+  }
+
+  public async authenticate(token?: string): Promise<string> {
+    const chainId = this.config.chainId;
+    const wallet = await this.getUserAddress();
+
+    const response = await fetchSiweMessage({
+      chainId,
+      wallet,
     });
 
-    const { data: token } = await jwt.json();
+    const message = response.data!;
 
-    const ordersUrl = `${AUCTIONEER_URL}/user_intent`;
-    const orders = await fetch(ordersUrl, {
-      method: 'GET',
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
+    // Sign the message using the wallet client
+    const signature = await this.evmIntentProvider.provider.walletClient.signMessage({
+      message,
     });
 
-    const { data: ordersData } = await orders.json();
+    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 ordersData;
+    return orders;
   }
 
   /**
    * Gets the user's Ethereum address derived from their private key
-   *
-   * Uses viem's privateKeyToAccount function to derive the address securely
-   *
    * @returns Promise resolving to the user's Ethereum address as a 0x-prefixed string
-   * @throws {EVMError} If address derivation fails
    */
   public async getUserAddress(): Promise<string> {
-    try {
-      return privateKeyToAccount(this.config.privateKey).address;
-    } catch (error) {
-      throw new EVMError('Failed to get user address', error);
+    return privateKeyToAccount(this.config.privateKey).address;
+  }
+
+  protected async approveAllowanceIfNeeded(tokenAddress: Address, amount: bigint): Promise<void> {
+    const permit2Address = PERMIT2_ADDRESS[this.config.chainId];
+    const ERC20Contract = this.evmIntentProvider.provider.getERC20Contract(tokenAddress);
+
+    const userAddress = (await this.getUserAddress()) as Address;
+
+    const allowance = await ERC20Contract.read.allowance([userAddress, permit2Address]);
+
+    if (allowance < amount) {
+      await ERC20Contract.write.approve([permit2Address, MAX_UINT_256]);
     }
   }
 
@@ -157,14 +234,14 @@ export class EVMSDK extends BaseSDK {
    *
    * @param order The validated order to prepare
    * @returns Promise resolving to a prepared order with EVM-specific signature data
-   * @throws {OrderCreationError} If order preparation fails
-   * @protected
    */
-  protected prepareOrder(order: Order): Promise<PreparedOrder> {
-    try {
-      return this.evmIntentProvider.prepare(order);
-    } catch (error) {
-      throw new OrderCreationError('Failed to prepare EVM order', error);
-    }
+  protected override async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
+    await this.approveAllowanceIfNeeded(order.sourceTokenAddress as Address, order.sourceTokenAmount);
+    return this.evmIntentProvider.prepareCrossChainOrder(order);
+  }
+
+  protected async prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared> {
+    await this.approveAllowanceIfNeeded(order.tokenIn as Address, order.amountIn);
+    return this.evmIntentProvider.prepareSingleChainOrder(order);
   }
 }

package/src/core/evm/validator.ts

@@ -1,11 +1,12 @@
 import { type Address, getContract, isAddress as isEvmAddress } from 'viem';
-import type { SupportedEvmChain } from '../../chains.js';
-import { MAX_UINT_128, PERMIT2_ADDRESS } from '../../constants.js';
-import { InsufficientAllowanceError, InsufficientBalanceError } from '../../errors/index.js';
+import { ChainID, type SupportedEvmChain } from '../../chains.js';
+import { isNativeEvmToken, MAX_UINT_128 } from '../../constants.js';
+import { InsufficientBalanceError, ValidationError } from '../../errors/index.js';
 import { BaseValidator } from '../../utils/base-validator.js';
-import type { OrderInput } from '../order.js';
+import type { CreateCrossChainOrderParams } from '../orders/cross-chain.js';
 import { ERC20ABI } from './abi/erc20.js';
-import { ChainProvider } from './viem-provider.js';
+import { ChainProvider } from './chain-provider.js';
+import type { CreateSingleChainOrderParams } from '../orders/single-chain.js';
 
 /**
  * Chain-specific validator implementations
@@ -27,11 +28,21 @@ export class EvmValidator extends BaseValidator {
     return 'EVM';
   }
 
-  public async chainSpecificValidation(order: OrderInput): Promise<void> {
+  public async validateCrossChainOrderFeasability(
+    order: CreateCrossChainOrderParams & { user: string },
+  ): Promise<void> {
     const chain = order.sourceChainId as SupportedEvmChain;
     const client = ChainProvider.getClient(chain);
     const user = order.user as Address;
 
+    if (isNativeEvmToken(order.sourceTokenAddress)) {
+      throw new ValidationError('Native token is not supported.');
+    }
+
+    if (order.sourceChainId === ChainID.Hyperliquid && isNativeEvmToken(order.destinationTokenAddress)) {
+      throw new ValidationError('HYPE native token as destination address is not supported.');
+    }
+
     const ERC20Contract = getContract({
       address: order.sourceTokenAddress as Address,
       abi: ERC20ABI,
@@ -40,6 +51,7 @@ export class EvmValidator extends BaseValidator {
         chain,
       },
     });
+
     const balance = await ERC20Contract.read.balanceOf([user]);
 
     if (balance < order.sourceTokenAmount) {
@@ -48,13 +60,63 @@ export class EvmValidator extends BaseValidator {
       );
     }
 
-    const permit2Address = PERMIT2_ADDRESS[chain];
-    const allowance = await ERC20Contract.read.allowance([user, permit2Address]);
+    // Temporary allowance turn off. This should be handled in the frontend.
+    // const permit2Address = PERMIT2_ADDRESS[chain];
+    // const allowance = await ERC20Contract.read.allowance([user, permit2Address]);
+
+    // if (allowance < order.sourceTokenAmount) {
+    //   throw new InsufficientAllowanceError(
+    //     `Insufficient allowance for token ${order.sourceTokenAddress} on permit2 address ${permit2Address}. Current allowance: ${allowance}. Required allowance: ${order.sourceTokenAmount}`,
+    //   );
+    // }
+  }
+
+  override async validateSingleChainOrderFeasability(
+    order: CreateSingleChainOrderParams & { user: string },
+  ): Promise<void> {
+    const chain = order.chainId as SupportedEvmChain;
+
+    const validSingleChainChains = [ChainID.Hyperliquid, ChainID.Base];
+
+    if (!validSingleChainChains.includes(chain)) {
+      throw new ValidationError(`Chain ${chain} is not supported for single chain orders`);
+    }
+
+    if (order.chainId === ChainID.Hyperliquid && isNativeEvmToken(order.tokenOut)) {
+      throw new ValidationError('HYPE native token as destination address is not supported.');
+    }
+
+    const client = ChainProvider.getClient(chain);
+    const user = order.user as Address;
 
-    if (allowance < order.sourceTokenAmount) {
-      throw new InsufficientAllowanceError(
-        `Insufficient allowance for token ${order.sourceTokenAddress} on permit2 address ${permit2Address}. Current allowance: ${allowance}. Required allowance: ${order.sourceTokenAmount}`,
+    if (isNativeEvmToken(order.tokenIn)) {
+      throw new ValidationError('Native token is not supported.');
+    }
+
+    const ERC20Contract = getContract({
+      address: order.tokenIn as Address,
+      abi: ERC20ABI,
+      client: {
+        public: client,
+        chain,
+      },
+    });
+
+    const balance = await ERC20Contract.read.balanceOf([user]);
+
+    if (balance < order.amountIn) {
+      throw new InsufficientBalanceError(
+        `Insufficient balance for token ${order.tokenIn}. Current balance: ${balance}. Required balance: ${order.amountIn}`,
       );
     }
+
+    // const permit2Address = PERMIT2_ADDRESS[chain];
+    // const allowance = await ERC20Contract.read.allowance([user, permit2Address]);
+
+    // if (allowance < order.amountIn) {
+    //   throw new InsufficientAllowanceError(
+    //     `Insufficient allowance for token ${order.tokenIn} on permit2 address ${permit2Address}. Current allowance: ${allowance}. Required allowance: ${order.amountIn}`,
+    //   );
+    // }
   }
 }

package/src/core/orders/api/fetch.ts

@@ -0,0 +1,21 @@
+import { AUCTIONEER_URL } from '../../../constants.js';
+import type { ApiResponse, ApiUserOrders } from '../../../types/api.js';
+
+export async function fetchUserOrders(jwtToken: string): Promise<ApiUserOrders> {
+  const url = `${AUCTIONEER_URL}/user_intent`;
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${jwtToken}`,
+    },
+  });
+
+  const data: ApiResponse<ApiUserOrders> = await response.json();
+
+  if (!data.success) {
+    throw new Error(`Failed to fetch user orders: ${data.error}`);
+  }
+
+  return data.data!;
+}

package/src/core/orders/common.ts

@@ -0,0 +1,19 @@
+import { OrderType } from '../../constants.js';
+import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+
+export type ExtraTransfer = {
+  /** Token address */
+  token: string;
+  /** Receiver address */
+  receiver: string;
+  /** Amount of tokens to transfer */
+  amount: bigint;
+};
+
+export function getOrderType(order: SingleChainOrderPrepared | CrossChainOrderPrepared): OrderType {
+  if ('tokenIn' in order.order) {
+    return OrderType.SINGLE_CHAIN_LIMIT;
+  }
+
+  return OrderType.CROSS_CHAIN_LIMIT;
+}