@pear-protocol/symmio-client 0.3.18 → 0.3.20

package/dist/react/index.js

@@ -1718,6 +1718,12 @@ function validateAddress(address, name) {
   return address;
 }
 function validateAmount(amount, name) {
+  if (typeof amount !== "bigint") {
+    throw new SymmioSDKError(
+      `${name} must be a bigint, got ${amount === void 0 ? "undefined" : typeof amount} (${amount})`,
+      "INVALID_AMOUNT"
+    );
+  }
   if (amount <= 0n) {
     throw new SymmioSDKError(
       `${name} must be a positive amount, got ${amount}`,
@@ -2664,288 +2670,24 @@ function useSymmDepositAndAllocateMutation(params = {}, options) {
     }
   });
 }
-
-// src/abis/WithdrawFacet.ts
-var WithdrawFacetABI = [
-  // ─── Mutations ──────────────────────────────────────────────────
-  {
-    type: "function",
-    name: "initiateWithdraw",
-    stateMutability: "nonpayable",
-    inputs: [
-      {
-        name: "parts",
-        type: "tuple[]",
-        internalType: "struct WithdrawReceiverPart[]",
-        components: [
-          { name: "id", type: "uint256", internalType: "uint256" },
-          { name: "amount", type: "uint256", internalType: "uint256" },
-          { name: "chainId", type: "int256", internalType: "int256" },
-          { name: "receiver", type: "bytes", internalType: "bytes" },
-          { name: "virtualProvider", type: "address", internalType: "address" },
-          { name: "expressProvider", type: "address", internalType: "address" }
-        ]
-      },
-      { name: "speedUp", type: "bool", internalType: "bool" },
-      { name: "data", type: "bytes", internalType: "bytes" }
-    ],
-    outputs: [
-      { name: "requestId", type: "uint256", internalType: "uint256" },
-      { name: "cooldownEndTime", type: "uint256", internalType: "uint256" }
-    ]
-  },
-  {
-    type: "function",
-    name: "finalizeWithdrawRequest",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "user", type: "address", internalType: "address" },
-      { name: "requestId", type: "uint256", internalType: "uint256" }
-    ],
-    outputs: []
-  },
-  {
-    type: "function",
-    name: "requestCancelWithdraw",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "requestId", type: "uint256", internalType: "uint256" }],
-    outputs: []
-  },
-  // ─── Views ──────────────────────────────────────────────────────
-  {
-    type: "function",
-    name: "getWithdrawableTime",
-    stateMutability: "view",
-    inputs: [{ name: "user", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }]
-  },
-  {
-    type: "function",
-    name: "getLastWithdrawRequestId",
-    stateMutability: "view",
-    inputs: [{ name: "user", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }]
-  },
-  {
-    type: "function",
-    name: "isSpeedUpEligible",
-    stateMutability: "view",
-    inputs: [{ name: "user", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }]
-  },
-  {
-    type: "function",
-    name: "isExpressProviderRegistered",
-    stateMutability: "view",
-    inputs: [{ name: "provider", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }]
-  },
-  {
-    type: "function",
-    name: "isVirtualProviderRegistered",
-    stateMutability: "view",
-    inputs: [{ name: "provider", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }]
-  },
-  // ─── Events ─────────────────────────────────────────────────────
-  {
-    type: "event",
-    name: "WithdrawInitiated",
-    anonymous: false,
-    inputs: [
-      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
-      { name: "user", type: "address", indexed: true, internalType: "address" },
-      {
-        name: "parts",
-        type: "tuple[]",
-        indexed: false,
-        internalType: "struct WithdrawReceiverPart[]",
-        components: [
-          { name: "id", type: "uint256", internalType: "uint256" },
-          { name: "amount", type: "uint256", internalType: "uint256" },
-          { name: "chainId", type: "int256", internalType: "int256" },
-          { name: "receiver", type: "bytes", internalType: "bytes" },
-          { name: "virtualProvider", type: "address", internalType: "address" },
-          { name: "expressProvider", type: "address", internalType: "address" }
-        ]
-      },
-      { name: "speedUp", type: "bool", indexed: false, internalType: "bool" },
-      { name: "providerData", type: "bytes", indexed: false, internalType: "bytes" },
-      { name: "cooldownEndTime", type: "uint256", indexed: false, internalType: "uint256" }
-    ]
-  },
-  {
-    type: "event",
-    name: "WithdrawAccepted",
-    anonymous: false,
-    inputs: [
-      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
-      { name: "user", type: "address", indexed: true, internalType: "address" }
-    ]
-  },
-  {
-    type: "event",
-    name: "WithdrawFinalized",
-    anonymous: false,
-    inputs: [
-      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
-      { name: "user", type: "address", indexed: true, internalType: "address" }
-    ]
-  },
-  {
-    type: "event",
-    name: "WithdrawCancelRequested",
-    anonymous: false,
-    inputs: [
-      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
-      { name: "user", type: "address", indexed: true, internalType: "address" }
-    ]
-  },
-  {
-    type: "event",
-    name: "WithdrawCancelled",
-    anonymous: false,
-    inputs: [
-      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
-      { name: "user", type: "address", indexed: true, internalType: "address" }
-    ]
-  },
-  {
-    type: "event",
-    name: "WithdrawRejected",
-    anonymous: false,
-    inputs: [
-      { name: "requestId", type: "uint256", indexed: false, internalType: "uint256" },
-      { name: "user", type: "address", indexed: false, internalType: "address" }
-    ]
-  },
-  {
-    type: "event",
-    name: "WithdrawSuspended",
-    anonymous: false,
-    inputs: [
-      { name: "requestId", type: "uint256", indexed: false, internalType: "uint256" },
-      { name: "user", type: "address", indexed: false, internalType: "address" }
-    ]
-  },
-  {
-    type: "event",
-    name: "WithdrawSpeedUpAccepted",
-    anonymous: false,
-    inputs: [
-      { name: "requestId", type: "uint256", indexed: false, internalType: "uint256" },
-      { name: "user", type: "address", indexed: false, internalType: "address" },
-      { name: "newCooldown", type: "uint256", indexed: false, internalType: "uint256" }
-    ]
-  }
-];
-
-// src/types/withdraw.ts
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-function wrapInProxyCall(accountDiamondAbi, subAccount, callDatas) {
+function prepareWithdraw(multiAccount, account, params) {
+  validateAmount(params.amount, "withdraw amount");
+  validateAddress(params.account, "account");
   const data = viem.encodeFunctionData({
-    abi: accountDiamondAbi,
-    functionName: "_call",
-    args: [subAccount, callDatas]
-  });
-  return {
-    functionName: "_call",
-    args: [subAccount, callDatas],
-    data
-  };
-}
-
-// src/actions/withdraw.ts
-function buildExpressWithdrawPart(amount, chainId, receiver, expressProvider, partId = 0n) {
-  return {
-    id: partId,
-    amount,
-    chainId,
-    receiver,
-    virtualProvider: ZERO_ADDRESS,
-    expressProvider
-  };
-}
-function validateParts(parts) {
-  if (parts.length === 0) {
-    throw new Error("initiateWithdraw: at least one withdraw part is required");
-  }
-  for (const part of parts) {
-    validateAmount(part.amount, "withdraw part amount");
-    if (part.expressProvider !== ZERO_ADDRESS && part.expressProvider === part.virtualProvider) {
-      throw new Error(
-        "initiateWithdraw: a single provider cannot be set as both express and virtual"
-      );
-    }
-  }
-}
-function prepareInitiateWithdraw(multiAccount, account, subAccount, params) {
-  validateParts(params.parts);
-  const innerData = viem.encodeFunctionData({
-    abi: WithdrawFacetABI,
-    functionName: "initiateWithdraw",
-    args: [params.parts, params.speedUp, params.providerData]
-  });
-  const proxy = wrapInProxyCall(MultiAccountABI, subAccount, [innerData]);
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
-  };
-}
-function prepareFinalizeWithdraw(multiAccount, account, subAccount, params) {
-  validateAddress(params.user, "user");
-  const innerData = viem.encodeFunctionData({
-    abi: WithdrawFacetABI,
-    functionName: "finalizeWithdrawRequest",
-    args: [params.user, params.requestId]
-  });
-  const proxy = wrapInProxyCall(MultiAccountABI, subAccount, [innerData]);
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
-  };
-}
-function prepareRequestCancelWithdraw(multiAccount, account, subAccount, params) {
-  const innerData = viem.encodeFunctionData({
-    abi: WithdrawFacetABI,
-    functionName: "requestCancelWithdraw",
-    args: [params.requestId]
+    abi: MultiAccountABI,
+    functionName: "withdrawFromAccount",
+    args: [params.account, params.amount]
   });
-  const proxy = wrapInProxyCall(MultiAccountABI, subAccount, [innerData]);
   return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+    functionName: "withdrawFromAccount",
+    args: [params.account, params.amount],
+    config: { account, to: multiAccount, data, value: 0n }
   };
 }
-async function initiateWithdraw(walletClient, publicClient, multiAccount, subAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareInitiateWithdraw(multiAccount, account, subAccount, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function finalizeWithdraw(walletClient, publicClient, multiAccount, subAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareFinalizeWithdraw(multiAccount, account, subAccount, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function requestCancelWithdraw(walletClient, publicClient, multiAccount, subAccount, params) {
+async function withdraw(walletClient, publicClient, multiAccount, params) {
   const account = walletClient.account?.address;
   if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareRequestCancelWithdraw(multiAccount, account, subAccount, params);
+  const prepared = prepareWithdraw(multiAccount, account, params);
   const gas = await publicClient.estimateGas(prepared.config);
   return walletClient.sendTransaction({
     ...prepared.config,
@@ -2955,201 +2697,26 @@ async function requestCancelWithdraw(walletClient, publicClient, multiAccount, s
 }
 
 // src/react/hooks/use-symm-withdraw.ts
-function useResolvedWithdrawConfig(params) {
+function useSymmWithdraw(params = {}, options) {
   const { chainId, symmioConfig } = useSymmContext();
-  const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
-  return {
-    multiAccount,
-    publicClient: params.publicClient,
-    walletClient: params.walletClient,
-    contextSubAccount: params.subAccount
-  };
-}
-function useSymmInitiateWithdraw(params = {}, options) {
-  const queryClient = reactQuery.useQueryClient();
-  const { multiAccount, publicClient, walletClient, contextSubAccount } = useResolvedWithdrawConfig(params);
-  return reactQuery.useMutation({
-    ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => invalidateBalances(queryClient)
-    }),
-    mutationFn: async (vars) => {
-      if (!walletClient || !publicClient) throw new Error("Clients not available");
-      const subAccount = vars.subAccount ?? contextSubAccount;
-      if (!subAccount) throw new Error("subAccount required");
-      return initiateWithdraw(walletClient, publicClient, multiAccount, subAccount, {
-        parts: vars.parts,
-        speedUp: vars.speedUp,
-        providerData: vars.providerData
-      });
-    }
-  });
-}
-function useSymmFinalizeWithdraw(params = {}, options) {
-  const queryClient = reactQuery.useQueryClient();
-  const { multiAccount, publicClient, walletClient, contextSubAccount } = useResolvedWithdrawConfig(params);
-  return reactQuery.useMutation({
-    ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => invalidateBalances(queryClient)
-    }),
-    mutationFn: async (vars) => {
-      if (!walletClient || !publicClient) throw new Error("Clients not available");
-      const subAccount = vars.subAccount ?? contextSubAccount;
-      if (!subAccount) throw new Error("subAccount required");
-      return finalizeWithdraw(walletClient, publicClient, multiAccount, subAccount, {
-        user: vars.user,
-        requestId: vars.requestId
-      });
-    }
-  });
-}
-function useSymmRequestCancelWithdraw(params = {}, options) {
+  const { publicClient, walletClient } = params;
   const queryClient = reactQuery.useQueryClient();
-  const { multiAccount, publicClient, walletClient, contextSubAccount } = useResolvedWithdrawConfig(params);
+  const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
   return reactQuery.useMutation({
     ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => invalidateBalances(queryClient)
+      onSuccess: () => {
+        invalidateBalances(queryClient);
+      }
     }),
-    mutationFn: async (vars) => {
+    mutationFn: async ({
+      account,
+      amount
+    }) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
-      const subAccount = vars.subAccount ?? contextSubAccount;
-      if (!subAccount) throw new Error("subAccount required");
-      return requestCancelWithdraw(walletClient, publicClient, multiAccount, subAccount, {
-        requestId: vars.requestId
-      });
+      return withdraw(walletClient, publicClient, multiAccount, { account, amount });
     }
   });
 }
-function useSymmWithdraw(params = {}) {
-  return {
-    initiate: useSymmInitiateWithdraw(params),
-    finalize: useSymmFinalizeWithdraw(params),
-    requestCancel: useSymmRequestCancelWithdraw(params)
-  };
-}
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-function useSymmInstantWithdraw(params = {}) {
-  const queryClient = reactQuery.useQueryClient();
-  const { chainId, symmioConfig } = useSymmContext();
-  const { multiAccount, publicClient, walletClient, contextSubAccount } = useResolvedWithdrawConfig(params);
-  const diamond = params.diamond ?? symmioConfig?.symmioDiamondAddress ?? getAddress(SYMMIO_DIAMOND_ADDRESS, chainId, "SymmioDiamond");
-  const providerTimeoutMs = params.providerAcceptanceTimeoutMs ?? 6e4;
-  const pollIntervalMs = params.pollIntervalMs ?? 3e3;
-  const [status, setStatus] = react.useState("idle" /* IDLE */);
-  const [requestId, setRequestId] = react.useState();
-  const [txHashes, setTxHashes] = react.useState({});
-  const [error, setError] = react.useState();
-  const reset = react.useCallback(() => {
-    setStatus("idle" /* IDLE */);
-    setRequestId(void 0);
-    setTxHashes({});
-    setError(void 0);
-  }, []);
-  const withdraw = react.useCallback(
-    async (vars) => {
-      setError(void 0);
-      setRequestId(void 0);
-      setTxHashes({});
-      try {
-        if (!walletClient || !publicClient) throw new Error("Clients not available");
-        const subAccount = vars.subAccount ?? contextSubAccount;
-        if (!subAccount) throw new Error("subAccount required");
-        setStatus("initiating" /* INITIATING */);
-        const part = buildExpressWithdrawPart(
-          vars.amount,
-          vars.chainId,
-          vars.receiver,
-          vars.expressProvider,
-          vars.partId ?? 0n
-        );
-        const initiateHash = await initiateWithdraw(
-          walletClient,
-          publicClient,
-          multiAccount,
-          subAccount,
-          {
-            parts: [part],
-            speedUp: vars.speedUp ?? false,
-            providerData: vars.providerData ?? "0x"
-          }
-        );
-        setTxHashes({ initiate: initiateHash });
-        const initiateReceipt = await publicClient.waitForTransactionReceipt({
-          hash: initiateHash
-        });
-        const [initiated] = viem.parseEventLogs({
-          abi: WithdrawFacetABI,
-          eventName: "WithdrawInitiated",
-          logs: initiateReceipt.logs
-        });
-        if (!initiated) {
-          throw new Error("WithdrawInitiated event not found in initiate receipt");
-        }
-        const reqId = initiated.args.requestId;
-        const cooldownEndTime = initiated.args.cooldownEndTime;
-        setRequestId(reqId);
-        setStatus("awaitingProvider" /* AWAITING_PROVIDER */);
-        const acceptanceDeadline = Date.now() + providerTimeoutMs;
-        let fromBlock = initiateReceipt.blockNumber;
-        let accepted = false;
-        while (Date.now() < acceptanceDeadline) {
-          const events = await publicClient.getContractEvents({
-            address: diamond,
-            abi: WithdrawFacetABI,
-            eventName: "WithdrawAccepted",
-            args: { requestId: reqId, user: subAccount },
-            fromBlock,
-            toBlock: "latest"
-          });
-          if (events.length > 0) {
-            accepted = true;
-            break;
-          }
-          await sleep(pollIntervalMs);
-        }
-        if (!accepted) {
-          throw new Error(
-            `Express provider did not accept within ${providerTimeoutMs}ms (requestId=${reqId})`
-          );
-        }
-        setStatus("awaitingCooldown" /* AWAITING_COOLDOWN */);
-        const nowSec = Math.floor(Date.now() / 1e3);
-        const remainingSec = Number(cooldownEndTime) - nowSec;
-        if (remainingSec > 0) {
-          await sleep((remainingSec + 1) * 1e3);
-        }
-        setStatus("finalizing" /* FINALIZING */);
-        const finalizeHash = await finalizeWithdraw(
-          walletClient,
-          publicClient,
-          multiAccount,
-          subAccount,
-          { user: subAccount, requestId: reqId }
-        );
-        setTxHashes((t) => ({ ...t, finalize: finalizeHash }));
-        await publicClient.waitForTransactionReceipt({ hash: finalizeHash });
-        setStatus("completed" /* COMPLETED */);
-        invalidateBalances(queryClient);
-        return { requestId: reqId, initiateHash, finalizeHash };
-      } catch (e) {
-        const err = e instanceof Error ? e : new Error(String(e));
-        setError(err);
-        setStatus("failed" /* FAILED */);
-        throw err;
-      }
-    },
-    [
-      walletClient,
-      publicClient,
-      multiAccount,
-      diamond,
-      contextSubAccount,
-      providerTimeoutMs,
-      pollIntervalMs,
-      queryClient
-    ]
-  );
-  return { withdraw, status, requestId, txHashes, error, reset };
-}
 
 // src/abis/SymmioDiamond.ts
 var SymmioDiamondABI = [
@@ -25535,6 +25102,18 @@ var SymmioDiamondABI = [
     type: "function"
   }
 ];
+function wrapInProxyCall(accountDiamondAbi, subAccount, callDatas) {
+  const data = viem.encodeFunctionData({
+    abi: accountDiamondAbi,
+    functionName: "_call",
+    args: [subAccount, callDatas]
+  });
+  return {
+    functionName: "_call",
+    args: [subAccount, callDatas],
+    data
+  };
+}
 
 // src/actions/allocate.ts
 function prepareAllocate(multiAccount, account, subAccount, params) {
@@ -25652,17 +25231,29 @@ function normalizeSignParams(raw) {
   return raw ?? {};
 }
 function unwrapMuonResult(result) {
-  const data = result["result"];
-  if (!data) {
+  const envelope = result["result"];
+  if (!envelope) {
     throw new SymmioSDKError("Invalid Muon response: missing result", "MUON_PARSE_ERROR");
   }
-  const sigData = data["data"];
+  const meta = envelope["data"] ?? {};
   return {
-    signParams: normalizeSignParams(sigData?.["signParams"] ?? data["signParams"]),
-    signatures: sigData?.["signatures"] ?? data["signatures"] ?? [],
-    init: sigData?.["init"] ?? data["init"]
+    envelope,
+    meta,
+    computed: meta["result"] ?? {},
+    signParams: normalizeSignParams(meta["signParams"] ?? envelope["signParams"]),
+    signatures: meta["signatures"] ?? envelope["signatures"] ?? [],
+    init: meta["init"] ?? envelope["init"]
   };
 }
+function requireBigInt(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    throw new SymmioSDKError(
+      `Invalid Muon response: missing "${field}"`,
+      "MUON_PARSE_ERROR"
+    );
+  }
+  return BigInt(value);
+}
 function extractSchnorrSign(signParams, signatures, init) {
   const inline = signParams["sigs"];
   if (inline?.signature !== void 0) {
@@ -25692,41 +25283,43 @@ function extractSchnorrSign(signParams, signatures, init) {
     nonce: nonceAddress
   };
 }
-function gatewaySigOf(signatures) {
+function gatewaySigOf(envelope, signatures) {
+  const shield = envelope["shieldSignature"] ?? envelope["nodeSignature"] ?? envelope["gatewaySignature"];
+  if (typeof shield === "string" && shield.length > 0) return shield;
   return signatures?.[0]?.["signature"] ?? "0x";
 }
 function parseSingleUpnlSig(result) {
-  const { signParams, signatures, init } = unwrapMuonResult(result);
+  const { signParams, signatures, init, envelope, meta, computed } = unwrapMuonResult(result);
   return {
-    reqId: signParams["reqId"],
-    timestamp: BigInt(signParams["timestamp"]),
-    upnl: BigInt(signParams["upnl"]),
-    gatewaySignature: gatewaySigOf(signatures),
+    reqId: signParams["reqId"] ?? envelope["reqId"],
+    timestamp: requireBigInt(signParams["timestamp"] ?? meta["timestamp"], "timestamp"),
+    upnl: requireBigInt(signParams["upnl"] ?? computed["uPnl"], "upnl"),
+    gatewaySignature: gatewaySigOf(envelope, signatures),
     sigs: extractSchnorrSign(signParams, signatures, init)
   };
 }
 function parseSingleUpnlAndPriceSig(result) {
-  const { signParams, signatures, init } = unwrapMuonResult(result);
+  const { signParams, signatures, init, envelope, meta, computed } = unwrapMuonResult(result);
   return {
-    reqId: signParams["reqId"],
-    timestamp: BigInt(signParams["timestamp"]),
-    upnl: BigInt(signParams["upnl"]),
-    price: BigInt(signParams["price"]),
-    gatewaySignature: gatewaySigOf(signatures),
+    reqId: signParams["reqId"] ?? envelope["reqId"],
+    timestamp: requireBigInt(signParams["timestamp"] ?? meta["timestamp"], "timestamp"),
+    upnl: requireBigInt(signParams["upnl"] ?? computed["uPnl"], "upnl"),
+    price: requireBigInt(signParams["price"] ?? computed["price"], "price"),
+    gatewaySignature: gatewaySigOf(envelope, signatures),
     sigs: extractSchnorrSign(signParams, signatures, init)
   };
 }
 function parseBatchSig(result) {
-  const { signParams, signatures, init } = unwrapMuonResult(result);
-  const prices = signParams["prices"];
-  const symbolIds = signParams["symbolIds"];
+  const { signParams, signatures, init, envelope, meta, computed } = unwrapMuonResult(result);
+  const prices = signParams["prices"] ?? computed["prices"];
+  const symbolIds = signParams["symbolIds"] ?? computed["symbolIds"];
   return {
-    reqId: signParams["reqId"],
-    timestamp: BigInt(signParams["timestamp"]),
-    upnl: BigInt(signParams["upnl"]),
+    reqId: signParams["reqId"] ?? envelope["reqId"],
+    timestamp: requireBigInt(signParams["timestamp"] ?? meta["timestamp"], "timestamp"),
+    upnl: requireBigInt(signParams["upnl"] ?? computed["uPnl"], "upnl"),
     prices: (prices ?? []).map((p) => BigInt(p)),
     symbolIds: (symbolIds ?? []).map((s) => BigInt(s)),
-    gatewaySignature: gatewaySigOf(signatures),
+    gatewaySignature: gatewaySigOf(envelope, signatures),
     sigs: extractSchnorrSign(signParams, signatures, init)
   };
 }
@@ -26529,8 +26122,8 @@ function computeSymmNetDeposited(totals, decimals = 6) {
     return "0";
   }
   const deposit2 = parseRawCollateralUnits(totals.deposit);
-  const withdraw = parseRawCollateralUnits(totals.withdraw);
-  const value = deposit2 - withdraw;
+  const withdraw2 = parseRawCollateralUnits(totals.withdraw);
+  const value = deposit2 - withdraw2;
   const negative = value < 0n;
   const absolute = negative ? -value : value;
   const scale = 10n ** BigInt(decimals);
@@ -28384,17 +27977,14 @@ exports.useSymmDelegation = useSymmDelegation;
 exports.useSymmDepositAndAllocateMutation = useSymmDepositAndAllocateMutation;
 exports.useSymmDepositMutation = useSymmDepositMutation;
 exports.useSymmEditAccountNameMutation = useSymmEditAccountNameMutation;
-exports.useSymmFinalizeWithdraw = useSymmFinalizeWithdraw;
 exports.useSymmFunding = useSymmFunding;
 exports.useSymmFundingHistory = useSymmFundingHistory;
 exports.useSymmFundingPayments = useSymmFundingPayments;
 exports.useSymmHedgerMarketById = useSymmHedgerMarketById;
 exports.useSymmHedgerMarketBySymbol = useSymmHedgerMarketBySymbol;
 exports.useSymmHedgerMarkets = useSymmHedgerMarkets;
-exports.useSymmInitiateWithdraw = useSymmInitiateWithdraw;
 exports.useSymmInstantTradeEnsureReadyMutation = useSymmInstantTradeEnsureReadyMutation;
 exports.useSymmInstantTradeExecuteMutation = useSymmInstantTradeExecuteMutation;
-exports.useSymmInstantWithdraw = useSymmInstantWithdraw;
 exports.useSymmInternalTransferCollateralMutation = useSymmInternalTransferCollateralMutation;
 exports.useSymmLockedParams = useSymmLockedParams;
 exports.useSymmMarkReadNotificationMutation = useSymmMarkReadNotificationMutation;
@@ -28409,7 +27999,6 @@ exports.useSymmPerformanceOverlays = useSymmPerformanceOverlays;
 exports.useSymmPortfolio = useSymmPortfolio;
 exports.useSymmPositions = useSymmPositions;
 exports.useSymmProposeRevokeDelegationMutation = useSymmProposeRevokeDelegationMutation;
-exports.useSymmRequestCancelWithdraw = useSymmRequestCancelWithdraw;
 exports.useSymmRevokeDelegationMutation = useSymmRevokeDelegationMutation;
 exports.useSymmSetTpslMutation = useSymmSetTpslMutation;
 exports.useSymmSetTriggerConfigMutation = useSymmSetTriggerConfigMutation;