@ember-finance/sdk 2.18.0 → 2.20.0

package/dist/src/placements/api.d.ts

@@ -0,0 +1,13 @@
+import { VaultsApi } from "../api/v2/index.js";
+/**
+ * The generated vaults client, on the fetch adapter so this module keeps one
+ * transport in the browser and in Node.
+ */
+export declare function vaultsApi(baseUrl: string): VaultsApi;
+/** Status and Retry-After of a failed call, or undefined when no response came back. */
+export declare function httpFailure(error: unknown): {
+    status: number;
+    retryAfter?: string;
+} | undefined;
+/** True for a transport failure (no response), which is worth retrying. */
+export declare function isNetworkError(error: unknown): boolean;

package/dist/src/placements/api.js

@@ -0,0 +1,26 @@
+import axios from "axios";
+import { Configuration, VaultsApi } from "../api/v2/index.js";
+/**
+ * The generated vaults client, on the fetch adapter so this module keeps one
+ * transport in the browser and in Node.
+ */
+export function vaultsApi(baseUrl) {
+    return new VaultsApi(new Configuration({
+        basePath: baseUrl.replace(/\/$/, ""),
+        baseOptions: { adapter: "fetch" }
+    }));
+}
+/** Status and Retry-After of a failed call, or undefined when no response came back. */
+export function httpFailure(error) {
+    if (!axios.isAxiosError(error) || !error.response)
+        return undefined;
+    const retryAfter = error.response.headers?.["retry-after"];
+    return {
+        status: error.response.status,
+        retryAfter: typeof retryAfter === "string" ? retryAfter : undefined
+    };
+}
+/** True for a transport failure (no response), which is worth retrying. */
+export function isNetworkError(error) {
+    return axios.isAxiosError(error) && !error.response && !axios.isCancel(error);
+}

package/dist/src/placements/pointers.d.ts

@@ -10,7 +10,6 @@ export interface HttpPointerSourceOptions {
     env?: PlatformEnv;
     /** Overrides `env` entirely. For a local deployment, or a proxy. */
     baseUrl?: string;
-    path?: string;
     /** How long a coin's rows may be reused, in milliseconds. Default 30s. */
     cacheMs?: number;
 }

package/dist/src/placements/pointers.js

@@ -1,5 +1,6 @@
 import { environmentConfig } from "../common/constants.js";
-import { isAbortError, isTransientStatus, retryAfterMs } from "./batch.js";
+import { httpFailure, isNetworkError, vaultsApi } from "./api.js";
+import { 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
@@ -33,7 +34,7 @@ export function httpPointerSource(options = {}) {
     // makes, not to cache across a session: pointers change when a venue is
     // added, and a long window would keep a new one invisible.
     const baseUrl = options.baseUrl ?? environmentConfig[options.env ?? "prod"].apiHost;
-    const path = options.path ?? "/api/v2/vaults/placements";
+    const api = vaultsApi(baseUrl);
     const cacheMs = options.cacheMs ?? 30000;
     /**
      * One request for every coin. The endpoint answers with the whole registry
@@ -59,12 +60,7 @@ export function httpPointerSource(options = {}) {
         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 request = (coin) => fetchPlacements(api, coin);
     const rowsFor = async (coin) => {
         if (Date.now() >= perCoinUntil) {
             try {
@@ -139,34 +135,31 @@ 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) {
+async function fetchPlacements(api, coin) {
     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);
-            }
+            const { data } = await api.getCoinPlacements(coin);
+            return data.placements ?? [];
         }
         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 failure = httpFailure(error);
+            if (!failure) {
+                // Only a transport failure is worth retrying, not an abort or a
+                // bug of our own.
+                if (!isNetworkError(error) || attempt >= FETCH_ATTEMPTS)
+                    throw error;
+            }
+            else {
+                if (!isTransientStatus(failure.status) || attempt >= FETCH_ATTEMPTS) {
+                    throw new PointerSourceError(failure.status);
+                }
+                waitMs = retryAfterMs(failure.retryAfter);
+                // 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(failure.status);
+                }
             }
         }
         const backoff = Math.min(RETRY_BASE_MS * 2 ** (attempt - 1), RETRY_MAX_MS);

package/dist/src/placements/vaults.js

@@ -1,4 +1,5 @@
 import { environmentConfig } from "../common/constants.js";
+import { httpFailure, vaultsApi } from "./api.js";
 /**
  * Resolves a vault to the receipt coins it issues, from the vaults API.
  *
@@ -6,14 +7,17 @@ import { environmentConfig } from "../common/constants.js";
  * each, so this returns one entry per chain rather than assuming a single coin.
  */
 export function httpVaultCoinsResolver(options = {}) {
-    const baseUrl = (options.baseUrl ?? environmentConfig[options.env ?? "prod"].apiHost).replace(/\/$/, "");
-    const get = async (path) => {
-        const response = await fetch(`${baseUrl}${path}`, {
-            headers: { Accept: "application/json" }
-        });
-        if (!response.ok)
-            throw new Error(`vaults api ${response.status} for ${path}`);
-        return (await response.json());
+    const api = vaultsApi(options.baseUrl ?? environmentConfig[options.env ?? "prod"].apiHost);
+    const get = async (path, call) => {
+        try {
+            return (await call()).data;
+        }
+        catch (error) {
+            const failure = httpFailure(error);
+            if (failure)
+                throw new Error(`vaults api ${failure.status} for ${path}`);
+            throw error;
+        }
     };
     // The chain catalogue is what carries the EVM network id. Without it an EVM
     // coin has no chainId, and every read for it fails rather than returning a
@@ -22,7 +26,7 @@ export function httpVaultCoinsResolver(options = {}) {
     const chainRefs = () => {
         if (chains)
             return chains;
-        chains = get("/api/v2/vaults/supported-chains").then(supported => {
+        chains = get("/api/v2/vaults/supported-chains", () => api.getSupportedChains()).then(supported => {
             const byIdentifier = new Map();
             for (const chain of supported) {
                 if (!chain.identifier)
@@ -51,10 +55,10 @@ export function httpVaultCoinsResolver(options = {}) {
     return {
         async coinsForVault(vaultId) {
             const [vaults, catalogue] = await Promise.all([
-                get(`/api/v2/vaults?vaultId=${encodeURIComponent(vaultId)}`),
+                get(`/api/v2/vaults?vaultId=${vaultId}`, () => api.getVaults(vaultId)),
                 chainRefs()
             ]);
-            const list = Array.isArray(vaults) ? vaults : [vaults];
+            const list = vaults;
             const vault = list.find(v => v.id === vaultId) ?? list[0];
             if (!vault)
                 throw new Error(`vault ${vaultId} not found`);

package/dist/src/sui-vaults/interfaces/index.d.ts

@@ -70,6 +70,20 @@ export interface IVaultOptionalParams extends ITxBuilderOptionalParams {
     dryRun?: boolean;
     returnTxb?: boolean;
 }
+/**
+ * Operations that can be paused individually on a vault.
+ *
+ * The values are the exact `vector<u8>` the Move entry points compare against
+ * (`OP_DEPOSITS` and friends in `vault.move`), shared by the regular and atomic
+ * vault flavours. Note `privileged_operations` is snake_case here and
+ * `privilegedOperations` in EVM's `VaultPauseOperation` — consumers serving both
+ * chains have to map, which is why this enum exists rather than a bare string.
+ */
+export declare enum SuiVaultPauseOperation {
+    Deposits = "deposits",
+    Withdrawals = "withdrawals",
+    PrivilegedOperations = "privileged_operations"
+}
 /** `version` and the protocol-wide pause flag from the shared ProtocolConfig. */
 export interface IProtocolConfigState {
     /** The package VERSION the protocol currently accepts, as a decimal string. */

package/dist/src/sui-vaults/interfaces/index.js

@@ -1 +1,15 @@
-export {};
+/**
+ * Operations that can be paused individually on a vault.
+ *
+ * The values are the exact `vector<u8>` the Move entry points compare against
+ * (`OP_DEPOSITS` and friends in `vault.move`), shared by the regular and atomic
+ * vault flavours. Note `privileged_operations` is snake_case here and
+ * `privilegedOperations` in EVM's `VaultPauseOperation` — consumers serving both
+ * chains have to map, which is why this enum exists rather than a bare string.
+ */
+export var SuiVaultPauseOperation;
+(function (SuiVaultPauseOperation) {
+    SuiVaultPauseOperation["Deposits"] = "deposits";
+    SuiVaultPauseOperation["Withdrawals"] = "withdrawals";
+    SuiVaultPauseOperation["PrivilegedOperations"] = "privileged_operations";
+})(SuiVaultPauseOperation || (SuiVaultPauseOperation = {}));

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

@@ -1,5 +1,5 @@
 import { SuiDeploymentParser } from "../utils/index.js";
-import { ISuiDeployment, ITxBuilderOptionalParams } from "../interfaces/index.js";
+import { ISuiDeployment, ITxBuilderOptionalParams, SuiVaultPauseOperation } from "../interfaces/index.js";
 import { Address, NumStr, TransactionBlock } from "@firefly-exchange/library-sui";
 export declare class TxBuilder {
     parser: SuiDeploymentParser;
@@ -45,6 +45,32 @@ export declare class TxBuilder {
      * @returns TransactionBlock
      */
     setGuardian(newGuardian: Address, options?: ITxBuilderOptionalParams): TransactionBlock;
+    /**
+     * Guardian fast-path to pause / unpause one operation on a regular vault.
+     * Callable directly by the guardian address — no AdminCap.
+     *
+     * Per-operation, unlike the AdminCap-gated {@link updateVaultPausedStatus},
+     * which flips the vault's single legacy `paused` flag. On chain the effective
+     * answer is `vault.paused || <this operation's flag>`, so clearing an
+     * operation here does not un-pause a vault the admin stopped wholesale.
+     * @param vaultId Id of the vault
+     * @param operation Operation to pause or resume
+     * @param paused True to pause, false to resume
+     * @param options Optional tx building params; `packageId` routes through a retired package
+     * @returns TransactionBlock
+     */
+    guardianSetVaultPausedStatus(vaultId: string, operation: SuiVaultPauseOperation, paused: boolean, options?: ITxBuilderOptionalParams): TransactionBlock;
+    /**
+     * Guardian fast-path to pause / unpause one operation on an atomic liquidity
+     * vault. Same vocabulary as the regular-vault variant; separate entry point
+     * because the vault type differs and takes only the collateral type.
+     * @param vaultId Id of the atomic vault
+     * @param operation Operation to pause or resume
+     * @param paused True to pause, false to resume
+     * @param options Optional tx building params; `packageId` routes through a retired package
+     * @returns TransactionBlock
+     */
+    atomicGuardianSetPauseStatus(vaultId: string, operation: SuiVaultPauseOperation, paused: boolean, options?: ITxBuilderOptionalParams): TransactionBlock;
     /**
      * Asserts `ProtocolConfig.version` equals the VERSION compiled into the target
      * package, aborting EUnsupportedPackage (1000) otherwise.

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

@@ -94,6 +94,69 @@ export class TxBuilder {
             txb.setSenderIfNotSet(options.sender);
         return txb;
     }
+    /**
+     * Guardian fast-path to pause / unpause one operation on a regular vault.
+     * Callable directly by the guardian address — no AdminCap.
+     *
+     * Per-operation, unlike the AdminCap-gated {@link updateVaultPausedStatus},
+     * which flips the vault's single legacy `paused` flag. On chain the effective
+     * answer is `vault.paused || <this operation's flag>`, so clearing an
+     * operation here does not un-pause a vault the admin stopped wholesale.
+     * @param vaultId Id of the vault
+     * @param operation Operation to pause or resume
+     * @param paused True to pause, false to resume
+     * @param options Optional tx building params; `packageId` routes through a retired package
+     * @returns TransactionBlock
+     */
+    guardianSetVaultPausedStatus(vaultId, operation, paused, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.vector("u8", Array.from(Buffer.from(operation, "utf8"))),
+                txb.pure.bool(paused)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.targetPackageId(options)}::gateway::guardian_set_vault_paused_status`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Guardian fast-path to pause / unpause one operation on an atomic liquidity
+     * vault. Same vocabulary as the regular-vault variant; separate entry point
+     * because the vault type differs and takes only the collateral type.
+     * @param vaultId Id of the atomic vault
+     * @param operation Operation to pause or resume
+     * @param paused True to pause, false to resume
+     * @param options Optional tx building params; `packageId` routes through a retired package
+     * @returns TransactionBlock
+     */
+    atomicGuardianSetPauseStatus(vaultId, operation, paused, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.vector("u8", Array.from(Buffer.from(operation, "utf8"))),
+                txb.pure.bool(paused)
+            ],
+            typeArguments: [this.parser.getAtomicCollateralType(vaultId)],
+            target: `${this.targetPackageId(options)}::gateway::atomic_guardian_set_pause_status`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
     /**
      * Asserts `ProtocolConfig.version` equals the VERSION compiled into the target
      * package, aborting EUnsupportedPackage (1000) otherwise.

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

@@ -1,6 +1,6 @@
 import { BaseClient as SuiClient } from "@mysten/sui/client";
 import { OnChainCalls } from "./onchain-calls.js";
-import { ISuiDeployment, IVaultOptionalParams } from "../interfaces/index.js";
+import { ISuiDeployment, IVaultOptionalParams, SuiVaultPauseOperation } from "../interfaces/index.js";
 import { NumStr } from "@firefly-exchange/library-sui";
 import { OnChainCallResponse, Signer, SuiAddress, SuiTransactionBlockResponseOptions } from "@firefly-exchange/library-sui";
 export declare class VaultAdminCalls extends OnChainCalls {
@@ -46,6 +46,34 @@ export declare class VaultAdminCalls extends OnChainCalls {
      * @returns OnChainCallResponse
      */
     updateVaultPausedStatus(vaultId: string, paused: boolean, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Guardian fast-path to pause / unpause one operation on a regular vault.
+     * Needs no AdminCap — the signer must be the address `set_guardian` recorded.
+     *
+     * Per-operation, unlike {@link updateVaultPausedStatus}, which flips the
+     * vault's single legacy `paused` flag. The chain reads
+     * `vault.paused || <operation flag>`, so resuming an operation here does not
+     * revive a vault the admin paused wholesale.
+     *
+     * Version-gated like every guarded call: pass `options.packageId` to route
+     * through a retired package while an upgrade is half-applied.
+     * @param vaultId The id of the vault
+     * @param operation The operation to pause or resume
+     * @param paused True to pause, false to resume
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    guardianSetVaultPausedStatus(vaultId: string, operation: SuiVaultPauseOperation, paused: boolean, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Guardian fast-path to pause / unpause one operation on an atomic liquidity
+     * vault. Same vocabulary as the regular-vault variant.
+     * @param vaultId The id of the atomic vault
+     * @param operation The operation to pause or resume
+     * @param paused True to pause, false to resume
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    atomicGuardianSetPauseStatus(vaultId: string, operation: SuiVaultPauseOperation, paused: boolean, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
     /**
      * Update vault rate update interval
      * @param vaultId The id of the vault to update the rate update interval for

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

@@ -80,6 +80,48 @@ export class VaultAdminCalls extends OnChainCalls {
         });
         return this.execCall(txb, options);
     }
+    /**
+     * Guardian fast-path to pause / unpause one operation on a regular vault.
+     * Needs no AdminCap — the signer must be the address `set_guardian` recorded.
+     *
+     * Per-operation, unlike {@link updateVaultPausedStatus}, which flips the
+     * vault's single legacy `paused` flag. The chain reads
+     * `vault.paused || <operation flag>`, so resuming an operation here does not
+     * revive a vault the admin paused wholesale.
+     *
+     * Version-gated like every guarded call: pass `options.packageId` to route
+     * through a retired package while an upgrade is half-applied.
+     * @param vaultId The id of the vault
+     * @param operation The operation to pause or resume
+     * @param paused True to pause, false to resume
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async guardianSetVaultPausedStatus(vaultId, operation, paused, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        this.txBuilder.guardianSetVaultPausedStatus(vaultId, operation, paused, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Guardian fast-path to pause / unpause one operation on an atomic liquidity
+     * vault. Same vocabulary as the regular-vault variant.
+     * @param vaultId The id of the atomic vault
+     * @param operation The operation to pause or resume
+     * @param paused True to pause, false to resume
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async atomicGuardianSetPauseStatus(vaultId, operation, paused, options) {
+        const txb = options?.txBlock || new TransactionBlock();
+        this.txBuilder.atomicGuardianSetPauseStatus(vaultId, operation, paused, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
     /**
      * Update vault rate update interval
      * @param vaultId The id of the vault to update the rate update interval for

package/package.json

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