@ember-finance/sdk 2.15.0-ccip.0 → 2.16.0

package/dist/src/evm-vaults/utils/deployment-parser.js

@@ -206,78 +206,4 @@ export class EVMDeploymentParser {
         }
         return entry;
     }
-    /**
-     * Finds the CCIP token pool entry for a given vault address.
-     * @param vaultAddress The vault address (receipt token address in EVM deployment data)
-     */
-    getCcipTokenPoolByVaultAddress(vaultAddress) {
-        return Object.values(this.deployment.contracts?.ccipTokenPools ?? {}).find(pool => pool.vaultAddress?.toLowerCase() === vaultAddress.toLowerCase());
-    }
-    /**
-     * Reports which bridge a vault uses, or undefined if it has none.
-     *
-     * A vault has exactly one active bridge, but different vaults use different
-     * ones, so call this before choosing between the LayerZero and CCIP send
-     * methods rather than assuming either.
-     *
-     * @param vaultAddress The vault address (receipt token address in EVM deployment data)
-     */
-    getBridgeTransportByVaultAddress(vaultAddress) {
-        if (this.getCcipTokenPoolByVaultAddress(vaultAddress))
-            return "CCIP";
-        if (this.getOFTAdapterObjectByVaultAddress(vaultAddress))
-            return "LayerZero";
-        return undefined;
-    }
-    /**
-     * Lists the networks a vault can bridge to, whichever transport it uses.
-     *
-     * Returns an empty array for a vault with no bridge, so it is safe to render
-     * directly. Names are as the deployment records them, which is what
-     * bridgeSendTokenViaCcip takes as its destination.
-     *
-     * @param vaultAddress The vault address (receipt token address in EVM deployment data)
-     */
-    getBridgeDestinationsByVaultAddress(vaultAddress) {
-        // Both transports record the far end the same way, under remoteNetwork,
-        // but one keys its map by CCIP chain selector and the other by LayerZero
-        // endpoint id — neither of which a caller has any way to resolve. Reading
-        // the values rather than the keys is what keeps the two symmetric.
-        const pool = this.getCcipTokenPoolByVaultAddress(vaultAddress);
-        const adapter = this.getOFTAdapterObjectByVaultAddress(vaultAddress);
-        const networks = [
-            ...Object.values(pool?.lanes ?? {}),
-            ...Object.values(adapter?.peers ?? {})
-        ]
-            .map(entry => entry.remoteNetwork)
-            .filter((network) => !!network);
-        return [...new Set(networks)];
-    }
-    /**
-     * Finds the configured CCIP lane from a vault to a destination chain selector.
-     *
-     * A missing lane means the route is not configured and a send would revert.
-     *
-     * @param vaultAddress The vault address on the source chain
-     * @param remoteChainSelector The destination CCIP chain selector
-     */
-    getCcipLaneByVaultAndSelector(vaultAddress, remoteChainSelector) {
-        // Lanes are keyed by selector, so this is a direct hit rather than the
-        // scan the by-network lookup has to do.
-        return this.getCcipTokenPoolByVaultAddress(vaultAddress)?.lanes?.[remoteChainSelector];
-    }
-    /**
-     * Finds the configured CCIP lane from a vault to a destination network.
-     *
-     * Lanes are keyed by the destination's CCIP chain selector, which nothing
-     * outside CCIP knows, so this looks the lane up by network name instead.
-     * A missing lane means the route is not configured — sending would revert.
-     *
-     * @param vaultAddress The vault address on the source chain
-     * @param destinationNetwork The destination network name, e.g. "atlantic"
-     */
-    getCcipLaneByVaultAndNetwork(vaultAddress, destinationNetwork) {
-        const pool = this.getCcipTokenPoolByVaultAddress(vaultAddress);
-        return Object.values(pool?.lanes ?? {}).find(lane => lane.remoteNetwork?.toLowerCase() === destinationNetwork.toLowerCase());
-    }
 }

package/dist/src/evm-vaults/utils/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./deployment-parser.js";
 export * from "./permit-utils.js";
-export * from "./ccip.js";

package/dist/src/evm-vaults/utils/index.js

@@ -1,3 +1,2 @@
 export * from "./deployment-parser.js";
 export * from "./permit-utils.js";
-export * from "./ccip.js";

package/dist/src/placements/pointers.js

@@ -1,5 +1,6 @@
 import { environmentConfig } from "../common/constants.js";
-import { coinTypesMatch } from "./sui.js";
+import { isAbortError, isTransientStatus, retryAfterMs } from "./batch.js";
+import { coinTypesMatch, normalizeCoinType } from "./sui.js";
 /**
  * Pointers held in memory. Useful for tests, and for pinning a known venue set
  * without a round-trip.
@@ -35,69 +36,152 @@ export function httpPointerSource(options = {}) {
     const path = options.path ?? "/api/v2/vaults/placements";
     const cacheMs = options.cacheMs ?? 30000;
     /**
-     * One request per coin, not per (coin, protocol).
-     *
-     * `?coin=` already returns every protocol's rows, so asking once per adapter
-     * fetched the same list five times and threw four of them away. Reading one
-     * vault meant eight requests where two would do, and a caller sweeping every
-     * vault made hundreds — enough to be rate-limited, and a rejected discover
-     * drops that venue from the answer.
+     * One request for every coin. The endpoint answers with the whole registry
+     * when `coin` is omitted, so reading every vault costs one call rather than
+     * one per receipt coin.
      *
      * In-flight requests are shared rather than merely cached, so the adapters
      * racing each other at the start of a `forAccount` collapse into one call.
      */
     const inFlight = new Map();
-    const rowsForCoin = (coin) => {
-        const key = coin.coin.toLowerCase();
+    // Set when the server rejects the unfiltered call, i.e. it predates it.
+    // Rechecked after a while, so a long-lived source picks up a server that
+    // has since been upgraded.
+    let perCoinUntil = 0;
+    const shared = (key, load) => {
         const hit = inFlight.get(key);
         if (hit && Date.now() - hit.at < cacheMs)
             return hit.rows;
-        const rows = (async () => {
-            const url = new URL(`${baseUrl.replace(/\/$/, "")}${path}`);
-            url.searchParams.set("coin", coin.coin);
-            const response = await fetch(url.toString(), {
-                headers: { Accept: "application/json" }
-            });
-            if (!response.ok) {
-                throw new Error(`pointer source ${response.status}`);
-            }
-            const body = (await response.json());
-            // The chain type comes from the coin, not the wire: an adapter only
-            // ever runs on its own chain, so a server that named it again could
-            // only ever disagree.
-            return (body.placements ?? []).map(placement => ({
-                id: placement.id,
-                protocol: placement.protocol,
-                chain: {
-                    type: coin.chain.type,
-                    chainId: placement.chainId,
-                    identifier: placement.chainIdentifier
-                },
-                venue: placement.venue,
-                coin: placement.coin,
-                decimals: requireDecimals(placement),
-                protocolName: placement.protocolName,
-                protocolLogoUrl: placement.protocolLogoUrl,
-                source: placement.source,
-                label: placement.label,
-                shareToken: placement.shareToken,
-                url: placement.url,
-                rpcUrl: placement.rpcUrl
-            }));
-        })();
+        const rows = load();
         // A failure is not cached: the next adapter should retry rather than
         // inherit a rejection it never caused.
         rows.catch(() => inFlight.delete(key));
         inFlight.set(key, { at: Date.now(), rows });
         return rows;
     };
+    const request = (coin) => {
+        const url = new URL(`${baseUrl.replace(/\/$/, "")}${path}`);
+        if (coin !== undefined)
+            url.searchParams.set("coin", coin);
+        return fetchPlacements(url.toString());
+    };
+    const rowsFor = async (coin) => {
+        if (Date.now() >= perCoinUntil) {
+            try {
+                return await shared("*", () => request());
+            }
+            catch (error) {
+                if (!(error instanceof PointerSourceError) || error.status !== 400) {
+                    throw error;
+                }
+                perCoinUntil = Date.now() + FALLBACK_RECHECK_MS;
+            }
+        }
+        return shared(coin.coin.toLowerCase(), () => request(coin.coin));
+    };
     return {
         async placements(protocol, coin) {
-            const rows = await rowsForCoin(coin);
-            return rows.filter(ref => ref.protocol === protocol);
+            const rows = await rowsFor(coin);
+            const wanted = coinKey(coin.coin);
+            // One venue stored under two spellings of the coin would otherwise
+            // be read twice and double-count the position.
+            const seen = new Set();
+            return (rows
+                .filter(row => {
+                if (row.protocol !== protocol || coinKey(row.coin) !== wanted) {
+                    return false;
+                }
+                const key = [row.chainIdentifier, row.venue, row.shareToken ?? ""]
+                    .join(":")
+                    .toLowerCase();
+                if (seen.has(key))
+                    return false;
+                seen.add(key);
+                return true;
+            })
+                // The chain type comes from the coin, not the wire: an adapter
+                // only ever runs on its own chain, so a server that named it
+                // again could only ever disagree.
+                .map(row => ({
+                id: row.id,
+                protocol: row.protocol,
+                chain: {
+                    type: coin.chain.type,
+                    chainId: row.chainId,
+                    identifier: row.chainIdentifier
+                },
+                venue: row.venue,
+                coin: row.coin,
+                decimals: requireDecimals(row),
+                protocolName: row.protocolName,
+                protocolLogoUrl: row.protocolLogoUrl,
+                source: row.source,
+                label: row.label,
+                shareToken: row.shareToken,
+                url: row.url,
+                rpcUrl: row.rpcUrl
+            })));
         }
     };
 }
+class PointerSourceError extends Error {
+    constructor(status) {
+        super(`pointer source ${status}`);
+        this.status = status;
+        this.name = "PointerSourceError";
+    }
+}
+const FETCH_ATTEMPTS = 3;
+const RETRY_BASE_MS = 250;
+const RETRY_MAX_MS = 2000;
+const FALLBACK_RECHECK_MS = 5 * 60000;
+/**
+ * Retries transient failures. Every vault's venues now ride on this one
+ * request, and callers keep a failed discover rather than retrying it.
+ */
+async function fetchPlacements(url) {
+    for (let attempt = 1;; attempt++) {
+        let waitMs;
+        try {
+            const response = await fetch(url, {
+                headers: { Accept: "application/json" }
+            });
+            if (response.ok) {
+                const body = (await response.json());
+                return body.placements ?? [];
+            }
+            if (!isTransientStatus(response.status) || attempt >= FETCH_ATTEMPTS) {
+                throw new PointerSourceError(response.status);
+            }
+            waitMs = retryAfterMs(response.headers?.get("retry-after"));
+            // Retrying before the server asked would only add to the load it
+            // is shedding and fail again.
+            if (waitMs !== undefined && waitMs > RETRY_MAX_MS) {
+                throw new PointerSourceError(response.status);
+            }
+        }
+        catch (error) {
+            // fetch rejects only on network failure; retry that, not our own
+            // errors or an abort.
+            if (error instanceof PointerSourceError ||
+                isAbortError(error) ||
+                attempt >= FETCH_ATTEMPTS) {
+                throw error;
+            }
+        }
+        const backoff = Math.min(RETRY_BASE_MS * 2 ** (attempt - 1), RETRY_MAX_MS);
+        await new Promise(resolve => setTimeout(resolve, waitMs ?? backoff));
+    }
+}
+/**
+ * Coin identity across spellings. `coinTypesMatch` folds a Sui address; EVM
+ * addresses are compared case-insensitively and with or without `0x`, since
+ * the API returns them lowercased and the vaults list checksums them.
+ */
+function coinKey(coin) {
+    const normalized = normalizeCoinType(coin);
+    return normalized.includes("::") ? normalized : normalized.replace(/^0x/, "");
+}
 /**
  * Merges what every source returns, de-duplicated by venue. Earlier sources win,
  * so a caller can pin rows ahead of a remote set. A source that throws is

package/dist/src/sui-vaults/on-chain-calls/atomic-liquidity.js

@@ -1,8 +1,8 @@
 import { bcs } from "@mysten/sui/bcs";
+import { tableIdOf, unwrapMoveFields } from "../utils/common.js";
 import { computeSwapQuote, computePlainInstantQuote } from "../../atomic/instant-withdraw.js";
 /** Sui fixed-point scale (1e9) used by the Atomic Liquidity Vault Move math. */
 const SUI_SCALE = 1000000000n;
-const unwrapMoveFields = (value) => value?.fields ?? value;
 const toBig = (v) => v === undefined || v === null ? 0n : BigInt(v);
 /** `math::div(a, b)` = floor(a * scale / b). */
 const divFloor = (a, b) => (b === 0n ? 0n : (a * SUI_SCALE) / b);
@@ -73,7 +73,7 @@ export class SuiAtomicLiquidityReader {
     /** Per-source-share EmberShare config from the `ember_share_configs` table. */
     async getEmberShareConfig(vaultId, sourceVaultId) {
         const fields = await this.vaultFields(vaultId);
-        const tableId = unwrapMoveFields(fields.ember_share_configs)?.id?.id;
+        const tableId = tableIdOf(fields.ember_share_configs);
         if (!tableId)
             return null;
         {
@@ -102,7 +102,7 @@ export class SuiAtomicLiquidityReader {
     /** Caller's ALV (non-transferable) share balance from the `shares` table. */
     async shareOf(vaultId, account) {
         const fields = await this.vaultFields(vaultId);
-        const tableId = unwrapMoveFields(fields.shares)?.id?.id;
+        const tableId = tableIdOf(fields.shares);
         if (!tableId)
             return 0n;
         return toBig(await this.readTableValue(tableId, "address", account));

package/dist/src/sui-vaults/on-chain-calls/tx-builder.d.ts

@@ -466,7 +466,7 @@ export declare class TxBuilder {
      * @param options Optional tx building params
      * @returns TransactionBlock
      */
-    atomicSetEmberShareWhitelist(vaultId: string, shareVaultId: string, whitelisted: boolean, feePercentage: NumStr, maxCapacityPercentage: NumStr, holdbackPercentage: NumStr, maxUtilizationPercentage: NumStr, options?: ITxBuilderOptionalParams): TransactionBlock;
+    atomicSetEmberShareWhitelist(vaultId: string, shareVaultId: string, whitelisted: boolean, feePercentage: NumStr, maxCapacityPercentage: NumStr, holdbackPercentage: NumStr, maxUtilizationPercentage: NumStr, minSwapGross: NumStr, maxHeldValueAbsolute: NumStr, options?: ITxBuilderOptionalParams): TransactionBlock;
     /**
      * Sets the max utilization percentage of an ember share source vault
      * @param vaultId Id of the atomic vault
@@ -556,7 +556,7 @@ export declare class TxBuilder {
      * @param options Optional tx building params
      * @returns TransactionBlock
      */
-    atomicSetStrategyNoneFromAlphalend(vaultId: string, lendingProtocolId: string, options?: ITxBuilderOptionalParams): TransactionBlock;
+    atomicSetStrategyNoneFromAlphalend(vaultId: string, lendingProtocolId: string, acceptResidual: boolean, options?: ITxBuilderOptionalParams): TransactionBlock;
     /**
      * Step 1 of 2 for Suilend activation: commits the reserve index, the market
      * object and the collateral type. Step 2 is `atomicOpenSuilendObligation`,

package/dist/src/sui-vaults/on-chain-calls/tx-builder.js

@@ -1452,7 +1452,7 @@ export class TxBuilder {
      * @param options Optional tx building params
      * @returns TransactionBlock
      */
-    atomicSetEmberShareWhitelist(vaultId, shareVaultId, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, options) {
+    atomicSetEmberShareWhitelist(vaultId, shareVaultId, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, minSwapGross, maxHeldValueAbsolute, options) {
         const txb = options?.txBlock || new TransactionBlock();
         txb.moveCall({
             arguments: [
@@ -1463,7 +1463,9 @@ export class TxBuilder {
                 txb.pure.u64(feePercentage),
                 txb.pure.u64(maxCapacityPercentage),
                 txb.pure.u64(holdbackPercentage),
-                txb.pure.u64(maxUtilizationPercentage)
+                txb.pure.u64(maxUtilizationPercentage),
+                txb.pure.u64(minSwapGross),
+                txb.pure.u64(maxHeldValueAbsolute)
             ],
             typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
             target: `${this.parser.getPackageId()}::gateway::atomic_set_ember_share_whitelist`
@@ -1715,13 +1717,14 @@ export class TxBuilder {
      * @param options Optional tx building params
      * @returns TransactionBlock
      */
-    atomicSetStrategyNoneFromAlphalend(vaultId, lendingProtocolId, options) {
+    atomicSetStrategyNoneFromAlphalend(vaultId, lendingProtocolId, acceptResidual, options) {
         const txb = options?.txBlock || new TransactionBlock();
         txb.moveCall({
             arguments: [
                 txb.object(vaultId),
                 txb.object(this.parser.getProtocolConfig()),
                 txb.object(lendingProtocolId),
+                txb.pure.bool(acceptResidual),
                 txb.object(SUI_CLOCK_OBJECT_ID)
             ],
             typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
@@ -2383,7 +2386,11 @@ export class TxBuilder {
             arguments: [
                 txb.object(vaultId),
                 txb.object(this.parser.getProtocolConfig()),
-                txb.pure.id(sourceVaultId),
+                // `source_vault: &Vault<T, R>` — a shared-object reference, not an
+                // id. Its sibling `atomic_redeem_collected_ember_shares` takes the
+                // same vault the same way; sending a pure ID here cannot resolve to
+                // the object the Move side wants.
+                txb.object(sourceVaultId),
                 txb.object(tokenId)
             ],
             typeArguments: [

package/dist/src/sui-vaults/on-chain-calls/vault-admin.d.ts

@@ -193,10 +193,15 @@ export declare class VaultAdminCalls extends OnChainCalls {
      * @param maxCapacityPercentage The max capacity percentage
      * @param holdbackPercentage The holdback percentage
      * @param maxUtilizationPercentage The max utilization percentage
+     * @param minSwapGross Minimum gross swap size, in collateral base units. 0 means
+     *   no floor. Below it `swap_ember_shares` aborts, which is what keeps dust swaps
+     *   from walking the fee curve for free.
+     * @param maxHeldValueAbsolute Absolute ceiling on the collateral value this vault
+     *   will custody for the source. 0 means no cap — the percentage caps still apply.
      * @param options Optional tx execution params
      * @returns OnChainCallResponse
      */
-    atomicSetEmberShareWhitelist(vaultId: string, shareVaultId: string, whitelisted: boolean, feePercentage: NumStr, maxCapacityPercentage: NumStr, holdbackPercentage: NumStr, maxUtilizationPercentage: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    atomicSetEmberShareWhitelist(vaultId: string, shareVaultId: string, whitelisted: boolean, feePercentage: NumStr, maxCapacityPercentage: NumStr, holdbackPercentage: NumStr, maxUtilizationPercentage: NumStr, minSwapGross: NumStr, maxHeldValueAbsolute: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
     /**
      * Set the max utilization percentage of an ember share source vault
      * @param vaultId The id of the atomic vault
@@ -317,8 +322,11 @@ export declare class VaultAdminCalls extends OnChainCalls {
      * draining the full position collateral back into the vault balance
      * @param vaultId The id of the atomic vault
      * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
+     * @param acceptResidual Abandon a dust residual rather than aborting the exit.
+     *   Only pass true deliberately: the residual is forfeited, and the exit burns the
+     *   PositionCap that could otherwise reach it.
      * @param options Optional tx execution params
      * @returns OnChainCallResponse
      */
-    atomicSetStrategyNoneFromAlphalend(vaultId: string, lendingProtocolId: string, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    atomicSetStrategyNoneFromAlphalend(vaultId: string, lendingProtocolId: string, acceptResidual: boolean, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
 }

package/dist/src/sui-vaults/on-chain-calls/vault-admin.js

@@ -340,12 +340,17 @@ export class VaultAdminCalls extends OnChainCalls {
      * @param maxCapacityPercentage The max capacity percentage
      * @param holdbackPercentage The holdback percentage
      * @param maxUtilizationPercentage The max utilization percentage
+     * @param minSwapGross Minimum gross swap size, in collateral base units. 0 means
+     *   no floor. Below it `swap_ember_shares` aborts, which is what keeps dust swaps
+     *   from walking the fee curve for free.
+     * @param maxHeldValueAbsolute Absolute ceiling on the collateral value this vault
+     *   will custody for the source. 0 means no cap — the percentage caps still apply.
      * @param options Optional tx execution params
      * @returns OnChainCallResponse
      */
-    async atomicSetEmberShareWhitelist(vaultId, shareVaultId, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, options) {
+    async atomicSetEmberShareWhitelist(vaultId, shareVaultId, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, minSwapGross, maxHeldValueAbsolute, options) {
         const txb = options?.txBlock || new TransactionBlock();
-        this.txBuilder.atomicSetEmberShareWhitelist(vaultId, shareVaultId, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, { ...options, txBlock: txb });
+        this.txBuilder.atomicSetEmberShareWhitelist(vaultId, shareVaultId, whitelisted, feePercentage, maxCapacityPercentage, holdbackPercentage, maxUtilizationPercentage, minSwapGross, maxHeldValueAbsolute, { ...options, txBlock: txb });
         return this.execCall(txb, options);
     }
     /**
@@ -537,15 +542,15 @@ export class VaultAdminCalls extends OnChainCalls {
      * draining the full position collateral back into the vault balance
      * @param vaultId The id of the atomic vault
      * @param lendingProtocolId Object id of the AlphaLend LendingProtocol
+     * @param acceptResidual Abandon a dust residual rather than aborting the exit.
+     *   Only pass true deliberately: the residual is forfeited, and the exit burns the
+     *   PositionCap that could otherwise reach it.
      * @param options Optional tx execution params
      * @returns OnChainCallResponse
      */
-    async atomicSetStrategyNoneFromAlphalend(vaultId, lendingProtocolId, options) {
+    async atomicSetStrategyNoneFromAlphalend(vaultId, lendingProtocolId, acceptResidual, options) {
         const txb = options?.txBlock || new TransactionBlock();
-        this.txBuilder.atomicSetStrategyNoneFromAlphalend(vaultId, lendingProtocolId, {
-            ...options,
-            txBlock: txb
-        });
+        this.txBuilder.atomicSetStrategyNoneFromAlphalend(vaultId, lendingProtocolId, acceptResidual, { ...options, txBlock: txb });
         return this.execCall(txb, options);
     }
 }

package/dist/src/sui-vaults/on-chain-calls/vault.js

@@ -1,6 +1,6 @@
 import { bcs } from "@mysten/sui/bcs";
 import { BcsUpdateVaultStrategyRequest } from "../interfaces/bcs.js";
-const unwrapMoveFields = (value) => value?.fields ?? value;
+import { tableIdOf, unwrapMoveFields } from "../utils/common.js";
 export class Vault {
     /**
      * Fetches the vault rate from on-chain
@@ -65,9 +65,7 @@ export class Vault {
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const fields = unwrapMoveFields(objDetails.object?.json);
-        const accounts = unwrapMoveFields(fields?.accounts);
-        const accountTableId = unwrapMoveFields(accounts?.id);
-        const userTable = accountTableId?.id || accounts?.id;
+        const userTable = tableIdOf(fields?.accounts);
         try {
             const userData = await suiClient.core.getDynamicObjectField({
                 parentId: userTable,

package/dist/src/sui-vaults/utils/common.d.ts

@@ -1,3 +1,23 @@
 import { BaseClient as SuiClient } from "@mysten/sui/client";
 import { TransactionBlock } from "@firefly-exchange/library-sui";
 export declare const getTxBytes: (tx: TransactionBlock, client: SuiClient) => Promise<string>;
+/**
+ * Strip the JSON-RPC `{ fields: {...} }` wrapper from a Move value.
+ *
+ * gRPC returns the fields directly, JSON-RPC nests them one level down, so this
+ * makes a read work on either transport.
+ */
+export declare const unwrapMoveFields: (value: any) => any;
+/**
+ * The object id of a `Table` / `Bag` / `ObjectTable` field, whichever way the
+ * transport rendered its `UID`.
+ *
+ * The two disagree: over gRPC a UID comes back flattened to a string, so the
+ * field reads `{ id: "0x...", size: "1" }`, while JSON-RPC keeps the nesting and
+ * gives `{ id: { id: "0x..." }, size: "1" }`. Reaching straight for `.id.id`
+ * therefore yields `undefined` on gRPC — and because every caller treats a
+ * missing table id as "no such table", the read fails CLOSED: a whitelisted
+ * source vault reads as not whitelisted, a real share balance reads as zero.
+ * Silent, and wrong in the direction that looks like ordinary empty state.
+ */
+export declare const tableIdOf: (field: any) => string | undefined;

package/dist/src/sui-vaults/utils/common.js

@@ -2,3 +2,27 @@ import { toBase64 } from "@mysten/sui/utils";
 export const getTxBytes = async (tx, client) => {
     return toBase64(await tx.build({ client: client, onlyTransactionKind: false }));
 };
+/**
+ * Strip the JSON-RPC `{ fields: {...} }` wrapper from a Move value.
+ *
+ * gRPC returns the fields directly, JSON-RPC nests them one level down, so this
+ * makes a read work on either transport.
+ */
+export const unwrapMoveFields = (value) => value?.fields ?? value;
+/**
+ * The object id of a `Table` / `Bag` / `ObjectTable` field, whichever way the
+ * transport rendered its `UID`.
+ *
+ * The two disagree: over gRPC a UID comes back flattened to a string, so the
+ * field reads `{ id: "0x...", size: "1" }`, while JSON-RPC keeps the nesting and
+ * gives `{ id: { id: "0x..." }, size: "1" }`. Reaching straight for `.id.id`
+ * therefore yields `undefined` on gRPC — and because every caller treats a
+ * missing table id as "no such table", the read fails CLOSED: a whitelisted
+ * source vault reads as not whitelisted, a real share balance reads as zero.
+ * Silent, and wrong in the direction that looks like ordinary empty state.
+ */
+export const tableIdOf = (field) => {
+    const table = unwrapMoveFields(field);
+    const id = unwrapMoveFields(table?.id);
+    return (typeof id === "string" ? id : id?.id) ?? undefined;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@ember-finance/sdk",
     "description": "Ember Protocol SDK",
-    "version": "2.15.0-ccip.0",
+    "version": "2.16.0",
     "type": "module",
     "module": "./dist/index.js",
     "main": "./dist/index.js",

package/dist/src/abis/CcipRouter.json

@@ -1,58 +0,0 @@
-{
-    "abi": [
-        {
-            "type": "function",
-            "name": "getFee",
-            "stateMutability": "view",
-            "inputs": [
-                { "name": "destChainSelector", "type": "uint64" },
-                {
-                    "name": "message",
-                    "type": "tuple",
-                    "components": [
-                        { "name": "receiver", "type": "bytes" },
-                        { "name": "data", "type": "bytes" },
-                        {
-                            "name": "tokenAmounts",
-                            "type": "tuple[]",
-                            "components": [
-                                { "name": "token", "type": "address" },
-                                { "name": "amount", "type": "uint256" }
-                            ]
-                        },
-                        { "name": "feeToken", "type": "address" },
-                        { "name": "extraArgs", "type": "bytes" }
-                    ]
-                }
-            ],
-            "outputs": [{ "name": "fee", "type": "uint256" }]
-        },
-        {
-            "type": "function",
-            "name": "ccipSend",
-            "stateMutability": "payable",
-            "inputs": [
-                { "name": "destinationChainSelector", "type": "uint64" },
-                {
-                    "name": "message",
-                    "type": "tuple",
-                    "components": [
-                        { "name": "receiver", "type": "bytes" },
-                        { "name": "data", "type": "bytes" },
-                        {
-                            "name": "tokenAmounts",
-                            "type": "tuple[]",
-                            "components": [
-                                { "name": "token", "type": "address" },
-                                { "name": "amount", "type": "uint256" }
-                            ]
-                        },
-                        { "name": "feeToken", "type": "address" },
-                        { "name": "extraArgs", "type": "bytes" }
-                    ]
-                }
-            ],
-            "outputs": [{ "name": "messageId", "type": "bytes32" }]
-        }
-    ]
-}

package/dist/src/api/v2/models/bridge-transaction.d.ts

@@ -1,50 +0,0 @@
-/**
- * Ember Protocol Vaults API
- * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
- *
- * The version of the OpenAPI document: 2.0.0
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-import type { Asset } from "./asset.js";
-import type { VaultSlice } from "./vault-slice.js";
-/**
- * Vault shares moving between chains. BridgeOut burns them on the origin chain, BridgeIn mints them on the destination; the two are separate transactions on separate chains rather than one record, because each chain reports its own half. Carries no transport discriminator: a vault has exactly one bridge, so which one carried a given transfer is a property of the vault rather than of the transaction. Read it from the vault\'s own bridge config.
- * @export
- * @interface BridgeTransaction
- */
-export interface BridgeTransaction {
-    /**
-     * The timestamp of the event
-     * @type {number}
-     * @memberof BridgeTransaction
-     */
-    timestamp?: number;
-    /**
-     * The amount of shares bridged
-     * @type {string}
-     * @memberof BridgeTransaction
-     */
-    sharesAmount?: string;
-    /**
-     *
-     * @type {Asset}
-     * @memberof BridgeTransaction
-     */
-    sharesCoin?: Asset;
-    /**
-     *
-     * @type {VaultSlice}
-     * @memberof BridgeTransaction
-     */
-    vault?: VaultSlice;
-    /**
-     * The transaction hash on this chain
-     * @type {string}
-     * @memberof BridgeTransaction
-     */
-    txDigest?: string;
-}