@upshiftfinance/sdk 0.3.0 → 0.5.0

package/lib/adapters/sui/index.d.ts

@@ -4,21 +4,44 @@
  * @module SuiAdapter
  */
 import type { ISuiConfig, ISuiNetwork } from '../../types';
+import * as SuiActions from './actions';
 import * as SuiClient from './client';
 import * as SuiConstants from './constants';
+import * as SuiGetters from './getters';
 import * as SuiTargets from './targets';
 import * as SuiUtils from './utils';
+/**
+ * Sui helpers by area: chain identity (`utils`), constants, the gRPC client
+ * with failover (`client`), move-call targets (`targets`), vault reads
+ * (`getters`) and deposit / instant-redeem builders (`actions`).
+ */
 export declare const Sui: {
     utils: typeof SuiUtils;
     constants: typeof SuiConstants;
     client: typeof SuiClient;
     targets: typeof SuiTargets;
+    getters: typeof SuiGetters;
+    actions: typeof SuiActions;
 };
+/**
+ * A Sui vault as the adapter methods take it; the network is the adapter's.
+ * From an `IVault`: `vaultId` is `address`, `assetCoinType` is
+ * `depositAssets[0].address`, `shareCoinType` is `receipt.address`.
+ */
+export interface ISuiAdapterVault {
+    /** Vault object ID (`0x` + 64 hex chars). */
+    vaultId: string;
+    /** Move type of the deposit coin. */
+    assetCoinType: string;
+    /** Move type of the vault's share coin. */
+    shareCoinType: string;
+}
 /**
  * Sui Adapter for Upshift SDK.
  *
- * Holds the Sui configuration passed to `new UpshiftSDK({ sui })` and the Sui
- * chain-identity helpers. It makes no network calls.
+ * Holds the Sui configuration passed to `new UpshiftSDK({ sui })`, the Sui
+ * chain-identity helpers, and the vault deposit / instant-redeem builders.
+ * Transactions run on the configured network.
  *
  * @example
  * ```ts
@@ -27,7 +50,7 @@ export declare const Sui: {
  * sdk.sui.isSuiAddress(vault.address);
  * ```
  */
-declare class SuiAdapter {
+export declare class SuiAdapter {
     private readonly _config;
     /**
      * @param config - Optional Sui settings; omit to target Sui mainnet.
@@ -53,5 +76,222 @@ declare class SuiAdapter {
      * @returns `true` only for `-2`.
      */
     isSuiVault(chainId: number): boolean;
+    /**
+     * Build an unsigned deposit on the configured network: charge the
+     * management fee, deposit with a minimum share amount, send the shares to
+     * the sender. Dry-runs it first, so a vault that would reject it fails here.
+     *
+     * RPC cost: one dry run (plus the coin lookup it needs).
+     *
+     * @param params - The vault, `amount` in asset base units, the `sender`, and
+     *   optionally `minSharesOut` or `slippageBps` (the minimum defaults to the
+     *   dry run's preview less 0.1%).
+     * @returns The unsigned transaction for the sender's wallet, the shares the
+     *   dry run minted, and the minimum it enforces.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a transaction that cannot be built.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const { transaction } = await sdk.sui.vaultDeposit({
+     *   vaultId: vault.address,
+     *   assetCoinType: vault.depositAssets[0].address,
+     *   shareCoinType: vault.receipt.address,
+     *   amount: 1_000_000n,
+     *   sender: account.address,
+     * });
+     * const digest = await sdk.sui.executeTransaction(
+     *   await dAppKit.signTransaction({ transaction }),
+     * );
+     * ```
+     */
+    vaultDeposit(params: ISuiAdapterVault & {
+        amount: bigint;
+        sender: string;
+        minSharesOut?: bigint;
+        slippageBps?: number;
+    }): Promise<SuiActions.ISuiDepositTransaction>;
+    /**
+     * Build an unsigned instant redemption on the configured network: charge
+     * the management fee, redeem shares with a minimum net asset amount, send
+     * the assets to the sender.
+     * Dry-runs it first; a vault with a withdrawal queue attached fails with
+     * `queue_attached`.
+     *
+     * Side effect on failure: a redemption the vault rejects is reported to that
+     * vault's curator (fire-and-forget; see `monitoring.curatorAlerts`).
+     *
+     * RPC cost: one dry run (plus the coin lookup it needs).
+     *
+     * @param params - The vault, `shares` in share base units, the `sender`, and
+     *   optionally `minAssetsOut` (net of the instant fee) or `slippageBps` (the
+     *   minimum defaults to the dry run's preview less 0.1%).
+     * @returns The unsigned transaction, the dry run's gross and net assets, and
+     *   the minimum it enforces.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a transaction that cannot be built.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     */
+    vaultRedeem(params: ISuiAdapterVault & {
+        shares: bigint;
+        sender: string;
+        minAssetsOut?: bigint;
+        slippageBps?: number;
+    }): Promise<SuiActions.ISuiRedeemTransaction>;
+    /**
+     * Build an unsigned withdrawal request on the configured network, for a
+     * vault with a withdrawal queue attached (where instant redemption is off).
+     * Escrows the shares in a new request; dry-runs it first, so a vault that
+     * would reject it fails here.
+     *
+     * The request is priced when it is claimed. Once the vault's cooldown has
+     * run, claim it with {@link SuiAdapter.claimWithdrawal}; cancel it at any
+     * time with {@link SuiAdapter.vaultCancelRedeemRequest}. List a wallet's
+     * requests with {@link SuiAdapter.getWithdrawalRequests}.
+     *
+     * RPC cost: one object read for a wallet with up to 23 earlier requests on
+     * the vault (one more per further 25), then one dry run.
+     *
+     * @param params - The vault, `shares` in share base units, the `sender`, and
+     *   optionally `payout` (defaults to the sender) and `finalizer`: who besides
+     *   the owner may claim during the first day the request is claimable
+     *   (anyone may after). Defaults to the owner alone; pass a keeper address,
+     *   or `null` to let anyone claim as soon as the cooldown ends.
+     * @returns The unsigned transaction, the request ID, the request's object ID
+     *   (`request`) for claiming or cancelling, and `expectedAssets` at today's
+     *   price.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a transaction that cannot be built.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it,
+     *   e.g. `queue_not_attached` (redeem instantly instead) or `paused`.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const { transaction, request } = await sdk.sui.vaultRequestRedeem({
+     *   vaultId: vault.address,
+     *   assetCoinType: vault.depositAssets[0].address,
+     *   shareCoinType: vault.receipt.address,
+     *   shares: 1_000_000n,
+     *   sender: account.address,
+     * });
+     * await sdk.sui.executeTransaction(await dAppKit.signTransaction({ transaction }));
+     * ```
+     */
+    vaultRequestRedeem(params: ISuiAdapterVault & {
+        shares: bigint;
+        sender: string;
+        payout?: string;
+        finalizer?: string | null;
+    }): Promise<SuiActions.ISuiRequestRedeemTransaction>;
+    /**
+     * Build an unsigned cancellation of a pending withdrawal request on the
+     * configured network; the escrowed shares go back to the sender. Allowed at
+     * any time while the request exists, also while the vault is paused. Only
+     * the wallet that made the request may cancel it.
+     *
+     * RPC cost: one dry run.
+     *
+     * @param params - The vault, the `request` object ID and the `sender`.
+     * @returns The unsigned transaction and the shares it returns.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a request that no longer exists.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it,
+     *   e.g. `not_request_owner`.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const { transaction } = await sdk.sui.vaultCancelRedeemRequest({
+     *   vaultId, assetCoinType, shareCoinType, request, sender: account.address,
+     * });
+     * ```
+     */
+    vaultCancelRedeemRequest(params: ISuiAdapterVault & {
+        request: string;
+        sender: string;
+    }): Promise<SuiActions.ISuiCancelRedeemRequestTransaction>;
+    /**
+     * Build an unsigned claim of a withdrawal request on the configured
+     * network: burns the escrowed shares and pays their current value, with no
+     * instant fee, to the request's payout.
+     *
+     * The payout lands in the payout address's address balance, not as a coin
+     * object. A request can be claimed from `eligibleAtMs` until `expiresAtMs`
+     * by its owner or finalizer (anyone when it names none), and by anyone from
+     * one day after it became eligible.
+     *
+     * RPC cost: one dry run.
+     *
+     * @param params - The vault, the `request` object ID, the `sender`, and
+     *   optionally `minAssetsOut` or `slippageBps` (the minimum defaults to the
+     *   dry run's payout less 0.1%).
+     * @returns The unsigned transaction, the shares it burns, the dry run's
+     *   payout, and the minimum it enforces.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a request that no longer exists.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it,
+     *   e.g. `not_eligible_yet`, `request_expired` or `insufficient_liquidity`.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const [pending] = await sdk.sui.getWithdrawalRequests({ ...vault, owner: account.address });
+     * const { transaction } = await sdk.sui.claimWithdrawal({
+     *   ...vault, request: pending.request, sender: account.address,
+     * });
+     * ```
+     */
+    claimWithdrawal(params: ISuiAdapterVault & {
+        request: string;
+        sender: string;
+        minAssetsOut?: bigint;
+        slippageBps?: number;
+    }): Promise<SuiActions.ISuiClaimWithdrawalTransaction>;
+    /**
+     * A wallet's pending withdrawal requests on a vault, on the configured
+     * network, oldest first. Finds every request made through the SDK however
+     * old; claimed and cancelled requests are left out.
+     *
+     * RPC cost: one object read for a wallet that has made up to 23 requests on
+     * the vault (most wallets), one more per further 25.
+     *
+     * @param params - The vault and the `owner` wallet.
+     * @returns The pending requests, with shares, payout, and the times they
+     *   become claimable and expire; empty when there are none.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a vault ID that is not a vault of the configured
+     *   `sui.originalPackageId`.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const pending = await sdk.sui.getWithdrawalRequests({
+     *   vaultId, assetCoinType, shareCoinType, owner: account.address,
+     * });
+     * const now = Date.now();
+     * const claimable = pending.filter(
+     *   (r) => r.eligibleAtMs <= now && (r.expiresAtMs === null || now < r.expiresAtMs),
+     * );
+     * ```
+     */
+    getWithdrawalRequests(params: ISuiAdapterVault & {
+        owner: string;
+    }): Promise<SuiGetters.ISuiWithdrawalRequest[]>;
+    /**
+     * Execute a wallet-signed transaction on the configured network and wait
+     * until it is indexed. Not needed when the wallet executes the transaction
+     * itself (e.g. dApp Kit's `signAndExecuteTransaction`).
+     *
+     * Side effect on failure: a failed instant redemption is reported to that
+     * vault's curator with its digest (fire-and-forget).
+     *
+     * @param signed - `{ bytes, signature }` from the wallet's `signTransaction`.
+     * @returns The transaction digest.
+     * @throws {@link UpshiftVaultAbortError} when the vault aborted it on chain.
+     * @throws {@link UpshiftSDKError} (`UNKNOWN`) when it failed otherwise.
+     * @throws {@link UpshiftTransactionError} when it executed but was not
+     *   indexed in time.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     */
+    executeTransaction(signed: SuiActions.ISuiSignedTransaction): Promise<string>;
 }
 export default SuiAdapter;

package/lib/adapters/sui/index.js

@@ -33,22 +33,32 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sui = void 0;
+exports.SuiAdapter = exports.Sui = void 0;
+const SuiActions = __importStar(require("./actions"));
 const SuiClient = __importStar(require("./client"));
 const SuiConstants = __importStar(require("./constants"));
+const SuiGetters = __importStar(require("./getters"));
 const SuiTargets = __importStar(require("./targets"));
 const SuiUtils = __importStar(require("./utils"));
+/**
+ * Sui helpers by area: chain identity (`utils`), constants, the gRPC client
+ * with failover (`client`), move-call targets (`targets`), vault reads
+ * (`getters`) and deposit / instant-redeem builders (`actions`).
+ */
 exports.Sui = {
     utils: SuiUtils,
     constants: SuiConstants,
     client: SuiClient,
     targets: SuiTargets,
+    getters: SuiGetters,
+    actions: SuiActions,
 };
 /**
  * Sui Adapter for Upshift SDK.
  *
- * Holds the Sui configuration passed to `new UpshiftSDK({ sui })` and the Sui
- * chain-identity helpers. It makes no network calls.
+ * Holds the Sui configuration passed to `new UpshiftSDK({ sui })`, the Sui
+ * chain-identity helpers, and the vault deposit / instant-redeem builders.
+ * Transactions run on the configured network.
  *
  * @example
  * ```ts
@@ -95,6 +105,243 @@ class SuiAdapter {
     isSuiVault(chainId) {
         return SuiUtils.isSuiVault(chainId);
     }
+    /**
+     * Build an unsigned deposit on the configured network: charge the
+     * management fee, deposit with a minimum share amount, send the shares to
+     * the sender. Dry-runs it first, so a vault that would reject it fails here.
+     *
+     * RPC cost: one dry run (plus the coin lookup it needs).
+     *
+     * @param params - The vault, `amount` in asset base units, the `sender`, and
+     *   optionally `minSharesOut` or `slippageBps` (the minimum defaults to the
+     *   dry run's preview less 0.1%).
+     * @returns The unsigned transaction for the sender's wallet, the shares the
+     *   dry run minted, and the minimum it enforces.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a transaction that cannot be built.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const { transaction } = await sdk.sui.vaultDeposit({
+     *   vaultId: vault.address,
+     *   assetCoinType: vault.depositAssets[0].address,
+     *   shareCoinType: vault.receipt.address,
+     *   amount: 1_000_000n,
+     *   sender: account.address,
+     * });
+     * const digest = await sdk.sui.executeTransaction(
+     *   await dAppKit.signTransaction({ transaction }),
+     * );
+     * ```
+     */
+    async vaultDeposit(params) {
+        const { amount, sender, minSharesOut, slippageBps, ...vault } = params;
+        return SuiActions.buildSuiDepositTransaction({
+            vault: { ...vault, network: this.network },
+            amount,
+            sender,
+            minSharesOut,
+            slippageBps,
+        }, this._config);
+    }
+    /**
+     * Build an unsigned instant redemption on the configured network: charge
+     * the management fee, redeem shares with a minimum net asset amount, send
+     * the assets to the sender.
+     * Dry-runs it first; a vault with a withdrawal queue attached fails with
+     * `queue_attached`.
+     *
+     * Side effect on failure: a redemption the vault rejects is reported to that
+     * vault's curator (fire-and-forget; see `monitoring.curatorAlerts`).
+     *
+     * RPC cost: one dry run (plus the coin lookup it needs).
+     *
+     * @param params - The vault, `shares` in share base units, the `sender`, and
+     *   optionally `minAssetsOut` (net of the instant fee) or `slippageBps` (the
+     *   minimum defaults to the dry run's preview less 0.1%).
+     * @returns The unsigned transaction, the dry run's gross and net assets, and
+     *   the minimum it enforces.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a transaction that cannot be built.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     */
+    async vaultRedeem(params) {
+        const { shares, sender, minAssetsOut, slippageBps, ...vault } = params;
+        return SuiActions.buildSuiRedeemTransaction({
+            vault: { ...vault, network: this.network },
+            shares,
+            sender,
+            minAssetsOut,
+            slippageBps,
+        }, this._config);
+    }
+    /**
+     * Build an unsigned withdrawal request on the configured network, for a
+     * vault with a withdrawal queue attached (where instant redemption is off).
+     * Escrows the shares in a new request; dry-runs it first, so a vault that
+     * would reject it fails here.
+     *
+     * The request is priced when it is claimed. Once the vault's cooldown has
+     * run, claim it with {@link SuiAdapter.claimWithdrawal}; cancel it at any
+     * time with {@link SuiAdapter.vaultCancelRedeemRequest}. List a wallet's
+     * requests with {@link SuiAdapter.getWithdrawalRequests}.
+     *
+     * RPC cost: one object read for a wallet with up to 23 earlier requests on
+     * the vault (one more per further 25), then one dry run.
+     *
+     * @param params - The vault, `shares` in share base units, the `sender`, and
+     *   optionally `payout` (defaults to the sender) and `finalizer`: who besides
+     *   the owner may claim during the first day the request is claimable
+     *   (anyone may after). Defaults to the owner alone; pass a keeper address,
+     *   or `null` to let anyone claim as soon as the cooldown ends.
+     * @returns The unsigned transaction, the request ID, the request's object ID
+     *   (`request`) for claiming or cancelling, and `expectedAssets` at today's
+     *   price.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a transaction that cannot be built.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it,
+     *   e.g. `queue_not_attached` (redeem instantly instead) or `paused`.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const { transaction, request } = await sdk.sui.vaultRequestRedeem({
+     *   vaultId: vault.address,
+     *   assetCoinType: vault.depositAssets[0].address,
+     *   shareCoinType: vault.receipt.address,
+     *   shares: 1_000_000n,
+     *   sender: account.address,
+     * });
+     * await sdk.sui.executeTransaction(await dAppKit.signTransaction({ transaction }));
+     * ```
+     */
+    async vaultRequestRedeem(params) {
+        const { shares, sender, payout, finalizer, ...vault } = params;
+        return SuiActions.buildSuiRequestRedeemTransaction({
+            vault: { ...vault, network: this.network },
+            shares,
+            sender,
+            payout,
+            finalizer,
+        }, this._config);
+    }
+    /**
+     * Build an unsigned cancellation of a pending withdrawal request on the
+     * configured network; the escrowed shares go back to the sender. Allowed at
+     * any time while the request exists, also while the vault is paused. Only
+     * the wallet that made the request may cancel it.
+     *
+     * RPC cost: one dry run.
+     *
+     * @param params - The vault, the `request` object ID and the `sender`.
+     * @returns The unsigned transaction and the shares it returns.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a request that no longer exists.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it,
+     *   e.g. `not_request_owner`.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const { transaction } = await sdk.sui.vaultCancelRedeemRequest({
+     *   vaultId, assetCoinType, shareCoinType, request, sender: account.address,
+     * });
+     * ```
+     */
+    async vaultCancelRedeemRequest(params) {
+        const { request, sender, ...vault } = params;
+        return SuiActions.buildSuiCancelRedeemRequestTransaction({ vault: { ...vault, network: this.network }, request, sender }, this._config);
+    }
+    /**
+     * Build an unsigned claim of a withdrawal request on the configured
+     * network: burns the escrowed shares and pays their current value, with no
+     * instant fee, to the request's payout.
+     *
+     * The payout lands in the payout address's address balance, not as a coin
+     * object. A request can be claimed from `eligibleAtMs` until `expiresAtMs`
+     * by its owner or finalizer (anyone when it names none), and by anyone from
+     * one day after it became eligible.
+     *
+     * RPC cost: one dry run.
+     *
+     * @param params - The vault, the `request` object ID, the `sender`, and
+     *   optionally `minAssetsOut` or `slippageBps` (the minimum defaults to the
+     *   dry run's payout less 0.1%).
+     * @returns The unsigned transaction, the shares it burns, the dry run's
+     *   payout, and the minimum it enforces.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a request that no longer exists.
+     * @throws {@link UpshiftVaultAbortError} when the vault would reject it,
+     *   e.g. `not_eligible_yet`, `request_expired` or `insufficient_liquidity`.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const [pending] = await sdk.sui.getWithdrawalRequests({ ...vault, owner: account.address });
+     * const { transaction } = await sdk.sui.claimWithdrawal({
+     *   ...vault, request: pending.request, sender: account.address,
+     * });
+     * ```
+     */
+    async claimWithdrawal(params) {
+        const { request, sender, minAssetsOut, slippageBps, ...vault } = params;
+        return SuiActions.buildSuiClaimWithdrawalTransaction({
+            vault: { ...vault, network: this.network },
+            request,
+            sender,
+            minAssetsOut,
+            slippageBps,
+        }, this._config);
+    }
+    /**
+     * A wallet's pending withdrawal requests on a vault, on the configured
+     * network, oldest first. Finds every request made through the SDK however
+     * old; claimed and cancelled requests are left out.
+     *
+     * RPC cost: one object read for a wallet that has made up to 23 requests on
+     * the vault (most wallets), one more per further 25.
+     *
+     * @param params - The vault and the `owner` wallet.
+     * @returns The pending requests, with shares, payout, and the times they
+     *   become claimable and expire; empty when there are none.
+     * @throws {@link UpshiftValidationError} for malformed input, unknown
+     *   contract IDs, or a vault ID that is not a vault of the configured
+     *   `sui.originalPackageId`.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     * @example
+     * ```ts
+     * const pending = await sdk.sui.getWithdrawalRequests({
+     *   vaultId, assetCoinType, shareCoinType, owner: account.address,
+     * });
+     * const now = Date.now();
+     * const claimable = pending.filter(
+     *   (r) => r.eligibleAtMs <= now && (r.expiresAtMs === null || now < r.expiresAtMs),
+     * );
+     * ```
+     */
+    async getWithdrawalRequests(params) {
+        const { owner, ...vault } = params;
+        return SuiGetters.getSuiWithdrawalRequests({ ...vault, network: this.network }, owner, this._config);
+    }
+    /**
+     * Execute a wallet-signed transaction on the configured network and wait
+     * until it is indexed. Not needed when the wallet executes the transaction
+     * itself (e.g. dApp Kit's `signAndExecuteTransaction`).
+     *
+     * Side effect on failure: a failed instant redemption is reported to that
+     * vault's curator with its digest (fire-and-forget).
+     *
+     * @param signed - `{ bytes, signature }` from the wallet's `signTransaction`.
+     * @returns The transaction digest.
+     * @throws {@link UpshiftVaultAbortError} when the vault aborted it on chain.
+     * @throws {@link UpshiftSDKError} (`UNKNOWN`) when it failed otherwise.
+     * @throws {@link UpshiftTransactionError} when it executed but was not
+     *   indexed in time.
+     * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+     */
+    async executeTransaction(signed) {
+        return SuiActions.submitSuiTransaction(signed, this.network, this._config);
+    }
 }
+exports.SuiAdapter = SuiAdapter;
 exports.default = SuiAdapter;
 //# sourceMappingURL=index.js.map

package/lib/adapters/sui/targets.d.ts

@@ -29,7 +29,8 @@ export interface ISuiVaultTargetSpec {
  * Every `upshift_vault` function the SDK calls, keyed by a stable name.
  *
  * Vault functions take the `<Asset, Share>` type arguments built by
- * {@link suiVaultTypeArguments}; `withdrawal::share` takes `<Share>` only.
+ * {@link suiVaultTypeArguments}; `withdrawal::share` and `withdrawal::shares`
+ * take `<Share>` only.
  */
 export declare const SUI_VAULT_TARGETS: {
     readonly deposit: {
@@ -67,6 +68,11 @@ export declare const SUI_VAULT_TARGETS: {
         readonly function: "share";
         readonly params: readonly ["WithdrawalRequest<Share>"];
     };
+    readonly withdrawalRequestShares: {
+        readonly module: "withdrawal";
+        readonly function: "shares";
+        readonly params: readonly ["&WithdrawalRequest<Share>"];
+    };
     readonly finalizeWithdrawal: {
         readonly module: "vault";
         readonly function: "finalize_withdrawal";
@@ -107,6 +113,41 @@ export declare const SUI_VAULT_TARGETS: {
         readonly function: "preview_redemption";
         readonly params: readonly ["&Vault<Asset, Share>", "&Registry", "u64", "bool"];
     };
+    readonly decimals: {
+        readonly module: "vault";
+        readonly function: "decimals";
+        readonly params: readonly ["&Vault<Asset, Share>"];
+    };
+    readonly paused: {
+        readonly module: "vault";
+        readonly function: "paused";
+        readonly params: readonly ["&Vault<Asset, Share>"];
+    };
+    readonly queueAttached: {
+        readonly module: "vault";
+        readonly function: "queue_attached";
+        readonly params: readonly ["&Vault<Asset, Share>"];
+    };
+    readonly minDeposit: {
+        readonly module: "vault";
+        readonly function: "min_deposit";
+        readonly params: readonly ["&Vault<Asset, Share>"];
+    };
+    readonly depositCap: {
+        readonly module: "vault";
+        readonly function: "deposit_cap";
+        readonly params: readonly ["&Vault<Asset, Share>"];
+    };
+    readonly maxDepositAmount: {
+        readonly module: "vault";
+        readonly function: "max_deposit_amount";
+        readonly params: readonly ["&Vault<Asset, Share>"];
+    };
+    readonly maxWithdrawalAmount: {
+        readonly module: "vault";
+        readonly function: "max_withdrawal_amount";
+        readonly params: readonly ["&Vault<Asset, Share>"];
+    };
 };
 /** Name of a package function the SDK calls; a key of {@link SUI_VAULT_TARGETS}. */
 export type ISuiVaultTarget = keyof typeof SUI_VAULT_TARGETS;

package/lib/adapters/sui/targets.js

@@ -12,7 +12,8 @@ const constants_1 = require("./constants");
  * Every `upshift_vault` function the SDK calls, keyed by a stable name.
  *
  * Vault functions take the `<Asset, Share>` type arguments built by
- * {@link suiVaultTypeArguments}; `withdrawal::share` takes `<Share>` only.
+ * {@link suiVaultTypeArguments}; `withdrawal::share` and `withdrawal::shares`
+ * take `<Share>` only.
  */
 exports.SUI_VAULT_TARGETS = {
     deposit: {
@@ -86,6 +87,11 @@ exports.SUI_VAULT_TARGETS = {
         function: 'share',
         params: ['WithdrawalRequest<Share>'],
     },
+    withdrawalRequestShares: {
+        module: 'withdrawal',
+        function: 'shares',
+        params: ['&WithdrawalRequest<Share>'],
+    },
     finalizeWithdrawal: {
         module: 'vault',
         function: 'finalize_withdrawal',
@@ -139,6 +145,41 @@ exports.SUI_VAULT_TARGETS = {
         function: 'preview_redemption',
         params: ['&Vault<Asset, Share>', '&Registry', 'u64', 'bool'],
     },
+    decimals: {
+        module: 'vault',
+        function: 'decimals',
+        params: ['&Vault<Asset, Share>'],
+    },
+    paused: {
+        module: 'vault',
+        function: 'paused',
+        params: ['&Vault<Asset, Share>'],
+    },
+    queueAttached: {
+        module: 'vault',
+        function: 'queue_attached',
+        params: ['&Vault<Asset, Share>'],
+    },
+    minDeposit: {
+        module: 'vault',
+        function: 'min_deposit',
+        params: ['&Vault<Asset, Share>'],
+    },
+    depositCap: {
+        module: 'vault',
+        function: 'deposit_cap',
+        params: ['&Vault<Asset, Share>'],
+    },
+    maxDepositAmount: {
+        module: 'vault',
+        function: 'max_deposit_amount',
+        params: ['&Vault<Asset, Share>'],
+    },
+    maxWithdrawalAmount: {
+        module: 'vault',
+        function: 'max_withdrawal_amount',
+        params: ['&Vault<Asset, Share>'],
+    },
 };
 /**
  * Resolve the Upshift vault contract IDs for a Sui config: each `sui` override