@shogun-sdk/intents-sdk 1.0.1 → 1.0.2

package/src/core/evm/abi/permit2.ts

@@ -0,0 +1,394 @@
+export const PERMIT2_ABI = [
+  {
+    inputs: [
+      {
+        internalType: 'uint256',
+        name: 'maxAmount',
+        type: 'uint256',
+      },
+    ],
+    name: 'InvalidAmount',
+    type: 'error',
+  },
+  {
+    inputs: [],
+    name: 'LengthMismatch',
+    type: 'error',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'word',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'mask',
+        type: 'uint256',
+      },
+    ],
+    name: 'UnorderedNonceInvalidation',
+    type: 'event',
+  },
+  {
+    inputs: [],
+    name: 'DOMAIN_SEPARATOR',
+    outputs: [
+      {
+        internalType: 'bytes32',
+        name: '',
+        type: 'bytes32',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint256',
+        name: 'wordPos',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'mask',
+        type: 'uint256',
+      },
+    ],
+    name: 'invalidateUnorderedNonces',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    name: 'nonceBitmap',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: 'address',
+                name: 'token',
+                type: 'address',
+              },
+              {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+              },
+            ],
+            internalType: 'struct ISignatureTransfer.TokenPermissions',
+            name: 'permitted',
+            type: 'tuple',
+          },
+          {
+            internalType: 'uint256',
+            name: 'nonce',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'deadline',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.PermitTransferFrom',
+        name: 'permit',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'address',
+            name: 'to',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'requestedAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.SignatureTransferDetails',
+        name: 'transferDetails',
+        type: 'tuple',
+      },
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+    ],
+    name: 'permitTransferFrom',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: 'address',
+                name: 'token',
+                type: 'address',
+              },
+              {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+              },
+            ],
+            internalType: 'struct ISignatureTransfer.TokenPermissions[]',
+            name: 'permitted',
+            type: 'tuple[]',
+          },
+          {
+            internalType: 'uint256',
+            name: 'nonce',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'deadline',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.PermitBatchTransferFrom',
+        name: 'permit',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'address',
+            name: 'to',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'requestedAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.SignatureTransferDetails[]',
+        name: 'transferDetails',
+        type: 'tuple[]',
+      },
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+    ],
+    name: 'permitTransferFrom',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: 'address',
+                name: 'token',
+                type: 'address',
+              },
+              {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+              },
+            ],
+            internalType: 'struct ISignatureTransfer.TokenPermissions',
+            name: 'permitted',
+            type: 'tuple',
+          },
+          {
+            internalType: 'uint256',
+            name: 'nonce',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'deadline',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.PermitTransferFrom',
+        name: 'permit',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'address',
+            name: 'to',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'requestedAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.SignatureTransferDetails',
+        name: 'transferDetails',
+        type: 'tuple',
+      },
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'witness',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'string',
+        name: 'witnessTypeString',
+        type: 'string',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+    ],
+    name: 'permitWitnessTransferFrom',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: 'address',
+                name: 'token',
+                type: 'address',
+              },
+              {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+              },
+            ],
+            internalType: 'struct ISignatureTransfer.TokenPermissions[]',
+            name: 'permitted',
+            type: 'tuple[]',
+          },
+          {
+            internalType: 'uint256',
+            name: 'nonce',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'deadline',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.PermitBatchTransferFrom',
+        name: 'permit',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'address',
+            name: 'to',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'requestedAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.SignatureTransferDetails[]',
+        name: 'transferDetails',
+        type: 'tuple[]',
+      },
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'witness',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'string',
+        name: 'witnessTypeString',
+        type: 'string',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+    ],
+    name: 'permitWitnessTransferFrom',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;

package/src/core/evm/abi/source-chain-guard.ts

@@ -1,4 +1,5 @@
-export const SourceChainGuardABI = [
+// NOTE: this ABI file only contains some of the functions to use by the SDK
+export const SOURCE_CHAIN_GUARD_ABI = [
   {
     inputs: [
       {

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

@@ -9,7 +9,7 @@ import { type PermitTransferFrom } from './permit2.js';
 import { ChainProvider } from './viem-provider.js';
 
 export class EVMIntentProvider {
-  private provider: ChainProvider;
+  public provider: ChainProvider;
 
   constructor(config: EVMConfig) {
     this.provider = new ChainProvider(config);

package/src/core/evm/order-signature.ts

@@ -3,6 +3,9 @@ import type { SupportedEvmChain } from '../../chains.js';
 import type { Order } from '../order.js';
 import { EVMIntentProvider } from './intent-provider.js';
 import { PERMIT2_DOMAIN, PERMIT2_TYPES, type PermitTransferFrom } from './permit2.js';
+import type { ApiResponse } from '../../types/api.js';
+import type { PreparedOrder } from '../../types/intent.js';
+import { BaseSDK } from '../sdk.js';
 
 export type EvmOrderTypedData = {
   domain: TypedDataDomain;
@@ -31,3 +34,23 @@ export async function getEvmOrderTypedData(
 
   return { orderTypedData, nonce: randomNonce };
 }
+
+export async function sendEvmRequest({
+  order,
+  signature,
+  nonce,
+}: {
+  order: Order;
+  signature: string;
+  nonce: bigint;
+}): Promise<ApiResponse> {
+  const preparedOrder: PreparedOrder = {
+    order,
+    preparedData: {
+      signature,
+      nonce: nonce.toString(),
+    },
+  };
+
+  return BaseSDK.sendOrder(preparedOrder);
+}

package/src/core/evm/sdk.ts

@@ -7,6 +7,10 @@ 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';
 
 /**
  * EVM-specific SDK implementation
@@ -35,6 +39,98 @@ export class EVMSDK extends BaseSDK {
     this.evmIntentProvider = new EVMIntentProvider(config);
   }
 
+  protected async cancelOrderInternal(orderId: string): Promise<string> {
+    const chainId = this.config.chainId;
+    const auctioneerAddress = SRC_CHAIN_GUARD[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 orderIdHex = 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!),
+      };
+
+      const tx = await auctioneerContract.write.cancelOrder([orderInfo]);
+      txHash = tx;
+    } else {
+      const nonce = BigInt(userOrder.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');
+      }
+
+      const tx = await permit2Contract.write.invalidateUnorderedNonces([nonceWordPos, mask]);
+      txHash = tx;
+    }
+
+    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}`;
+
+    const response = await fetch(`${siweEndpoint}${queryParams}`);
+    const { data: message } = await response.json();
+
+    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 { data: token } = await jwt.json();
+
+    const ordersUrl = `${AUCTIONEER_URL}/user_intent`;
+    const orders = await fetch(ordersUrl, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+
+    const { data: ordersData } = await orders.json();
+
+    return ordersData;
+  }
+
   /**
    * Gets the user's Ethereum address derived from their private key
    *

package/src/core/evm/viem-provider.ts

@@ -16,6 +16,8 @@ import { arbitrum, base, optimism } from 'viem/chains';
 import { ChainID, type SupportedEvmChain } from '../../chains.js';
 import type { EVMConfig } from '../../config.js';
 import { ERC20ABI } from './abi/erc20.js';
+import { SOURCE_CHAIN_GUARD_ABI } from './abi/source-chain-guard.js';
+import { PERMIT2_ABI } from './abi/permit2.js';
 
 const chainIdToProviderChainMap = {
   [ChainID.Arbitrum]: arbitrum,
@@ -64,6 +66,33 @@ export class ChainProvider {
     });
   }
 
+  getPermit2Contract(permit2Address: Address) {
+    return getContract({
+      address: permit2Address,
+      abi: PERMIT2_ABI,
+      client: {
+        wallet: this.walletClient,
+        public: this.publicClient,
+        chain: chainIdToProviderChainMap[this.chainId],
+        account: this.walletClient.account,
+      },
+    });
+  }
+
+  // Any type since the inferred type of this node exceeds the maximum length the compiler will serialize
+  getAuctioneerContract(auctioneerAddress: Address): any {
+    return getContract({
+      address: auctioneerAddress,
+      abi: SOURCE_CHAIN_GUARD_ABI,
+      client: {
+        wallet: this.walletClient,
+        public: this.publicClient,
+        chain: chainIdToProviderChainMap[this.chainId],
+        account: this.walletClient.account,
+      },
+    });
+  }
+
   getERC20Contract(tokenAddress: Address) {
     return getContract({
       address: tokenAddress,

package/src/core/sdk.ts

@@ -1,6 +1,7 @@
 import { chainIdToChainTypeMap } from '../chains.js';
-import { AUCTIONEER_URL,  } from '../constants.js';
-import {  NetworkError } from '../errors/index.js';
+import { AUCTIONEER_URL } from '../constants.js';
+import { NetworkError } from '../errors/index.js';
+import type { ApiResponse } from '../types/api.js';
 import type { CreateOrderParams, PreparedOrder, UserIntentRequest } from '../types/intent.js';
 import { calculateAmounts } from '../utils/defillama.js';
 import { Parsers } from '../utils/parsers.js';
@@ -22,6 +23,8 @@ export abstract class BaseSDK {
    */
   public abstract getUserAddress(): Promise<string>;
 
+  protected abstract cancelOrderInternal(orderId: string): Promise<string>;
+
   /**
    * Prepares an order for submission with chain-specific logic
    *
@@ -58,14 +61,15 @@ export abstract class BaseSDK {
 
     if (!params.minStablecoinAmount || !params.destinationTokenMinAmount) {
       // Calculate missing values using DefiLlama
-      const { amountOut: calculatedAmountOut, minStablecoinsAmount: calculatedMinStablecoins } =
-        await calculateAmounts({
+      const { amountOut: calculatedAmountOut, minStablecoinsAmount: calculatedMinStablecoins } = await calculateAmounts(
+        {
           srcChainId: params.sourceChainId,
           tokenIn: params.sourceTokenAddress,
           amountIn: params.sourceTokenAmount,
           destChainId: params.destinationChainId,
           tokenOut: params.destinationTokenAddress,
-        });
+        },
+      );
 
       // Use provided values if available, otherwise use calculated ones
       minStablecoinAmount = params.minStablecoinAmount ?? calculatedMinStablecoins;
@@ -94,6 +98,10 @@ export abstract class BaseSDK {
     return this.prepareOrder(order);
   }
 
+  public async cancelOrder(orderId: string): Promise<string> {
+    return this.cancelOrderInternal(orderId);
+  }
+
   /**
    * Creates an order and sends it to the auctioneer in a single call
    *
@@ -105,9 +113,9 @@ export abstract class BaseSDK {
    * @throws {OrderCreationError} If order creation fails
    * @throws {NetworkError} If order submission fails
    */
-  public async createAndSendOrder(params: CreateOrderParams): Promise<Response> {
+  public async createAndSendOrder(params: CreateOrderParams): Promise<ApiResponse> {
     const preparedOrder = await this.createOrder(params);
-    return this.sendOrder(preparedOrder);
+    return BaseSDK.sendOrder(preparedOrder);
   }
 
   /**
@@ -122,7 +130,7 @@ export abstract class BaseSDK {
    * @returns User intent request object ready for submission to the auctioneer
    * @throws {BaseError} If conversion fails
    */
-  private getUserIntentRequest(preparedOrder: PreparedOrder): UserIntentRequest {
+  public static getUserIntentRequest(preparedOrder: PreparedOrder): UserIntentRequest {
     const sourceChain = preparedOrder.order.sourceChainId;
     const sourceChainType = chainIdToChainTypeMap[sourceChain];
     const executionDetails = preparedOrder.order.getExecutionDetails();
@@ -149,8 +157,8 @@ export abstract class BaseSDK {
    * @returns Promise resolving to the specific-chain tx hash
    * @throws {NetworkError} If the network request fails or returns an error
    */
-  public async sendOrder(preparedOrder: PreparedOrder): Promise<Response> {
-    const intentRequest = this.getUserIntentRequest(preparedOrder);
+  public static async sendOrder(preparedOrder: PreparedOrder): Promise<ApiResponse> {
+    const intentRequest = BaseSDK.getUserIntentRequest(preparedOrder);
     const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
 
     const url = `${AUCTIONEER_URL}/user_intent`;
@@ -163,7 +171,7 @@ export abstract class BaseSDK {
     });
 
     if (!response.ok) {
-      const errorJson = await response.json();
+      const errorJson: ApiResponse = await response.json();
 
       const extraErrorData = errorJson.extra_error_data;
       throw new NetworkError(`Server error`, {
@@ -173,6 +181,6 @@ export abstract class BaseSDK {
       });
     }
 
-    return response;
+    return response.json();
   }
 }