@shogun-sdk/swap 0.0.2-test.27 → 0.0.2-test.29

package/dist/react.d.cts

@@ -1,9 +1,9 @@
 import React from 'react';
-import { S as SwapSDKConfig, a as SwapSDK, b as SwapQuoteParams, c as SwapQuoteResponse, E as ExecuteOrderParams, d as Stage, P as PlaceOrderResult, T as TokenInfo, B as BalanceRequestParams, e as BalanceResponse } from './index-CmsKzdEu.cjs';
-export { C as ChainId, O as OrderExecutionType, j as SupportedChain, g as SupportedChains, h as TokenBalance, f as buildQuoteParams, i as isEvmChain } from './index-CmsKzdEu.cjs';
+import { S as SwapSDKConfig, a as SwapSDK, b as SwapQuoteParams, c as SwapQuoteResponse, E as ExecuteOrderParams, d as Stage, P as PlaceOrderResult, T as TokenInfo, B as BalanceRequestParams, e as BalanceResponse } from './index-6Wt_Nfub.cjs';
+export { C as ChainId, O as OrderExecutionType, j as SupportedChain, g as SupportedChains, h as TokenBalance, f as buildQuoteParams, i as isEvmChain } from './index-6Wt_Nfub.cjs';
 import { WalletClient } from 'viem';
 import { A as AdaptedWallet } from './wallet-B9bKceyN.cjs';
-import { ApiUserOrders } from '@shogun-sdk/intents-sdk';
+import { ApiUserOrders, ApiCrossChainOrder, ApiSingleChainOrder } from '@shogun-sdk/intents-sdk';
 import '@solana/web3.js';
 
 /**
@@ -297,4 +297,32 @@ declare function useOrders(initialAddresses?: {
     } | null;
 };
 
-export { BalanceRequestParams, BalanceResponse, SwapProvider, SwapQuoteParams, SwapQuoteResponse, useBalances, useExecuteTransaction, useOrders, useQuote, useSwap, useTokenList, useTokensData };
+/**
+ * `useCancelOrder`
+ *
+ * React hook to cancel an intents order (single-chain or cross-chain) on EVM or Solana.
+ * Returns helpers for loading/error state and the resulting transaction hash/signature.
+ *
+ * @example
+ * ```tsx
+ * const { cancel, isLoading, error, result } = useCancelOrder();
+ *
+ * await cancel({
+ *   order,
+ *   wallet,    // AdaptedWallet instance
+ *   solRpc: "https://api.mainnet-beta.solana.com",
+ * });
+ * ```
+ */
+declare function useCancelOrder(): {
+    cancel: (params: {
+        order: ApiCrossChainOrder | ApiSingleChainOrder;
+        wallet: AdaptedWallet;
+        solRpc: string;
+    }) => Promise<string>;
+    isLoading: boolean;
+    error: string | null;
+    result: string | null;
+};
+
+export { BalanceRequestParams, BalanceResponse, SwapProvider, SwapQuoteParams, SwapQuoteResponse, useBalances, useCancelOrder, useExecuteTransaction, useOrders, useQuote, useSwap, useTokenList, useTokensData };

package/dist/react.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
-import { S as SwapSDKConfig, a as SwapSDK, b as SwapQuoteParams, c as SwapQuoteResponse, E as ExecuteOrderParams, d as Stage, P as PlaceOrderResult, T as TokenInfo, B as BalanceRequestParams, e as BalanceResponse } from './index-Qoc6Q9XN.js';
-export { C as ChainId, O as OrderExecutionType, j as SupportedChain, g as SupportedChains, h as TokenBalance, f as buildQuoteParams, i as isEvmChain } from './index-Qoc6Q9XN.js';
+import { S as SwapSDKConfig, a as SwapSDK, b as SwapQuoteParams, c as SwapQuoteResponse, E as ExecuteOrderParams, d as Stage, P as PlaceOrderResult, T as TokenInfo, B as BalanceRequestParams, e as BalanceResponse } from './index-DdO3mOAE.js';
+export { C as ChainId, O as OrderExecutionType, j as SupportedChain, g as SupportedChains, h as TokenBalance, f as buildQuoteParams, i as isEvmChain } from './index-DdO3mOAE.js';
 import { WalletClient } from 'viem';
 import { A as AdaptedWallet } from './wallet-B9bKceyN.js';
-import { ApiUserOrders } from '@shogun-sdk/intents-sdk';
+import { ApiUserOrders, ApiCrossChainOrder, ApiSingleChainOrder } from '@shogun-sdk/intents-sdk';
 import '@solana/web3.js';
 
 /**
@@ -297,4 +297,32 @@ declare function useOrders(initialAddresses?: {
     } | null;
 };
 
-export { BalanceRequestParams, BalanceResponse, SwapProvider, SwapQuoteParams, SwapQuoteResponse, useBalances, useExecuteTransaction, useOrders, useQuote, useSwap, useTokenList, useTokensData };
+/**
+ * `useCancelOrder`
+ *
+ * React hook to cancel an intents order (single-chain or cross-chain) on EVM or Solana.
+ * Returns helpers for loading/error state and the resulting transaction hash/signature.
+ *
+ * @example
+ * ```tsx
+ * const { cancel, isLoading, error, result } = useCancelOrder();
+ *
+ * await cancel({
+ *   order,
+ *   wallet,    // AdaptedWallet instance
+ *   solRpc: "https://api.mainnet-beta.solana.com",
+ * });
+ * ```
+ */
+declare function useCancelOrder(): {
+    cancel: (params: {
+        order: ApiCrossChainOrder | ApiSingleChainOrder;
+        wallet: AdaptedWallet;
+        solRpc: string;
+    }) => Promise<string>;
+    isLoading: boolean;
+    error: string | null;
+    result: string | null;
+};
+
+export { BalanceRequestParams, BalanceResponse, SwapProvider, SwapQuoteParams, SwapQuoteResponse, useBalances, useCancelOrder, useExecuteTransaction, useOrders, useQuote, useSwap, useTokenList, useTokensData };

package/dist/react.js

@@ -949,6 +949,304 @@ async function getOrders({
   return orders;
 }
 
+// src/core/orders/cancelOrder.ts
+import {
+  cancelCrossChainOrderInstructionsAsBytes,
+  cancelSingleChainOrderInstructionsAsBytes,
+  ChainID as ChainID3,
+  CROSS_CHAIN_GUARD_ADDRESSES,
+  PERMIT2_ADDRESS as PERMIT2_ADDRESS2,
+  SINGLE_CHAIN_GUARD_ADDRESSES
+} from "@shogun-sdk/intents-sdk";
+import {
+  VersionedMessage,
+  VersionedTransaction as VersionedTransaction2
+} from "@solana/web3.js";
+import { encodeFunctionData as encodeFunctionData3 } from "viem";
+async function cancelIntentsOrder({
+  order,
+  wallet,
+  sol_rpc
+}) {
+  const isCrossChain = "srcChainId" in order && "destChainId" in order && order.srcChainId !== order.destChainId;
+  const srcChain = "srcChainId" in order ? order.srcChainId : order.chainId;
+  const isSolanaOrder = srcChain === ChainID3.Solana;
+  if (isSolanaOrder) {
+    if (!isCrossChain) {
+      const { versionedMessageBytes: versionedMessageBytes2 } = await cancelSingleChainOrderInstructionsAsBytes(
+        order.orderId,
+        order.user,
+        { rpcUrl: sol_rpc }
+      );
+      const message2 = VersionedMessage.deserialize(
+        versionedMessageBytes2
+      );
+      const tx2 = new VersionedTransaction2(message2);
+      return await wallet.sendTransaction(tx2);
+    }
+    const { versionedMessageBytes } = await cancelCrossChainOrderInstructionsAsBytes(
+      order.orderId,
+      order.user,
+      { rpcUrl: sol_rpc }
+    );
+    const message = VersionedMessage.deserialize(
+      versionedMessageBytes
+    );
+    const tx = new VersionedTransaction2(message);
+    return await wallet.sendTransaction(tx);
+  }
+  const chainId = srcChain;
+  const { readContract } = wallet;
+  if (!readContract) {
+    throw new Error("Wallet does not support readContract");
+  }
+  const nonce = BigInt(order.nonce ?? "0");
+  const nonceWordPos = nonce >> 8n;
+  const nonceBitPos = nonce - nonceWordPos * 256n;
+  if (isCrossChain) {
+    const [orderData = [false, false], currentNonceBitmap = 0n] = await Promise.all([
+      readContract({
+        address: CROSS_CHAIN_GUARD_ADDRESSES[chainId],
+        abi: [
+          {
+            inputs: [{ name: "orderId", type: "bytes32" }],
+            name: "orderData",
+            outputs: [
+              { name: "initialized", type: "bool" },
+              { name: "deactivated", type: "bool" }
+            ],
+            stateMutability: "view",
+            type: "function"
+          }
+        ],
+        functionName: "orderData",
+        args: [order.orderId]
+      }),
+      readContract({
+        address: PERMIT2_ADDRESS2[chainId],
+        abi: [
+          {
+            inputs: [
+              { name: "owner", type: "address" },
+              { name: "wordPos", type: "uint256" }
+            ],
+            name: "nonceBitmap",
+            outputs: [{ name: "", type: "uint256" }],
+            stateMutability: "view",
+            type: "function"
+          }
+        ],
+        functionName: "nonceBitmap",
+        args: [order.user, nonceWordPos]
+      })
+    ]);
+    const [initialized, deactivated] = orderData;
+    if (initialized) {
+      if (deactivated) {
+        throw new Error("Order is already deactivated");
+      }
+      return await wallet.sendTransaction({
+        to: CROSS_CHAIN_GUARD_ADDRESSES[order.srcChainId],
+        data: encodeFunctionData3({
+          abi: [
+            {
+              inputs: [
+                {
+                  components: [
+                    { name: "user", type: "address" },
+                    { name: "tokenIn", type: "address" },
+                    { name: "srcChainId", type: "uint256" },
+                    { name: "deadline", type: "uint256" },
+                    { name: "amountIn", type: "uint256" },
+                    { name: "minStablecoinsAmount", type: "uint256" },
+                    { name: "executionDetailsHash", type: "bytes32" },
+                    { name: "nonce", type: "uint256" }
+                  ],
+                  name: "orderInfo",
+                  type: "tuple"
+                }
+              ],
+              name: "cancelOrder",
+              outputs: [],
+              stateMutability: "nonpayable",
+              type: "function"
+            }
+          ],
+          functionName: "cancelOrder",
+          args: [
+            {
+              user: order.user,
+              tokenIn: order.tokenIn,
+              srcChainId: BigInt(order.srcChainId),
+              deadline: BigInt(order.deadline),
+              amountIn: BigInt(order.amountIn),
+              minStablecoinsAmount: BigInt(order.minStablecoinsAmount),
+              executionDetailsHash: order.executionDetailsHash,
+              nonce
+            }
+          ]
+        }),
+        value: BigInt(0),
+        from: order.user
+      });
+    } else {
+      if ((currentNonceBitmap & 1n << nonceBitPos) !== 0n) {
+        throw new Error("Nonce is already invalidated");
+      }
+      const mask2 = 1n << nonceBitPos;
+      return await wallet.sendTransaction({
+        to: PERMIT2_ADDRESS2[order.srcChainId],
+        data: encodeFunctionData3({
+          abi: [
+            {
+              inputs: [
+                { name: "wordPos", type: "uint256" },
+                { name: "mask", type: "uint256" }
+              ],
+              name: "invalidateUnorderedNonces",
+              outputs: [],
+              stateMutability: "nonpayable",
+              type: "function"
+            }
+          ],
+          functionName: "invalidateUnorderedNonces",
+          args: [nonceWordPos, mask2]
+        }),
+        value: BigInt(0),
+        from: order.user
+      });
+    }
+  }
+  const [wasManuallyInitialized, currentBitmap = 0n] = await Promise.all([
+    readContract({
+      address: SINGLE_CHAIN_GUARD_ADDRESSES[chainId],
+      abi: [
+        {
+          inputs: [{ name: "orderHash", type: "bytes32" }],
+          name: "orderManuallyInitialized",
+          outputs: [{ name: "", type: "bool" }],
+          stateMutability: "view",
+          type: "function"
+        }
+      ],
+      functionName: "orderManuallyInitialized",
+      args: [order.orderId]
+    }),
+    readContract({
+      address: PERMIT2_ADDRESS2[chainId],
+      abi: [
+        {
+          inputs: [
+            { name: "owner", type: "address" },
+            { name: "wordPos", type: "uint256" }
+          ],
+          name: "nonceBitmap",
+          outputs: [{ name: "", type: "uint256" }],
+          stateMutability: "view",
+          type: "function"
+        }
+      ],
+      functionName: "nonceBitmap",
+      args: [order.user, nonceWordPos]
+    })
+  ]);
+  if (wasManuallyInitialized) {
+    return await wallet.sendTransaction({
+      to: SINGLE_CHAIN_GUARD_ADDRESSES[chainId],
+      data: encodeFunctionData3({
+        abi: [
+          {
+            inputs: [
+              {
+                name: "order",
+                type: "tuple",
+                components: [
+                  { name: "amountIn", type: "uint256" },
+                  { name: "tokenIn", type: "address" },
+                  { name: "deadline", type: "uint256" },
+                  { name: "nonce", type: "uint256" },
+                  { name: "encodedExternalCallData", type: "bytes" },
+                  {
+                    name: "extraTransfers",
+                    type: "tuple[]",
+                    components: [
+                      { name: "amount", type: "uint256" },
+                      { name: "receiver", type: "address" },
+                      { name: "token", type: "address" }
+                    ]
+                  },
+                  {
+                    name: "requestedOutput",
+                    type: "tuple",
+                    components: [
+                      { name: "amount", type: "uint256" },
+                      { name: "receiver", type: "address" },
+                      { name: "token", type: "address" }
+                    ]
+                  },
+                  { name: "user", type: "address" }
+                ]
+              }
+            ],
+            name: "cancelManuallyCreatedOrder",
+            outputs: [],
+            stateMutability: "nonpayable",
+            type: "function"
+          }
+        ],
+        functionName: "cancelManuallyCreatedOrder",
+        args: [
+          {
+            amountIn: BigInt(order.amountIn),
+            tokenIn: order.tokenIn,
+            deadline: BigInt(order.deadline),
+            nonce,
+            encodedExternalCallData: "0x",
+            extraTransfers: (order.extraTransfers || []).map((t) => ({
+              amount: BigInt(t.amount),
+              receiver: t.receiver,
+              token: t.token
+            })),
+            requestedOutput: {
+              amount: BigInt(order.amountOutMin),
+              receiver: order.destinationAddress,
+              token: order.tokenOut
+            },
+            user: order.user
+          }
+        ]
+      }),
+      value: 0n,
+      from: order.user
+    });
+  }
+  const mask = 1n << nonceBitPos;
+  if ((currentBitmap & mask) !== 0n) {
+    throw new Error("Nonce is already invalidated");
+  }
+  return await wallet.sendTransaction({
+    to: PERMIT2_ADDRESS2[chainId],
+    data: encodeFunctionData3({
+      abi: [
+        {
+          inputs: [
+            { name: "wordPos", type: "uint256" },
+            { name: "mask", type: "uint256" }
+          ],
+          name: "invalidateUnorderedNonces",
+          outputs: [],
+          stateMutability: "nonpayable",
+          type: "function"
+        }
+      ],
+      functionName: "invalidateUnorderedNonces",
+      args: [nonceWordPos, mask]
+    }),
+    value: 0n,
+    from: order.user
+  });
+}
+
 // src/core/client.ts
 var SwapSDK = class {
   constructor(config) {
@@ -1109,6 +1407,25 @@ var SwapSDK = class {
   async getOrders(params) {
     return getOrders(params);
   }
+  /**
+   * Cancels an order (single-chain or cross-chain) on EVM or Solana.
+   *
+   * Internally routes to the correct guard contract or Solana program to
+   * deactivate the order or invalidate its nonce.
+   *
+   * @param params.order - Order payload returned from the Intents API.
+   * @param params.wallet - Adapted wallet used to submit the cancellation transaction.
+   * @param params.solRpc - Solana RPC URL used for SVM cancellations.
+   *
+   * @returns A transaction signature or hash from the underlying wallet.
+   */
+  async cancelOrder(params) {
+    return cancelIntentsOrder({
+      order: params.order,
+      wallet: params.wallet,
+      sol_rpc: params.solRpc
+    });
+  }
 };
 
 // src/react/SwapProvider.tsx
@@ -1523,6 +1840,46 @@ function useOrders(initialAddresses) {
     [data, loading, error, refetch, setAddresses]
   );
 }
+
+// src/react/useCancelOrder.ts
+import { useCallback as useCallback6, useState as useState4 } from "react";
+import { mutate as mutate4 } from "swr";
+function useCancelOrder() {
+  const sdk = useSwap();
+  const [isLoading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [result, setResult] = useState4(null);
+  const cancel = useCallback6(
+    async (params) => {
+      setLoading(true);
+      setError(null);
+      setResult(null);
+      try {
+        const tx = await sdk.cancelOrder({
+          order: params.order,
+          wallet: params.wallet,
+          solRpc: params.solRpc
+        });
+        setResult(tx);
+        void mutate4("orders-global");
+        return tx;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        setError(msg);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [sdk]
+  );
+  return {
+    cancel,
+    isLoading,
+    error,
+    result
+  };
+}
 export {
   ChainId,
   OrderExecutionType,
@@ -1531,6 +1888,7 @@ export {
   buildQuoteParams,
   isEvmChain,
   useBalances,
+  useCancelOrder,
   useExecuteTransaction,
   useOrders,
   useQuote,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shogun-sdk/swap",
-  "version": "0.0.2-test.27",
+  "version": "0.0.2-test.29",
   "type": "module",
   "description": "Shogun Network Swap utilities and helpers",
   "author": "Shogun Network",