@upshiftfinance/sdk 0.3.0 → 0.5.0

package/lib/adapters/sui/getters.js

@@ -0,0 +1,669 @@
+"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.getSuiWithdrawalRequests = getSuiWithdrawalRequests;
+exports.suiPositionRedemptions = suiPositionRedemptions;
+exports.getSuiPositionRedemptions = getSuiPositionRedemptions;
+exports.nextSuiWithdrawalRequestId = nextSuiWithdrawalRequestId;
+exports.deriveSuiWithdrawalRequestId = deriveSuiWithdrawalRequestId;
+exports.suiVaultRefFromRow = suiVaultRefFromRow;
+exports.buildSuiVault = buildSuiVault;
+exports.getSuiVault = getSuiVault;
+const types_1 = require("../../types");
+const core_1 = require("../../core");
+const errors_1 = require("../../core/errors");
+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");
+/**
+ * Re-throw a failed read as a typed SDK error: SDK errors pass through, and
+ * anything else (an object that does not exist, a malformed coin type, a
+ * package that is not the vault package) becomes `INVALID_INPUT`.
+ */
+function asReadError(err, network) {
+    if (err instanceof core_1.UpshiftSDKError)
+        throw err;
+    throw new core_1.UpshiftValidationError('INVALID_INPUT', `Sui read failed — check the vault ID, its coin types and the contract IDs for this network: ${err instanceof Error ? err.message : String(err)}`, { cause: err, context: { network } });
+}
+/** 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);
+        // Charge the management fee accrued since the last charge first, so every
+        // read sees the current NAV. A simulation persists nothing.
+        tx.moveCall({
+            target: (0, targets_1.suiMoveCallTarget)(contracts, 'chargeManagementFee'),
+            typeArguments,
+            arguments: [
+                tx.object(ref.vaultId),
+                tx.object(contracts.registryId),
+                tx.object(constants_1.SUI_CLOCK_ID),
+            ],
+        });
+        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),
+                },
+            });
+        }
+        // Drop the fee charge's (empty) result so indexes match `calls`.
+        return result.commandResults
+            .slice(1)
+            .map((c) => c.returnValues.map((v) => v.bcs));
+    }).catch((err) => asReadError(err, ref.network));
+}
+/**
+ * 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 } })).catch((err) => asReadError(err, ref.network)),
+    ]);
+    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 })).catch((err) => asReadError(err, network));
+    return BigInt(balance.balance);
+}
+/**
+ * IDs checked per object read: each needs its claim marker and its request,
+ * and the gRPC client sends at most 50 objects per request. The first page
+ * also carries the vault object, so it checks one ID fewer.
+ */
+const REQUEST_SCAN_PAGE = 25;
+/**
+ * Walk a wallet's request IDs on a vault, `0, 1, 2, …`, and read each one.
+ *
+ * The contract derives a request's object ID from (vault, owner, request ID)
+ * and leaves a permanent claim marker on the vault for every ID ever used,
+ * also after the request is claimed or cancelled. The SDK numbers requests
+ * sequentially, so the first ID without a marker is the next one to use, and
+ * every request below it that still exists is pending. This needs neither an
+ * event index (public fullnodes keep about two weeks of events) nor an
+ * indexer.
+ *
+ * Requests made outside the SDK with other IDs are not found.
+ *
+ * The first read also checks that `ref.vaultId` is a vault of the configured
+ * original package, so a wrong vault ID or `sui.originalPackageId` (which
+ * names the request IDs) fails loudly instead of finding nothing.
+ *
+ * RPC cost: one object read for up to 23 used IDs, one more per further 25.
+ */
+async function scanSuiWithdrawalRequests(ref, owner, sui) {
+    const config = suiConfigForNetwork(ref.network, sui);
+    const contracts = (0, targets_1.resolveSuiVaultContracts)(config);
+    const [{ bcs }, { deriveDynamicFieldID }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('@mysten/sui/bcs'))),
+        Promise.resolve().then(() => __importStar(require('@mysten/sui/utils'))),
+    ]);
+    const WithdrawalRequest = bcs.struct('WithdrawalRequest', {
+        id: bcs.Address,
+        vaultId: bcs.Address,
+        owner: bcs.Address,
+        requestId: bcs.u64(),
+        shares: bcs.u64(),
+        payout: bcs.Address,
+        finalizer: bcs.option(bcs.Address),
+        requestedAtMs: bcs.u64(),
+        eligibleAtMs: bcs.u64(),
+        expiresAtMs: bcs.option(bcs.u64()),
+    });
+    const requests = [];
+    for (let start = 0n;;) {
+        const first = start === 0n;
+        const size = first ? REQUEST_SCAN_PAGE - 1 : REQUEST_SCAN_PAGE;
+        const ids = Array.from({ length: size }, (_, i) => start + BigInt(i));
+        start += BigInt(size);
+        const requestIds = await Promise.all(ids.map((requestId) => deriveSuiWithdrawalRequestId(ref.vaultId, owner, requestId, contracts.originalPackageId)));
+        // The marker is a dynamic field on the vault keyed by the request ID.
+        const markerIds = requestIds.map((id) => deriveDynamicFieldID(ref.vaultId, '0x2::derived_object::Claimed', bcs.Address.serialize(id).toBytes()));
+        const { objects } = await (0, client_1.withSuiClient)((0, client_1.resolveSuiNetworkConfig)(config), (client) => client.core.getObjects({
+            objectIds: [
+                ...markerIds,
+                ...requestIds,
+                ...(first ? [ref.vaultId] : []),
+            ],
+            include: { content: true },
+        })).catch((err) => asReadError(err, ref.network));
+        const missing = (o) => {
+            if (!(o instanceof Error))
+                return false;
+            const reason = o.reason;
+            if (reason === 'notFound' || reason === 'deleted')
+                return true;
+            // Any other per-object error means the node did not answer for it.
+            throw new errors_1.UpshiftNetworkError(`Sui read: withdrawal request lookup failed: ${o.message}`, { cause: o, context: { network: ref.network } });
+        };
+        if (first) {
+            const vault = objects[2 * size];
+            // A missing vault is a wrong ID; any other per-object error is the node.
+            assertVaultOfPackage(missing(vault) ? undefined : vault, ref, contracts);
+        }
+        for (let i = 0; i < size; i += 1) {
+            if (missing(objects[i])) {
+                return { nextRequestId: ids[i], requests };
+            }
+            const object = objects[size + i];
+            // Claimed but gone: the request was claimed or cancelled.
+            if (missing(object) || object instanceof Error)
+                continue;
+            const parsed = WithdrawalRequest.parse(object.content);
+            requests.push({
+                request: requestIds[i],
+                requestId: BigInt(parsed.requestId),
+                owner: parsed.owner,
+                shares: BigInt(parsed.shares),
+                payout: parsed.payout,
+                finalizer: parsed.finalizer ?? null,
+                requestedAtMs: Number(parsed.requestedAtMs),
+                eligibleAtMs: Number(parsed.eligibleAtMs),
+                expiresAtMs: parsed.expiresAtMs == null ? null : Number(parsed.expiresAtMs),
+            });
+        }
+    }
+}
+/**
+ * Throw unless `object` is the vault `ref` names, typed by the configured
+ * original package: request IDs are derived from that package, so a wrong one
+ * would make every request invisible.
+ */
+function assertVaultOfPackage(object, ref, contracts) {
+    const type = object instanceof Error ? undefined : object?.type;
+    const expected = `${contracts.originalPackageId}::vault::Vault<`.toLowerCase();
+    if (!type) {
+        throw new core_1.UpshiftValidationError('INVALID_INPUT', 'Sui read: the vault object was not found — check the vault ID for this network.', { context: { network: ref.network } });
+    }
+    if (!type.toLowerCase().startsWith(expected)) {
+        throw new core_1.UpshiftValidationError('INVALID_INPUT', `Sui read: ${ref.vaultId} is not a vault of the configured original package (its type is ${type}) — check the vault ID and sui.originalPackageId.`, { context: { network: ref.network } });
+    }
+}
+function assertOwner(owner, method) {
+    if (!(0, chain_address_1.isSuiAddress)(owner)) {
+        throw new core_1.UpshiftValidationError('INVALID_ADDRESS', `${method}: owner must be a Sui address (0x + 64 hex chars).`);
+    }
+}
+/**
+ * A wallet's pending withdrawal requests on a vault, oldest first.
+ *
+ * Finds the requests the SDK made (see `buildSuiRequestRedeemTransaction`),
+ * however old: requests made outside the SDK with non-sequential IDs are not
+ * listed. Claimed and cancelled requests no longer exist and 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 ref - The vault and its coin types and network.
+ * @param owner - Wallet that made the requests (`0x` + 64 hex chars).
+ * @param sui - The SDK's `sui` config; applied only for `ref.network`.
+ * @returns The pending requests; empty when there are none.
+ * @throws {@link UpshiftValidationError} (`INVALID_ADDRESS`) for a malformed
+ *   vault ID or owner, (`INVALID_INPUT`) for 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, or the
+ *   node cannot answer for one of the objects.
+ * @example
+ * ```ts
+ * const pending = await getSuiWithdrawalRequests(ref, account.address, sdkSuiConfig);
+ * const now = Date.now();
+ * const claimable = pending.filter(
+ *   (r) => r.eligibleAtMs <= now && (r.expiresAtMs === null || now < r.expiresAtMs),
+ * );
+ * ```
+ */
+async function getSuiWithdrawalRequests(ref, owner, sui) {
+    assertVaultRef(ref, 'getSuiWithdrawalRequests');
+    assertOwner(owner, 'getSuiWithdrawalRequests');
+    return (await scanSuiWithdrawalRequests(ref, owner, sui)).requests;
+}
+/**
+ * Split a wallet's withdrawal requests into position redemptions, the way
+ * the EVM and Solana paths do: `availableRedemptions` holds requests still in
+ * their cooldown or past their window (cancel-only), `pendingRedemptions` the
+ * ones claimable now. Each entry's `amount` is the escrowed shares; `date` is
+ * when it becomes claimable, `timestamp` when it was made (Unix seconds).
+ * @internal
+ */
+function suiPositionRedemptions(requests, vault, decimals, nowMs) {
+    const availableRedemptions = [];
+    const pendingRedemptions = [];
+    for (const r of requests) {
+        const status = r.expiresAtMs !== null && nowMs >= r.expiresAtMs
+            ? types_1.VaultRedemptionStatus.EXPIRED
+            : nowMs >= r.eligibleAtMs
+                ? types_1.VaultRedemptionStatus.READY_TO_CLAIM
+                : types_1.VaultRedemptionStatus.AWAITING_COOLDOWN;
+        const date = new Date(r.eligibleAtMs);
+        const entry = {
+            id: r.request,
+            hash: r.request,
+            timestamp: Math.floor(r.requestedAtMs / 1000),
+            receiver: r.payout,
+            day: (0, core_1.toNormalizedBn)(date.getUTCDate(), 0),
+            month: (0, core_1.toNormalizedBn)(date.getUTCMonth() + 1, 0),
+            year: (0, core_1.toNormalizedBn)(date.getUTCFullYear(), 0),
+            amount: (0, core_1.toNormalizedBn)(r.shares, decimals),
+            date,
+            vault: vault,
+            status,
+        };
+        if (status === types_1.VaultRedemptionStatus.READY_TO_CLAIM) {
+            pendingRedemptions.push(entry);
+        }
+        else {
+            availableRedemptions.push(entry);
+        }
+    }
+    return { availableRedemptions, pendingRedemptions };
+}
+/**
+ * A wallet's withdrawal requests on a vault as position redemptions (see
+ * {@link suiPositionRedemptions}). Empty when the SDK has no contract IDs for
+ * the network: the share balance can still be read without them, so a
+ * position should not fail for that.
+ *
+ * RPC cost: as {@link getSuiWithdrawalRequests}; none without contract IDs.
+ * @internal
+ */
+async function getSuiPositionRedemptions(ref, owner, decimals, sui) {
+    const config = suiConfigForNetwork(ref.network, sui);
+    const defaults = constants_1.SUI_VAULT_CONTRACTS[ref.network];
+    const configured = (config.packageId ?? defaults.packageId) &&
+        (config.originalPackageId ?? defaults.originalPackageId) &&
+        (config.registryId ?? defaults.registryId);
+    if (!configured) {
+        return suiPositionRedemptions([], ref.vaultId, decimals, Date.now());
+    }
+    const requests = await getSuiWithdrawalRequests(ref, owner, sui);
+    return suiPositionRedemptions(requests, ref.vaultId, decimals, Date.now());
+}
+/**
+ * The request ID a wallet's next withdrawal request on a vault takes: the
+ * lowest it has never used.
+ *
+ * RPC cost: as {@link getSuiWithdrawalRequests}.
+ * @internal
+ */
+async function nextSuiWithdrawalRequestId(ref, owner, sui) {
+    assertVaultRef(ref, 'nextSuiWithdrawalRequestId');
+    assertOwner(owner, 'nextSuiWithdrawalRequestId');
+    return (await scanSuiWithdrawalRequests(ref, owner, sui)).nextRequestId;
+}
+/**
+ * The object ID of a wallet's withdrawal request: derived from the vault, the
+ * owner and the request ID, as the contract derives it.
+ *
+ * @param vaultId - Vault object ID.
+ * @param owner - Wallet that made the request.
+ * @param requestId - The wallet's numeric request ID on the vault.
+ * @param originalPackageId - The original `upshift_vault` package, which
+ *   names the derivation key type.
+ * @returns The request object ID.
+ * @internal
+ */
+async function deriveSuiWithdrawalRequestId(vaultId, owner, requestId, originalPackageId) {
+    const [{ bcs }, { deriveObjectID, normalizeSuiAddress }] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('@mysten/sui/bcs'))),
+        Promise.resolve().then(() => __importStar(require('@mysten/sui/utils'))),
+    ]);
+    const key = bcs
+        .struct('RequestKey', { owner: bcs.Address, requestId: bcs.u64() })
+        .serialize({ owner: normalizeSuiAddress(owner), requestId })
+        .toBytes();
+    return deriveObjectID(normalizeSuiAddress(vaultId), `${originalPackageId}::withdrawal::RequestKey`, key);
+}
+/**
+ * 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 `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