@ember-finance/sdk 2.27.0 → 2.29.0

package/dist/src/api/v2/models/chain-vault-details.d.ts

@@ -116,6 +116,12 @@ export interface ChainVaultDetails {
      * @memberof ChainVaultDetails
      */
     status: ChainVaultDetailsStatusEnum;
+    /**
+     * Display order of this chain\'s vault among the parent\'s detailsByChain entries, ascending. Map key order is not stable, so sort by this. Ties are possible; break them by chainIdentifier.
+     * @type {number}
+     * @memberof ChainVaultDetails
+     */
+    rank: number;
     /**
      * True if this on-chain vault gates deposits through a parking lot (async deposits) — i.e. it has an active deposit parking lot. Only set for EVM vaults; always false/absent for Sui. Convenience flag equivalent to `parkingLot != null`.
      * @type {boolean}

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

@@ -1,5 +1,26 @@
 import { BaseClient as SuiClient } from "@mysten/sui/client";
 import { FeeMultiplierTier, InstantWithdrawQuote } from "../../atomic/instant-withdraw.js";
+/** A queued holdback awaiting release, in collateral base units. */
+export interface SuiHoldbackEntry {
+    receiver: string;
+    amount: bigint;
+    createdAt: bigint;
+    sequenceNumber: bigint;
+}
+/** A Suilend reward the vault's strategy position can claim. */
+export interface SuiSuilendReward {
+    /** Slot on the reserve's deposit reward manager. */
+    rewardIndex: number;
+    isDepositReward: boolean;
+    rewardCoinType: string;
+    /** Coin type of the reserve the reward accrues on: the vault's collateral. */
+    rewardSourceType: string;
+    /** Claimable now, in reward-coin base units. 0 when the vault has no sub-account. */
+    pending: bigint;
+    /** The allowlisted sub-account `pending` was priced against; claim to this one. */
+    subAccount?: string;
+    campaignEndsAtMs: bigint;
+}
 /** Strategy an atomic vault's idle collateral can be supplied to. */
 export type SuiAtomicStrategy = "none" | "suilend";
 /** An atomic vault's strategy and, for Suilend, the market it supplies to. */
@@ -56,6 +77,65 @@ export declare class SuiAtomicLiquidityReader {
     } | null>;
     /** Caller's ALV (non-transferable) share balance from the `shares` table. */
     shareOf(vaultId: string, account: string): Promise<bigint>;
+    /**
+     * Source-vault shares an atomic vault has collected from swaps and not yet redeemed.
+     * @param vaultId Object id of the atomic vault
+     * @param sourceVaultId Object id of the source vault
+     * @returns The collected share balance, in source-share base units
+     */
+    getCollectedEmberShares(vaultId: string, sourceVaultId: string): Promise<bigint>;
+    /**
+     * What redeeming a source vault's shares depends on.
+     * @param sourceVaultId Object id of the source vault
+     * @returns Its receipt coin type (`R`), minimum withdrawal shares, and whether
+     * withdrawals are paused
+     */
+    getEmberShareSource(sourceVaultId: string): Promise<{
+        receiptCoinType: string;
+        minWithdrawalShares: bigint;
+        withdrawalsPaused: boolean;
+    }>;
+    /**
+     * The holdback queue for one source share, oldest first.
+     * @param vaultId Object id of the atomic vault
+     * @param sourceVaultId Object id of the source vault
+     * @param maxEntries Read at most this many entries from the head
+     * @returns The queue length and the entries read
+     */
+    getHoldbackQueue(vaultId: string, sourceVaultId: string, maxEntries: number): Promise<{
+        length: bigint;
+        entries: SuiHoldbackEntry[];
+    }>;
+    /**
+     * Suilend rewards the vault's strategy position has accrued and not yet claimed,
+     * one entry per reward campaign the position earns from.
+     * @param vaultId Object id of the atomic vault
+     * @param packageId The protocol package currently accepted by ProtocolConfig; the
+     * claim the amount is simulated through is version-gated
+     * @param protocolConfigId Object id of the ProtocolConfig
+     * @returns Claimable rewards, with everything a claim needs. Empty when the vault
+     * is not on Suilend.
+     */
+    getSuilendRewards(vaultId: string, packageId: string, protocolConfigId: string): Promise<SuiSuilendReward[]>;
+    private simulateRewardClaim;
+    /**
+     * Coins sent to the atomic vault's address and not yet taken into it: withdrawal
+     * proceeds from source vaults (collateral) and redemptions a source returned
+     * (source shares). Each has to be claimed into the vault before it counts.
+     * @param vaultId Object id of the atomic vault
+     * @returns Non-empty coins, split into collateral and returned shares
+     */
+    getReceivedCoins(vaultId: string): Promise<{
+        collateral: {
+            objectId: string;
+            amount: bigint;
+        }[];
+        returnedShares: {
+            objectId: string;
+            coinType: string;
+            amount: bigint;
+        }[];
+    }>;
     /**
      * The strategy an atomic vault is on, and for Suilend the market it supplies to.
      * Plain object reads, no simulation.

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

@@ -3,6 +3,63 @@ import { Transaction } from "@mysten/sui/transactions";
 import { SUI_ZERO_ADDRESS } from "./protocol-config-reader.js";
 import { tableIdOf, unwrapMoveFields } from "../utils/common.js";
 import { computeSwapQuote, computePlainInstantQuote } from "../../atomic/instant-withdraw.js";
+// queue::Queue<T> and atomic_liquidity_vault::HoldbackEntry, in field order.
+const QUEUE_BCS = bcs.struct("Queue", {
+    id: bcs.Address,
+    table: bcs.struct("Table", { id: bcs.Address, size: bcs.u64() }),
+    head: bcs.u64(),
+    tail: bcs.u64()
+});
+const HOLDBACK_ENTRY_BCS = bcs.struct("HoldbackEntry", {
+    share_vault_id: bcs.Address,
+    receiver: bcs.Address,
+    amount: bcs.u64(),
+    created_at: bcs.u64(),
+    sequence_number: bcs.u128()
+});
+/** Top-level type arguments, e.g. `A, B<C, D>` -> [A, B<C, D>]. */
+const splitTypeArgs = (args) => {
+    const out = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "<")
+            depth++;
+        else if (args[i] === ">")
+            depth--;
+        else if (args[i] === "," && depth === 0) {
+            out.push(args.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    out.push(args.slice(start).trim());
+    return out;
+};
+// A missing dynamic field is a legitimate "none" here; any other failure is not.
+const dynamicFieldOrNull = async (suiClient, args) => {
+    try {
+        const res = await suiClient.core.getDynamicField(args);
+        return res.dynamicField;
+    }
+    catch (error) {
+        if (/not found/i.test(error?.message ?? ""))
+            return null;
+        throw error;
+    }
+};
+const suilendKey = (key) => ({
+    type: "vector<u8>",
+    bcs: bcs.vector(bcs.u8()).serialize(new TextEncoder().encode(key)).toBytes()
+});
+// Move renders type names without the 0x prefix inside JSON.
+const withHexPrefix = (coinType) => coinType.startsWith("0x") ? coinType : `0x${coinType}`;
+const sameCoinType = (a, b) => {
+    const norm = (t) => {
+        const [address, ...rest] = withHexPrefix(t).split("::");
+        return [`0x${address.slice(2).replace(/^0+/, "")}`, ...rest].join("::");
+    };
+    return norm(a) === norm(b);
+};
 // Indexed by the Move `strategy_kind` u8.
 const SUI_ATOMIC_STRATEGIES = ["none", "suilend"];
 /** Sui fixed-point scale (1e9) used by the Atomic Liquidity Vault Move math. */
@@ -113,6 +170,266 @@ export class SuiAtomicLiquidityReader {
             return 0n;
         return toBig(await this.readTableValue(tableId, "address", account));
     }
+    /**
+     * Source-vault shares an atomic vault has collected from swaps and not yet redeemed.
+     * @param vaultId Object id of the atomic vault
+     * @param sourceVaultId Object id of the source vault
+     * @returns The collected share balance, in source-share base units
+     */
+    async getCollectedEmberShares(vaultId, sourceVaultId) {
+        const vault = await this.suiClient.core.getObject({ objectId: vaultId });
+        // The key type lives in the package that defines the vault type.
+        const packageId = vault.object.type.split("::")[0];
+        const field = await dynamicFieldOrNull(this.suiClient, {
+            parentId: vaultId,
+            name: {
+                type: `${packageId}::atomic_liquidity_vault::CollectedEmberSharesKey`,
+                bcs: bcs.Address.serialize(sourceVaultId).toBytes()
+            }
+        });
+        return field ? BigInt(bcs.u64().parse(field.value.bcs)) : 0n;
+    }
+    /**
+     * What redeeming a source vault's shares depends on.
+     * @param sourceVaultId Object id of the source vault
+     * @returns Its receipt coin type (`R`), minimum withdrawal shares, and whether
+     * withdrawals are paused
+     */
+    async getEmberShareSource(sourceVaultId) {
+        const res = await this.suiClient.core.getObject({
+            objectId: sourceVaultId,
+            include: { json: true }
+        });
+        const fields = unwrapMoveFields(res.object?.json);
+        if (!fields)
+            throw new Error(`Source vault ${sourceVaultId} not found`);
+        const type = res.object.type;
+        const [, receiptCoinType] = splitTypeArgs(type.slice(type.indexOf("<") + 1, -1));
+        if (!receiptCoinType)
+            throw new Error(`${sourceVaultId} is not a Vault<T, R>: ${type}`);
+        // Mirrors vault::is_withdrawals_paused: the legacy global bit, or the
+        // per-operation flag kept as a dynamic field.
+        let withdrawalsPaused = !!fields.paused;
+        if (!withdrawalsPaused) {
+            const field = await dynamicFieldOrNull(this.suiClient, {
+                parentId: sourceVaultId,
+                name: {
+                    type: "vector<u8>",
+                    bcs: bcs
+                        .vector(bcs.u8())
+                        .serialize(new TextEncoder().encode("paused_withdrawals"))
+                        .toBytes()
+                }
+            });
+            withdrawalsPaused = field ? bcs.bool().parse(field.value.bcs) : false;
+        }
+        return {
+            receiptCoinType,
+            minWithdrawalShares: toBig(fields.min_withdrawal_shares),
+            withdrawalsPaused
+        };
+    }
+    /**
+     * The holdback queue for one source share, oldest first.
+     * @param vaultId Object id of the atomic vault
+     * @param sourceVaultId Object id of the source vault
+     * @param maxEntries Read at most this many entries from the head
+     * @returns The queue length and the entries read
+     */
+    async getHoldbackQueue(vaultId, sourceVaultId, maxEntries) {
+        const fields = await this.vaultFields(vaultId);
+        const tableId = tableIdOf(fields.holdback_queues);
+        if (!tableId)
+            return { length: 0n, entries: [] };
+        const queueField = await dynamicFieldOrNull(this.suiClient, {
+            parentId: tableId,
+            name: {
+                type: "0x2::object::ID",
+                bcs: bcs.Address.serialize(sourceVaultId).toBytes()
+            }
+        });
+        if (!queueField)
+            return { length: 0n, entries: [] };
+        const queue = QUEUE_BCS.parse(queueField.value.bcs);
+        const head = BigInt(queue.head);
+        const length = BigInt(queue.tail) - head;
+        const count = length < BigInt(maxEntries) ? Number(length) : maxEntries;
+        const entries = await Promise.all(Array.from({ length: count }, async (_, i) => {
+            const entry = await this.suiClient.core.getDynamicField({
+                parentId: queue.table.id,
+                name: {
+                    type: "u64",
+                    bcs: bcs
+                        .u64()
+                        .serialize(head + BigInt(i))
+                        .toBytes()
+                }
+            });
+            const e = HOLDBACK_ENTRY_BCS.parse(entry.dynamicField.value.bcs);
+            return {
+                receiver: e.receiver,
+                amount: BigInt(e.amount),
+                createdAt: BigInt(e.created_at),
+                sequenceNumber: BigInt(e.sequence_number)
+            };
+        }));
+        return { length, entries };
+    }
+    /**
+     * Suilend rewards the vault's strategy position has accrued and not yet claimed,
+     * one entry per reward campaign the position earns from.
+     * @param vaultId Object id of the atomic vault
+     * @param packageId The protocol package currently accepted by ProtocolConfig; the
+     * claim the amount is simulated through is version-gated
+     * @param protocolConfigId Object id of the ProtocolConfig
+     * @returns Claimable rewards, with everything a claim needs. Empty when the vault
+     * is not on Suilend.
+     */
+    async getSuilendRewards(vaultId, packageId, protocolConfigId) {
+        const fields = await this.vaultFields(vaultId);
+        const target = await this.getStrategyTarget(vaultId);
+        if (target.strategy !== "suilend")
+            return [];
+        const obligationField = await dynamicFieldOrNull(this.suiClient, {
+            parentId: vaultId,
+            name: suilendKey("al_strategy_suilend_obligation_id")
+        });
+        if (!obligationField)
+            return [];
+        const obligationId = bcs.Address.parse(obligationField.value.bcs);
+        const [obligation, market] = await Promise.all([
+            this.suiClient.core.getObject({
+                objectId: obligationId,
+                include: { json: true }
+            }),
+            this.suiClient.core.getObject({
+                objectId: target.suilendMarketId,
+                include: { json: true }
+            })
+        ]);
+        const obligationFields = unwrapMoveFields(obligation.object?.json) ?? {};
+        const reserves = unwrapMoveFields(market.object?.json)?.reserves ?? [];
+        const subAccount = fields.sub_accounts?.[0];
+        const rewards = [];
+        // Every deposit earns, not only the committed collateral: the permissionless
+        // claim_rewards_and_deposit can add foreign collateral to the obligation.
+        for (const deposit of obligationFields.deposits ?? []) {
+            const manager = obligationFields.user_reward_managers?.[Number(deposit.user_reward_manager_index)];
+            const userRewards = manager?.rewards ?? [];
+            const lastUpdateMs = BigInt(manager?.last_update_time_ms ?? 0);
+            const poolRewards = reserves[Number(deposit.reserve_array_index)]
+                ?.deposits_pool_reward_manager?.pool_rewards ?? [];
+            const rewardSourceType = withHexPrefix(deposit.coin_type);
+            for (let index = 0; index < poolRewards.length; index++) {
+                const pool = poolRewards[index];
+                if (!pool)
+                    continue;
+                // Suilend only materialises a user slot when the obligation is next
+                // refreshed, so a campaign that ran after the last refresh has accrued
+                // without one. Claiming refreshes first, so the simulation sees it.
+                const tracked = !!userRewards[index];
+                if (!tracked && BigInt(pool.end_time_ms) <= lastUpdateMs)
+                    continue;
+                const rewardCoinType = withHexPrefix(pool.coin_type);
+                const pending = subAccount
+                    ? await this.simulateRewardClaim({
+                        packageId,
+                        protocolConfigId,
+                        vaultId,
+                        operator: fields.operator,
+                        subAccount,
+                        target,
+                        rewardSourceType,
+                        rewardCoinType,
+                        rewardIndex: index
+                    })
+                    : 0n;
+                if (!tracked && pending === 0n)
+                    continue;
+                rewards.push({
+                    rewardIndex: index,
+                    isDepositReward: true,
+                    rewardCoinType,
+                    rewardSourceType,
+                    campaignEndsAtMs: BigInt(pool.end_time_ms),
+                    ...(subAccount ? { subAccount } : {}),
+                    pending
+                });
+            }
+        }
+        return rewards;
+    }
+    async simulateRewardClaim(args) {
+        const tx = new Transaction();
+        tx.setSender(args.operator);
+        tx.moveCall({
+            target: `${args.packageId}::gateway::atomic_claim_suilend_strategy_reward`,
+            typeArguments: [
+                args.target.collateralType,
+                args.target.suilendPoolType,
+                args.rewardSourceType,
+                args.rewardCoinType
+            ],
+            arguments: [
+                tx.object(args.vaultId),
+                tx.object(args.protocolConfigId),
+                tx.object(args.target.suilendMarketId),
+                tx.pure.address(args.subAccount),
+                tx.pure.u64(args.rewardIndex),
+                tx.pure.bool(true),
+                tx.object.clock()
+            ]
+        });
+        const sim = await this.suiClient.core.simulateTransaction({
+            transaction: tx,
+            checksEnabled: false,
+            include: { events: true }
+        });
+        if (sim.$kind !== "Transaction") {
+            throw new Error(`Simulating the Suilend reward claim for slot ${args.rewardIndex} failed: ${sim.FailedTransaction?.status?.error?.message ?? "unknown"}`);
+        }
+        const event = (sim.Transaction.events ?? []).find(e => e.eventType.includes("::events::StrategyRewardCollectedEvent"));
+        return toBig(event?.json?.amount);
+    }
+    /**
+     * Coins sent to the atomic vault's address and not yet taken into it: withdrawal
+     * proceeds from source vaults (collateral) and redemptions a source returned
+     * (source shares). Each has to be claimed into the vault before it counts.
+     * @param vaultId Object id of the atomic vault
+     * @returns Non-empty coins, split into collateral and returned shares
+     */
+    async getReceivedCoins(vaultId) {
+        const { collateralType } = await this.getStrategyTarget(vaultId);
+        const collateral = [];
+        const returnedShares = [];
+        let cursor = null;
+        do {
+            const page = await this.suiClient.core.listOwnedObjects({
+                owner: vaultId,
+                cursor,
+                include: { json: true }
+            });
+            for (const object of page.objects ?? []) {
+                const type = object.type ?? "";
+                if (!type.startsWith("0x2::coin::Coin<") &&
+                    !/^0x0*2::coin::Coin</.test(type)) {
+                    continue;
+                }
+                const amount = toBig(unwrapMoveFields(object.json)?.balance);
+                if (amount === 0n)
+                    continue;
+                const coinType = type.slice(type.indexOf("<") + 1, -1);
+                if (sameCoinType(coinType, collateralType)) {
+                    collateral.push({ objectId: object.objectId, amount });
+                }
+                else {
+                    returnedShares.push({ objectId: object.objectId, coinType, amount });
+                }
+            }
+            cursor = page.hasNextPage ? page.cursor : null;
+        } while (cursor);
+        return { collateral, returnedShares };
+    }
     /**
      * The strategy an atomic vault is on, and for Suilend the market it supplies to.
      * Plain object reads, no simulation.
@@ -147,13 +464,7 @@ export class SuiAtomicLiquidityReader {
         }
         const marketField = await this.suiClient.core.getDynamicField({
             parentId: vaultId,
-            name: {
-                type: "vector<u8>",
-                bcs: bcs
-                    .vector(bcs.u8())
-                    .serialize(new TextEncoder().encode("al_strategy_suilend_market_id"))
-                    .toBytes()
-            }
+            name: suilendKey("al_strategy_suilend_market_id")
         });
         const suilendMarketId = bcs.Address.parse(marketField.dynamicField.value.bcs);
         const market = await this.suiClient.core.getObject({ objectId: suilendMarketId });

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

@@ -255,7 +255,8 @@ export declare class OperatorCalls extends OnChainCalls {
      */
     atomicRedeemCollectedEmberShares(vaultId: string, sourceReceiptType: string, sourceVaultId: string, amount: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
     /**
-     * Release users' holdback for an ember share source vault
+     * Release users' holdback for an ember share source vault. On a strategy vault,
+     * pulls any shortfall from the strategy first, in the same transaction.
      * @param vaultId The id of the atomic vault
      * @param shareVaultId Id of the source ember share vault
      * @param unwindingPercentage The unwinding percentage

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

@@ -1,6 +1,8 @@
 import { OnChainCalls } from "./onchain-calls.js";
 import { TransactionBlock } from "@firefly-exchange/library-sui";
 import { CoinUtils } from "@firefly-exchange/library-sui";
+import { SuiAtomicLiquidityReader } from "./atomic-liquidity.js";
+import { holdbackPayout, isSuiCoinType } from "../utils/common.js";
 import { SuiProtocolConfigReader, usesCollectPlatformFeeV2 } from "./protocol-config-reader.js";
 export class OperatorCalls extends OnChainCalls {
     constructor(_network, _suiClient, _deployment, _signer, _walletAddress) {
@@ -418,7 +420,8 @@ export class OperatorCalls extends OnChainCalls {
         return this.execCall(txb, options);
     }
     /**
-     * Release users' holdback for an ember share source vault
+     * Release users' holdback for an ember share source vault. On a strategy vault,
+     * pulls any shortfall from the strategy first, in the same transaction.
      * @param vaultId The id of the atomic vault
      * @param shareVaultId Id of the source ember share vault
      * @param unwindingPercentage The unwinding percentage
@@ -428,6 +431,26 @@ export class OperatorCalls extends OnChainCalls {
      */
     async atomicReleaseUsersHoldback(vaultId, shareVaultId, unwindingPercentage, maxEntries, options) {
         const txb = options?.txBlock || new TransactionBlock();
+        // Unlike EVM's releaseUsersHoldback, the Sui release pays only from idle
+        // balance and aborts when it is short, so the strategy has to be drawn on
+        // first — sized to what the release will actually pay, since withdrawing more
+        // than the strategy holds aborts the whole transaction.
+        const pct = BigInt(unwindingPercentage);
+        if (pct > 0n) {
+            const reader = new SuiAtomicLiquidityReader(this.suiClient);
+            const target = await reader.getStrategyTarget(vaultId);
+            if (target.strategy === "suilend") {
+                const { entries } = await reader.getHoldbackQueue(vaultId, shareVaultId, Number(maxEntries));
+                const payout = entries.reduce((sum, e) => sum + holdbackPayout(e.amount, pct), 0n);
+                const shortfall = payout - target.idleCollateral;
+                if (shortfall > 0n) {
+                    const withdraw = isSuiCoinType(target.collateralType)
+                        ? this.txBuilder.atomicWithdrawFromSuilendStrategySui.bind(this.txBuilder)
+                        : this.txBuilder.atomicWithdrawFromSuilendStrategy.bind(this.txBuilder);
+                    withdraw(vaultId, target.suilendPoolType, target.suilendMarketId, shortfall.toString(), { ...options, txBlock: txb });
+                }
+            }
+        }
         this.txBuilder.atomicReleaseUsersHoldback(vaultId, shareVaultId, unwindingPercentage, maxEntries, { ...options, txBlock: txb });
         return this.execCall(txb, options);
     }

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

@@ -2,10 +2,7 @@ import { OnChainCalls } from "./onchain-calls.js";
 import { TransactionBlock, bigNumber, CoinUtils, SUI_NATIVE_BASE } from "@firefly-exchange/library-sui";
 import { Vault } from "./vault.js";
 import { SuiAtomicLiquidityReader } from "./atomic-liquidity.js";
-const isSuiCoinType = (coinType) => {
-    const [address, module, name] = coinType.split("::");
-    return module === "sui" && name === "SUI" && /^0x0*2$/.test(address);
-};
+import { isSuiCoinType } from "../utils/common.js";
 export class UserCalls extends OnChainCalls {
     constructor(_network, _suiClient, _deployment, _signer, _walletAddress, _isUIWallet) {
         super(_network, _suiClient, _deployment, _signer, _walletAddress, _isUIWallet);

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

@@ -21,3 +21,11 @@ export declare const unwrapMoveFields: (value: any) => any;
  * Silent, and wrong in the direction that looks like ordinary empty state.
  */
 export declare const tableIdOf: (field: any) => string | undefined;
+/** True for the SUI coin type, in its short (`0x2`) or padded form. */
+export declare const isSuiCoinType: (coinType: string) => boolean;
+/**
+ * What `release_users_holdback` pays one holdback entry at `unwindingPercentage`
+ * (1e9 = 100%): floor(amount * pct / 1e9), except that an entry of at most 100 base
+ * units that rounds to zero is paid in full. Zero unwinding pays nothing.
+ */
+export declare const holdbackPayout: (amount: bigint, unwindingPercentage: bigint) => bigint;

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

@@ -26,3 +26,19 @@ export const tableIdOf = (field) => {
     const id = unwrapMoveFields(table?.id);
     return (typeof id === "string" ? id : id?.id) ?? undefined;
 };
+/** True for the SUI coin type, in its short (`0x2`) or padded form. */
+export const isSuiCoinType = (coinType) => {
+    const [address, module, name] = coinType.split("::");
+    return module === "sui" && name === "SUI" && /^0x0*2$/.test(address);
+};
+/**
+ * What `release_users_holdback` pays one holdback entry at `unwindingPercentage`
+ * (1e9 = 100%): floor(amount * pct / 1e9), except that an entry of at most 100 base
+ * units that rounds to zero is paid in full. Zero unwinding pays nothing.
+ */
+export const holdbackPayout = (amount, unwindingPercentage) => {
+    if (unwindingPercentage === 0n)
+        return 0n;
+    const payout = (amount * unwindingPercentage) / 1000000000n;
+    return payout === 0n && amount > 0n && amount <= 100n ? amount : payout;
+};

package/package.json

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