@upshiftfinance/sdk 0.2.0 → 0.4.0

package/lib/adapters/sui/getters.js

@@ -0,0 +1,391 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeSuiUint = decodeSuiUint;
+exports.decodeSuiBool = decodeSuiBool;
+exports.parseInstantRedemptionFeeBps = parseInstantRedemptionFeeBps;
+exports.suiConfigForNetwork = suiConfigForNetwork;
+exports.readSuiVaultState = readSuiVaultState;
+exports.previewSuiDeposit = previewSuiDeposit;
+exports.previewSuiRedemption = previewSuiRedemption;
+exports.getSuiShareBalance = getSuiShareBalance;
+exports.suiVaultRefFromRow = suiVaultRefFromRow;
+exports.buildSuiVault = buildSuiVault;
+exports.getSuiVault = getSuiVault;
+const core_1 = require("../../core");
+const chain_address_1 = require("../../core/helpers/chain-address");
+const utils_1 = require("../../modules/vaults/utils");
+const client_1 = require("./client");
+const constants_1 = require("./constants");
+const targets_1 = require("./targets");
+/** Simulations need a sender; no signature or gas is involved. */
+const SIMULATION_SENDER = `0x${'0'.repeat(64)}`;
+/** The contract's "no limit" value for `u64` caps. */
+const U64_MAX = 2n ** 64n - 1n;
+/** Read-only targets {@link readSuiVaultState} calls, in command order. */
+const STATE_READS = [
+    'totalAssets',
+    'totalSupply',
+    'sharePrice',
+    'decimals',
+    'paused',
+    'queueAttached',
+    'minDeposit',
+    'depositCap',
+    'maxDepositAmount',
+    'maxWithdrawalAmount',
+];
+/** Targets that also take the Registry after the vault. */
+const NEEDS_REGISTRY = new Set(['totalAssets', 'sharePrice']);
+/**
+ * Decode a little-endian BCS unsigned integer of `size` bytes.
+ * @internal
+ */
+function decodeSuiUint(bytes, size) {
+    if (bytes.length !== size) {
+        throw new core_1.UpshiftValidationError('INVALID_INPUT', `Sui read: expected a ${size}-byte integer, got ${bytes.length} bytes.`);
+    }
+    let value = 0n;
+    for (let i = size - 1; i >= 0; i -= 1) {
+        value = (value << 8n) | BigInt(bytes[i]);
+    }
+    return value;
+}
+/**
+ * Decode a BCS `bool`.
+ * @internal
+ */
+function decodeSuiBool(bytes) {
+    if (bytes.length !== 1 || bytes[0] > 1) {
+        throw new core_1.UpshiftValidationError('INVALID_INPUT', 'Sui read: expected a BCS bool.');
+    }
+    return bytes[0] === 1;
+}
+/**
+ * Read the instant-redemption fee from the vault object's JSON fields: the fee
+ * sits in a nested struct that a transaction cannot return.
+ * @internal
+ */
+function parseInstantRedemptionFeeBps(json) {
+    const raw = json
+        ?.fee_state?.instant_redemption_fee_bps;
+    const text = typeof raw === 'number' ? String(raw) : raw;
+    if (typeof text !== 'string' || !/^\d+$/.test(text)) {
+        throw new core_1.UpshiftValidationError('INVALID_INPUT', 'Sui read: vault object has no fee_state.instant_redemption_fee_bps.');
+    }
+    return Number(text);
+}
+/**
+ * The `sui` config to use for a vault on `network`: the consumer's config when
+ * it is for that network, else the network alone (built-in endpoint and
+ * contract IDs). A testnet override must never serve a mainnet vault.
+ * @internal
+ */
+function suiConfigForNetwork(network, sui) {
+    return (sui?.network ?? 'mainnet') === network
+        ? { ...sui, network }
+        : { network };
+}
+function assertVaultRef(ref, method) {
+    if (!(0, chain_address_1.isSuiAddress)(ref.vaultId)) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `${method}: vaultId must be a Sui object ID (0x + 64 hex chars).`);
+    }
+}
+/**
+ * Simulate read-only vault calls in one transaction and return each call's
+ * return values (BCS bytes), in order.
+ */
+async function simulateVaultReads(ref, sui, calls) {
+    const config = suiConfigForNetwork(ref.network, sui);
+    const contracts = (0, targets_1.resolveSuiVaultContracts)(config);
+    const { Transaction: SuiTransaction } = await Promise.resolve().then(() => __importStar(require('@mysten/sui/transactions')));
+    const typeArguments = (0, targets_1.suiVaultTypeArguments)(ref.assetCoinType, ref.shareCoinType);
+    return (0, client_1.withSuiClient)((0, client_1.resolveSuiNetworkConfig)(config), async (client) => {
+        // Built per attempt: building resolves object versions against this client.
+        const tx = new SuiTransaction();
+        tx.setSender(SIMULATION_SENDER);
+        for (const call of calls) {
+            tx.moveCall({
+                target: (0, targets_1.suiMoveCallTarget)(contracts, call.target),
+                typeArguments,
+                arguments: [
+                    tx.object(ref.vaultId),
+                    ...(call.registry ? [tx.object(contracts.registryId)] : []),
+                    ...(call.pure?.(tx) ?? []),
+                ],
+            });
+        }
+        const result = await client.core.simulateTransaction({
+            transaction: tx,
+            include: { commandResults: true, effects: true },
+        });
+        if (result.$kind !== 'Transaction') {
+            throw new core_1.UpshiftValidationError('INVALID_INPUT', 'Sui read: vault simulation failed — check the vault ID, its coin types and the contract IDs for this network.', {
+                context: {
+                    network: ref.network,
+                    status: JSON.stringify(result.FailedTransaction?.effects?.status),
+                },
+            });
+        }
+        return result.commandResults.map((c) => c.returnValues.map((v) => v.bcs));
+    });
+}
+/**
+ * Read a vault's on-chain state.
+ *
+ * RPC cost: two requests, run in parallel: one transaction simulation and one
+ * object read. `getVaults` makes these two per Sui vault.
+ *
+ * @param ref - The vault and its coin types and network.
+ * @param sui - The SDK's `sui` config; applied only when its network matches
+ *   `ref.network`.
+ * @returns The vault's state; see {@link ISuiVaultState} for units.
+ * @throws {@link UpshiftValidationError} (`INVALID_ADDRESS`) for a malformed
+ *   vault ID, (`INVALID_INPUT`) when the contract IDs for the network are not
+ *   known or the simulation aborts (wrong vault, coin types or package).
+ * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+ * @example
+ * ```ts
+ * const state = await readSuiVaultState(
+ *   { vaultId, assetCoinType, shareCoinType, network: 'testnet' },
+ *   { network: 'testnet', packageId, originalPackageId, registryId },
+ * );
+ * ```
+ */
+async function readSuiVaultState(ref, sui) {
+    assertVaultRef(ref, 'readSuiVaultState');
+    const config = suiConfigForNetwork(ref.network, sui);
+    const [values, fee] = await Promise.all([
+        simulateVaultReads(ref, sui, STATE_READS.map((target) => ({
+            target,
+            registry: NEEDS_REGISTRY.has(target),
+        }))),
+        (0, client_1.withSuiClient)((0, client_1.resolveSuiNetworkConfig)(config), (client) => client.core.getObject({ objectId: ref.vaultId, include: { json: true } })),
+    ]);
+    const at = (i) => {
+        const bytes = values[i]?.[0];
+        if (!bytes) {
+            throw new core_1.UpshiftValidationError('INVALID_INPUT', `Sui read: ${STATE_READS[i]} returned no value.`);
+        }
+        return bytes;
+    };
+    return {
+        totalAssets: decodeSuiUint(at(0), 16),
+        totalSupply: decodeSuiUint(at(1), 8),
+        sharePrice: decodeSuiUint(at(2), 16),
+        decimals: Number(decodeSuiUint(at(3), 1)),
+        paused: decodeSuiBool(at(4)),
+        queueAttached: decodeSuiBool(at(5)),
+        minDeposit: decodeSuiUint(at(6), 8),
+        depositCap: decodeSuiUint(at(7), 8),
+        maxDepositAmount: decodeSuiUint(at(8), 8),
+        maxWithdrawalAmount: decodeSuiUint(at(9), 8),
+        instantRedemptionFeeBps: parseInstantRedemptionFeeBps(fee.object.json),
+    };
+}
+/**
+ * Shares a deposit would mint at the current price. Limits are not checked.
+ *
+ * RPC cost: one transaction simulation.
+ *
+ * @param ref - The vault and its coin types and network.
+ * @param assets - Deposit amount in asset base units.
+ * @param sui - The SDK's `sui` config; applied only for `ref.network`.
+ * @returns Shares in share base units.
+ * @throws {@link UpshiftValidationError} for a malformed vault ID, a negative
+ *   or out-of-range amount, unknown contract IDs or an aborted simulation.
+ * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+ */
+async function previewSuiDeposit(ref, assets, sui) {
+    assertVaultRef(ref, 'previewSuiDeposit');
+    assertU64(assets, 'previewSuiDeposit', 'assets');
+    const [returned] = await simulateVaultReads(ref, sui, [
+        {
+            target: 'previewDeposit',
+            registry: true,
+            pure: (tx) => [tx.pure.u64(assets)],
+        },
+    ]);
+    return decodeSuiUint(returned[0], 8);
+}
+/**
+ * Assets a redemption of `shares` would pay at the current price.
+ *
+ * RPC cost: one transaction simulation.
+ *
+ * @param ref - The vault and its coin types and network.
+ * @param shares - Shares to redeem, in share base units.
+ * @param isInstant - `true` for instant `redeem` (charges the instant fee),
+ *   `false` for a queued withdrawal (no fee).
+ * @param sui - The SDK's `sui` config; applied only for `ref.network`.
+ * @returns `gross` and `net` (after the instant fee) in asset base units.
+ * @throws {@link UpshiftValidationError} for a malformed vault ID, a negative
+ *   or out-of-range amount, unknown contract IDs or an aborted simulation.
+ * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+ */
+async function previewSuiRedemption(ref, shares, isInstant, sui) {
+    assertVaultRef(ref, 'previewSuiRedemption');
+    assertU64(shares, 'previewSuiRedemption', 'shares');
+    const [returned] = await simulateVaultReads(ref, sui, [
+        {
+            target: 'previewRedemption',
+            registry: true,
+            pure: (tx) => [tx.pure.u64(shares), tx.pure.bool(isInstant)],
+        },
+    ]);
+    return {
+        gross: decodeSuiUint(returned[0], 8),
+        net: decodeSuiUint(returned[1], 8),
+    };
+}
+function assertU64(value, method, name) {
+    if (typeof value !== 'bigint' || value < 0n || value > U64_MAX) {
+        throw new core_1.UpshiftValidationError('INVALID_INPUT', `${method}: ${name} must be a bigint between 0 and 2^64 - 1.`);
+    }
+}
+/**
+ * A wallet's balance of a share coin: coin objects plus the address balance.
+ *
+ * RPC cost: one balance read.
+ *
+ * @param owner - Wallet address (`0x` + 64 hex chars).
+ * @param shareCoinType - Move type of the vault's share coin.
+ * @param network - Network to read.
+ * @param sui - The SDK's `sui` config; applied only for `network`.
+ * @returns Shares in share base units.
+ * @throws {@link UpshiftValidationError} (`INVALID_ADDRESS`) for a malformed
+ *   owner.
+ * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+ */
+async function getSuiShareBalance(owner, shareCoinType, network, sui) {
+    if (!(0, chain_address_1.isSuiAddress)(owner)) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', 'getSuiShareBalance: owner must be a Sui address (0x + 64 hex chars).');
+    }
+    const config = suiConfigForNetwork(network, sui);
+    const { balance } = await (0, client_1.withSuiClient)((0, client_1.resolveSuiNetworkConfig)(config), (client) => client.core.getBalance({ owner, coinType: shareCoinType }));
+    return BigInt(balance.balance);
+}
+/**
+ * The vault reference for a backend row, or `null` when the row has no usable
+ * `sui_vault_metadata`.
+ * @internal
+ */
+function suiVaultRefFromRow(row) {
+    const meta = row.sui_vault_metadata;
+    if (!meta?.share_coin_type || !meta.deposit_coin_type)
+        return null;
+    if (meta.network_name !== 'mainnet' && meta.network_name !== 'testnet') {
+        return null;
+    }
+    return {
+        vaultId: row.address,
+        assetCoinType: meta.deposit_coin_type,
+        shareCoinType: meta.share_coin_type,
+        network: meta.network_name,
+    };
+}
+/**
+ * Build the SDK's `IVault` for a Sui vault from its backend row and, when the
+ * read succeeded, its on-chain state. Without state, total assets fall back
+ * to the backend's `latest_reported_tvl`, supply to zero, and the vault is
+ * marked deposit-paused so no deposit is offered on unread state.
+ * @internal
+ */
+function buildSuiVault(row, state) {
+    const meta = row.sui_vault_metadata;
+    const decimals = state?.decimals ?? meta?.deposit_token_decimals ?? 0;
+    const vault = (0, utils_1.buildBackendVault)(row, {
+        chainId: constants_1.SUI_CHAIN_ID,
+        version: 'sui-0',
+        name: row.vault_name || 'Sui Vault',
+        totalAssets: state
+            ? (0, core_1.toNormalizedBn)(state.totalAssets, decimals)
+            : (0, utils_1.backendTvlToNormalizedBn)(row.latest_reported_tvl, decimals),
+        totalSupply: (0, core_1.toNormalizedBn)(state?.totalSupply ?? 0n, decimals),
+        depositAssets: [
+            {
+                address: meta?.deposit_coin_type ?? '',
+                symbol: meta?.deposit_token_symbol ?? 'UNKNOWN',
+                decimals,
+            },
+        ],
+        receipt: {
+            address: meta?.share_coin_type ?? '',
+            symbol: row.receipt_token_symbol || 'UNKNOWN',
+            decimals,
+        },
+        isDepositPaused: !state || state.paused || !meta?.deposit_coin_type,
+        isWithdrawalPaused: state?.paused ?? false,
+    });
+    // u64::MAX is the contract's "no cap"; leave the field unset for it.
+    if (state && state.depositCap !== U64_MAX) {
+        vault.depositCap = (0, core_1.toNormalizedBn)(state.depositCap, decimals);
+    }
+    return vault;
+}
+/**
+ * Build a Sui vault's `IVault` from its backend row plus on-chain state.
+ *
+ * A failed read (unknown contract IDs, every endpoint down, an aborted
+ * simulation) does not fail the call: the vault is built from the backend row
+ * alone (see {@link buildSuiVault}) and a warning is logged.
+ *
+ * RPC cost: as {@link readSuiVaultState}.
+ *
+ * @param row - Backend `tokenized_vault` row with `sui_vault_metadata`.
+ * @param options - Vault options; `options.sui` carries the SDK's `sui` config.
+ * @returns The vault.
+ * @throws {@link UpshiftValidationError} (`INVALID_INPUT`) when the row has no
+ *   usable `sui_vault_metadata` (e.g. a legacy Ember/Gamma Sui vault).
+ */
+async function getSuiVault(row, options) {
+    const ref = suiVaultRefFromRow(row);
+    if (!ref) {
+        throw new core_1.UpshiftValidationError('INVALID_INPUT', 'getSuiVault: not an Upshift Sui vault — the backend row has no usable sui_vault_metadata.', { context: { vault: row.address } });
+    }
+    let state = null;
+    try {
+        state = await readSuiVaultState(ref, options?.sui);
+    }
+    catch (err) {
+        core_1.Logger.log.warn('getSuiVault', 'On-chain read failed — using backend values', {
+            vault: row.address,
+            network: ref.network,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    return buildSuiVault(row, state);
+}
+//# sourceMappingURL=getters.js.map

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

@@ -4,8 +4,10 @@
  * @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';
 export declare const Sui: {
@@ -13,12 +15,28 @@ export declare const Sui: {
     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
@@ -53,5 +71,80 @@ 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
+     *   an optional `minSharesOut` (defaults to the dry run's exact preview).
+     * @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,
+     * });
+     * await dAppKit.signAndExecuteTransaction({ transaction });
+     * ```
+     */
+    vaultDeposit(params: ISuiAdapterVault & {
+        amount: bigint;
+        sender: string;
+        minSharesOut?: bigint;
+    }): Promise<SuiActions.ISuiDepositTransaction>;
+    /**
+     * Build an unsigned instant redemption on the configured network: 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
+     *   an optional `minAssetsOut` net of the instant fee (defaults to the dry
+     *   run's exact preview).
+     * @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;
+    }): Promise<SuiActions.ISuiRedeemTransaction>;
+    /**
+     * 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

@@ -34,8 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 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"));
 exports.Sui = {
@@ -43,12 +45,15 @@ exports.Sui = {
     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 +100,91 @@ 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
+     *   an optional `minSharesOut` (defaults to the dry run's exact preview).
+     * @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,
+     * });
+     * await dAppKit.signAndExecuteTransaction({ transaction });
+     * ```
+     */
+    async vaultDeposit(params) {
+        const { amount, sender, minSharesOut, ...vault } = params;
+        return SuiActions.buildSuiDepositTransaction({
+            vault: { ...vault, network: this.network },
+            amount,
+            sender,
+            minSharesOut,
+        }, this._config);
+    }
+    /**
+     * Build an unsigned instant redemption on the configured network: 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
+     *   an optional `minAssetsOut` net of the instant fee (defaults to the dry
+     *   run's exact preview).
+     * @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, ...vault } = params;
+        return SuiActions.buildSuiRedeemTransaction({
+            vault: { ...vault, network: this.network },
+            shares,
+            sender,
+            minAssetsOut,
+        }, 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.default = SuiAdapter;
 //# sourceMappingURL=index.js.map

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

@@ -107,6 +107,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;