@0xmonaco/core 0.7.3 → 0.7.4

package/dist/api/vault/api.d.ts

@@ -23,7 +23,7 @@
  * console.log(`Deposit transaction: ${result.hash}`);
  * ```
  */
-import type { ApplicationsAPI, Balance, ProfileAPI, TransactionResult, VaultAPI } from "@0xmonaco/types";
+import type { ApplicationsAPI, Balance, ProfileAPI, TransactionResult, VaultAPI, WithdrawResult } from "@0xmonaco/types";
 import { type Address, type Chain, type PublicClient, type WalletClient } from "viem";
 import { BaseAPI } from "../base";
 export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
@@ -148,41 +148,64 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      */
     deposit(assetId: string, amount: bigint, autoWait?: boolean): Promise<TransactionResult>;
     /**
-     * Withdraws tokens from the Monaco vault.
+     * Initiates a withdrawal through the API Gateway and submits the resulting
+     * pre-signed calldata on-chain via the connected wallet.
      *
-     * Withdraws the specified amount of tokens from the vault contract back to the
-     * user's wallet. The method obtains a signature from the API Gateway and then
-     * executes the withdrawal transaction on-chain.
+     * The gateway allocates a `withdrawalIndex` via the matching engine and returns
+     * ABI-encoded calldata for `executeSignedWithdrawal(...)` signed by the
+     * server-side `WITHDRAWAL_SIGNER`. The user's wallet pays gas to submit it,
+     * but the contract authenticates against the embedded signature — not the
+     * `msg.sender`. The connected wallet's address is sent as the on-chain
+     * `destination`.
      *
      * @param assetId - The asset identifier (UUID) to withdraw
-     * @param amount - The amount of tokens to withdraw (as bigint)
+     * @param amount - The raw token amount to withdraw (as bigint)
      * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
-     * @returns Promise resolving to TransactionResult with transaction details
-     * @throws {ContractError} When withdrawal fails
-     * @throws {APIError} When signature retrieval fails or the asset is not found/assetId is invalid
+     * @returns Promise resolving to `{ withdrawalIndex, transaction }`
+     * @throws {APIError} When the asset is not found or the request is rejected
+     * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      *
      * @example
      * ```typescript
-     * // Withdraw 50 USDC from the vault (auto-waits by default)
+     * // Withdraw 50 USDC, wait for on-chain confirmation
      * const result = await vaultAPI.withdraw(
      *   "123e4567-e89b-12d3-a456-426614174000",
-     *   parseUnits("50", 6)
+     *   parseUnits("50", 6),
      * );
-     * console.log(`Withdrawal transaction: ${result.hash}`);
-     * console.log(`Status: ${result.status}`); // "confirmed" if successful
+     * console.log(`Withdrawal index: ${result.withdrawalIndex}`);
+     * console.log(`Tx hash: ${result.hash}, status: ${result.status}`);
      *
-     * // Or skip auto-waiting
+     * // Or skip auto-waiting and finalise later
      * const result = await vaultAPI.withdraw(
      *   "123e4567-e89b-12d3-a456-426614174000",
      *   parseUnits("50", 6),
-     *   false
+     *   false,
      * );
-     * // Then manually wait later if needed
      * const receipt = await sdk.waitForTransaction(result.hash);
      * ```
      */
-    withdraw(assetId: string, amount: bigint, autoWait?: boolean): Promise<TransactionResult>;
+    withdraw(assetId: string, amount: bigint, autoWait?: boolean): Promise<WithdrawResult>;
+    /**
+     * Retries a previously-initiated withdrawal whose on-chain submission never
+     * landed — e.g. the wallet rejected the tx, the page reloaded before the
+     * receipt came back, or a stuck mempool entry needs resending.
+     *
+     * Re-fetches the same `executeSignedWithdrawal` calldata the gateway
+     * generated when the withdrawal was initiated, then submits it through the
+     * connected wallet. Does NOT initiate a new withdrawal — the matching engine
+     * already debited the balance and allocated the index. The contract is
+     * idempotent against double-submission of a settled withdrawal: it will
+     * revert once the index is consumed on-chain.
+     *
+     * @param withdrawalIndex - The index returned by the original `withdraw()` call
+     * @param autoWait - Whether to await on-chain confirmation (defaults to true)
+     * @returns Promise resolving to `{ withdrawalIndex, ...transaction }`
+     * @throws {APIError} When the index doesn't exist
+     * @throws {ContractError} When the on-chain submission fails
+     * @throws {InvalidConfigError} When wallet account is not available
+     */
+    retryWithdrawal(withdrawalIndex: number, autoWait?: boolean): Promise<WithdrawResult>;
     /**
      * Retrieves the user's token balance in the vault.
      *
@@ -234,19 +257,5 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      * ```
      */
     needsApproval(assetId: string, amount: bigint): Promise<boolean>;
-    /**
-     * Retrieves a withdrawal signature from the API Gateway.
-     *
-     * Internal method that communicates with the Monaco API Gateway to obtain
-     * the cryptographic signature required for withdrawal transactions. The signature
-     * validates the withdrawal request and ensures proper authorization.
-     *
-     * @param assetId - The asset identifier (UUID) to withdraw
-     * @param amount - The amount to withdraw (as bigint)
-     * @returns Promise resolving to object containing seed and signature
-     * @throws {APIError} When signature retrieval fails
-     * @private
-     */
-    private getWithdrawSignature;
     private waitForTransaction;
 }

package/dist/api/vault/api.js

@@ -275,37 +275,40 @@ export class VaultAPIImpl extends BaseAPI {
         return await this.waitForTransaction(txResult, autoWait);
     }
     /**
-     * Withdraws tokens from the Monaco vault.
+     * Initiates a withdrawal through the API Gateway and submits the resulting
+     * pre-signed calldata on-chain via the connected wallet.
      *
-     * Withdraws the specified amount of tokens from the vault contract back to the
-     * user's wallet. The method obtains a signature from the API Gateway and then
-     * executes the withdrawal transaction on-chain.
+     * The gateway allocates a `withdrawalIndex` via the matching engine and returns
+     * ABI-encoded calldata for `executeSignedWithdrawal(...)` signed by the
+     * server-side `WITHDRAWAL_SIGNER`. The user's wallet pays gas to submit it,
+     * but the contract authenticates against the embedded signature — not the
+     * `msg.sender`. The connected wallet's address is sent as the on-chain
+     * `destination`.
      *
      * @param assetId - The asset identifier (UUID) to withdraw
-     * @param amount - The amount of tokens to withdraw (as bigint)
+     * @param amount - The raw token amount to withdraw (as bigint)
      * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
-     * @returns Promise resolving to TransactionResult with transaction details
-     * @throws {ContractError} When withdrawal fails
-     * @throws {APIError} When signature retrieval fails or the asset is not found/assetId is invalid
+     * @returns Promise resolving to `{ withdrawalIndex, transaction }`
+     * @throws {APIError} When the asset is not found or the request is rejected
+     * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      *
      * @example
      * ```typescript
-     * // Withdraw 50 USDC from the vault (auto-waits by default)
+     * // Withdraw 50 USDC, wait for on-chain confirmation
      * const result = await vaultAPI.withdraw(
      *   "123e4567-e89b-12d3-a456-426614174000",
-     *   parseUnits("50", 6)
+     *   parseUnits("50", 6),
      * );
-     * console.log(`Withdrawal transaction: ${result.hash}`);
-     * console.log(`Status: ${result.status}`); // "confirmed" if successful
+     * console.log(`Withdrawal index: ${result.withdrawalIndex}`);
+     * console.log(`Tx hash: ${result.hash}, status: ${result.status}`);
      *
-     * // Or skip auto-waiting
+     * // Or skip auto-waiting and finalise later
      * const result = await vaultAPI.withdraw(
      *   "123e4567-e89b-12d3-a456-426614174000",
      *   parseUnits("50", 6),
-     *   false
+     *   false,
      * );
-     * // Then manually wait later if needed
      * const receipt = await sdk.waitForTransaction(result.hash);
      * ```
      */
@@ -313,45 +316,95 @@ export class VaultAPIImpl extends BaseAPI {
         if (!this.walletClient) {
             throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
         }
-        validate(WithdrawSchema, { assetId, amount, autoWait });
-        const vaultAddress = await this.getVaultAddress();
-        const { tokenAddress, isNativeToken } = await this.resolveAsset(assetId);
-        // Get signature from backend API using asset_id
-        const { seed, signature } = await this.getWithdrawSignature(assetId, amount);
         const walletAccount = this.walletClient.account;
         if (!walletAccount) {
             throw new InvalidConfigError("No account available in wallet client", "account");
         }
-        // For native SEI (zero address), use withdrawNative; for ERC20 tokens, use withdraw
+        const destination = walletAccount.address.toLowerCase();
+        validate(WithdrawSchema, { assetId, amount, destination, autoWait });
+        // 1. Gateway allocates withdrawal_index + returns pre-signed
+        // executeSignedWithdrawal calldata along with the vault address to send
+        // it to. Sourcing the vault address from this response (instead of
+        // GET /applications/config) keeps the calldata + target contract in
+        // lockstep and avoids an extra round-trip.
+        const { withdrawal_index: withdrawalIndex, vault_address: vaultAddress, calldata, } = await this.makeAuthenticatedRequest("/api/v1/withdrawals", {
+            method: "POST",
+            body: JSON.stringify({
+                asset_id: assetId,
+                amount: amount.toString(),
+                destination,
+            }),
+        });
+        // 2. Submit the calldata on-chain through the connected wallet.
         let hash;
-        if (isNativeToken) {
-            hash = await this.walletClient.writeContract({
-                address: vaultAddress,
-                abi: CONTRACT_ABIS.vault,
-                functionName: "withdrawNative",
-                args: [amount, seed, signature],
+        try {
+            hash = await this.walletClient.sendTransaction({
+                to: vaultAddress,
+                data: calldata,
                 account: walletAccount,
                 chain: this.chain,
             });
         }
-        else {
-            hash = await this.walletClient.writeContract({
-                address: vaultAddress,
-                abi: CONTRACT_ABIS.vault,
-                functionName: "withdraw",
-                args: [tokenAddress, amount, seed, signature],
+        catch (error) {
+            throw new ContractError(`Failed to submit executeSignedWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
+        }
+        const nonce = walletAccount.getNonce ? await walletAccount.getNonce() : 0n;
+        const txResult = {
+            hash,
+            status: "pending",
+            nonce,
+        };
+        const settled = await this.waitForTransaction(txResult, autoWait);
+        return { ...settled, withdrawalIndex };
+    }
+    /**
+     * Retries a previously-initiated withdrawal whose on-chain submission never
+     * landed — e.g. the wallet rejected the tx, the page reloaded before the
+     * receipt came back, or a stuck mempool entry needs resending.
+     *
+     * Re-fetches the same `executeSignedWithdrawal` calldata the gateway
+     * generated when the withdrawal was initiated, then submits it through the
+     * connected wallet. Does NOT initiate a new withdrawal — the matching engine
+     * already debited the balance and allocated the index. The contract is
+     * idempotent against double-submission of a settled withdrawal: it will
+     * revert once the index is consumed on-chain.
+     *
+     * @param withdrawalIndex - The index returned by the original `withdraw()` call
+     * @param autoWait - Whether to await on-chain confirmation (defaults to true)
+     * @returns Promise resolving to `{ withdrawalIndex, ...transaction }`
+     * @throws {APIError} When the index doesn't exist
+     * @throws {ContractError} When the on-chain submission fails
+     * @throws {InvalidConfigError} When wallet account is not available
+     */
+    async retryWithdrawal(withdrawalIndex, autoWait = true) {
+        if (!this.walletClient) {
+            throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
+        }
+        const walletAccount = this.walletClient.account;
+        if (!walletAccount) {
+            throw new InvalidConfigError("No account available in wallet client", "account");
+        }
+        const { vault_address: vaultAddress, calldata } = await this.makePublicRequest(`/api/v1/withdrawals/${withdrawalIndex}`);
+        let hash;
+        try {
+            hash = await this.walletClient.sendTransaction({
+                to: vaultAddress,
+                data: calldata,
                 account: walletAccount,
                 chain: this.chain,
             });
         }
+        catch (error) {
+            throw new ContractError(`Failed to resubmit executeSignedWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
+        }
         const nonce = walletAccount.getNonce ? await walletAccount.getNonce() : 0n;
         const txResult = {
             hash,
             status: "pending",
             nonce,
         };
-        // Handle auto-waiting for transaction confirmation
-        return await this.waitForTransaction(txResult, autoWait);
+        const settled = await this.waitForTransaction(txResult, autoWait);
+        return { ...settled, withdrawalIndex };
     }
     /**
      * Retrieves the user's token balance in the vault.
@@ -426,32 +479,6 @@ export class VaultAPIImpl extends BaseAPI {
         const allowance = await this.getAllowance(assetId);
         return allowance < amount;
     }
-    /**
-     * Retrieves a withdrawal signature from the API Gateway.
-     *
-     * Internal method that communicates with the Monaco API Gateway to obtain
-     * the cryptographic signature required for withdrawal transactions. The signature
-     * validates the withdrawal request and ensures proper authorization.
-     *
-     * @param assetId - The asset identifier (UUID) to withdraw
-     * @param amount - The amount to withdraw (as bigint)
-     * @returns Promise resolving to object containing seed and signature
-     * @throws {APIError} When signature retrieval fails
-     * @private
-     */
-    async getWithdrawSignature(assetId, amount) {
-        const data = await this.makeAuthenticatedRequest("/api/v1/withdraw/signature", {
-            method: "POST",
-            body: JSON.stringify({
-                asset_id: assetId,
-                amount: amount.toString(),
-            }),
-        });
-        return {
-            seed: data.seed,
-            signature: data.signature,
-        };
-    }
     async waitForTransaction(txResult, autoWait = true, options = {}) {
         if (!autoWait) {
             return txResult;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "0.7.3",
+	"version": "0.7.4",
 	"type": "module",
 	"repository": {
 		"type": "git",