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

package/dist/index.js

@@ -946,6 +946,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) {
@@ -1106,6 +1404,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
+    });
+  }
 };
 export {
   ChainId,

package/dist/react.cjs

@@ -39,6 +39,7 @@ __export(react_exports, {
   buildQuoteParams: () => buildQuoteParams,
   isEvmChain: () => isEvmChain,
   useBalances: () => useBalances,
+  useCancelOrder: () => useCancelOrder,
   useExecuteTransaction: () => useExecuteTransaction,
   useOrders: () => useOrders,
   useQuote: () => useQuote,
@@ -986,6 +987,294 @@ async function getOrders({
   return orders;
 }
 
+// src/core/orders/cancelOrder.ts
+var import_intents_sdk14 = require("@shogun-sdk/intents-sdk");
+var import_web32 = require("@solana/web3.js");
+var import_viem8 = require("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 === import_intents_sdk14.ChainID.Solana;
+  if (isSolanaOrder) {
+    if (!isCrossChain) {
+      const { versionedMessageBytes: versionedMessageBytes2 } = await (0, import_intents_sdk14.cancelSingleChainOrderInstructionsAsBytes)(
+        order.orderId,
+        order.user,
+        { rpcUrl: sol_rpc }
+      );
+      const message2 = import_web32.VersionedMessage.deserialize(
+        versionedMessageBytes2
+      );
+      const tx2 = new import_web32.VersionedTransaction(message2);
+      return await wallet.sendTransaction(tx2);
+    }
+    const { versionedMessageBytes } = await (0, import_intents_sdk14.cancelCrossChainOrderInstructionsAsBytes)(
+      order.orderId,
+      order.user,
+      { rpcUrl: sol_rpc }
+    );
+    const message = import_web32.VersionedMessage.deserialize(
+      versionedMessageBytes
+    );
+    const tx = new import_web32.VersionedTransaction(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: import_intents_sdk14.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: import_intents_sdk14.PERMIT2_ADDRESS[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: import_intents_sdk14.CROSS_CHAIN_GUARD_ADDRESSES[order.srcChainId],
+        data: (0, import_viem8.encodeFunctionData)({
+          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: import_intents_sdk14.PERMIT2_ADDRESS[order.srcChainId],
+        data: (0, import_viem8.encodeFunctionData)({
+          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: import_intents_sdk14.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: import_intents_sdk14.PERMIT2_ADDRESS[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: import_intents_sdk14.SINGLE_CHAIN_GUARD_ADDRESSES[chainId],
+      data: (0, import_viem8.encodeFunctionData)({
+        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: import_intents_sdk14.PERMIT2_ADDRESS[chainId],
+    data: (0, import_viem8.encodeFunctionData)({
+      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) {
@@ -1146,6 +1435,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
@@ -1560,3 +1868,43 @@ function useOrders(initialAddresses) {
     [data, loading, error, refetch, setAddresses]
   );
 }
+
+// src/react/useCancelOrder.ts
+var import_react8 = require("react");
+var import_swr4 = require("swr");
+function useCancelOrder() {
+  const sdk = useSwap();
+  const [isLoading, setLoading] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const [result, setResult] = (0, import_react8.useState)(null);
+  const cancel = (0, import_react8.useCallback)(
+    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 (0, import_swr4.mutate)("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
+  };
+}