@pear-protocol/symmio-client 0.3.17 → 0.3.18

package/dist/react/index.js

@@ -2664,24 +2664,288 @@ function useSymmDepositAndAllocateMutation(params = {}, options) {
     }
   });
 }
-function prepareWithdraw(multiAccount, account, params) {
-  validateAmount(params.amount, "withdraw amount");
-  validateAddress(params.account, "account");
+
+// 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) {
   const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "withdrawFromAccount",
-    args: [params.account, params.amount]
+    abi: accountDiamondAbi,
+    functionName: "_call",
+    args: [subAccount, callDatas]
   });
   return {
-    functionName: "withdrawFromAccount",
-    args: [params.account, params.amount],
-    config: { account, to: multiAccount, data, value: 0n }
+    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]
+  });
+  const proxy = wrapInProxyCall(MultiAccountABI, subAccount, [innerData]);
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
   };
 }
-async function withdraw(walletClient, publicClient, multiAccount, params) {
+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 = prepareWithdraw(multiAccount, account, params);
+  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) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareRequestCancelWithdraw(multiAccount, account, subAccount, params);
   const gas = await publicClient.estimateGas(prepared.config);
   return walletClient.sendTransaction({
     ...prepared.config,
@@ -2691,26 +2955,201 @@ async function withdraw(walletClient, publicClient, multiAccount, params) {
 }
 
 // src/react/hooks/use-symm-withdraw.ts
-function useSymmWithdraw(params = {}, options) {
+function useResolvedWithdrawConfig(params) {
   const { chainId, symmioConfig } = useSymmContext();
-  const { publicClient, walletClient } = params;
-  const queryClient = reactQuery.useQueryClient();
   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);
-      }
+      onSuccess: () => invalidateBalances(queryClient)
     }),
-    mutationFn: async ({
-      account,
-      amount
-    }) => {
+    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");
-      return withdraw(walletClient, publicClient, multiAccount, { account, amount });
+      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 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 requestCancelWithdraw(walletClient, publicClient, multiAccount, subAccount, {
+        requestId: vars.requestId
+      });
     }
   });
 }
+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 = [
@@ -25096,18 +25535,6 @@ 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) {
@@ -26102,8 +26529,8 @@ function computeSymmNetDeposited(totals, decimals = 6) {
     return "0";
   }
   const deposit2 = parseRawCollateralUnits(totals.deposit);
-  const withdraw2 = parseRawCollateralUnits(totals.withdraw);
-  const value = deposit2 - withdraw2;
+  const withdraw = parseRawCollateralUnits(totals.withdraw);
+  const value = deposit2 - withdraw;
   const negative = value < 0n;
   const absolute = negative ? -value : value;
   const scale = 10n ** BigInt(decimals);
@@ -27957,14 +28384,17 @@ 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;
@@ -27979,6 +28409,7 @@ exports.useSymmPerformanceOverlays = useSymmPerformanceOverlays;
 exports.useSymmPortfolio = useSymmPortfolio;
 exports.useSymmPositions = useSymmPositions;
 exports.useSymmProposeRevokeDelegationMutation = useSymmProposeRevokeDelegationMutation;
+exports.useSymmRequestCancelWithdraw = useSymmRequestCancelWithdraw;
 exports.useSymmRevokeDelegationMutation = useSymmRevokeDelegationMutation;
 exports.useSymmSetTpslMutation = useSymmSetTpslMutation;
 exports.useSymmSetTriggerConfigMutation = useSymmSetTriggerConfigMutation;