upshift-config 0.5.14

package/lib/adapters/stellar/submit.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Stellar Transaction Submission
+ *
+ * Submits signed Soroban transactions and polls for confirmation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitStellarTransaction = submitStellarTransaction;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const core_1 = require("../../core");
+const soroban_1 = require("./soroban");
+const constants_1 = require("./constants");
+/**
+ * Best-effort decode of the transaction-level result code (the XDR union
+ * discriminant, e.g. `"txBadSeq"`, `"txTooLate"`) from a Soroban
+ * `TransactionResult`. Typed `unknown` and probed structurally so it stays
+ * robust to RPC/SDK shape drift; returns `undefined` for anything that isn't a
+ * decoded union, so callers fall back to the stringified XDR in the message.
+ */
+function extractTxResultCode(result) {
+    try {
+        const decoded = result;
+        if (typeof decoded?.result !== 'function')
+            return undefined;
+        // `|| undefined`: an empty discriminant shares the clean "no code" path.
+        return decoded.result().switch().name || undefined;
+    }
+    catch (e) {
+        // Only reached on a malformed / shape-drifted union (the non-union case
+        // already returned above). Breadcrumb it so decoder rot stays detectable;
+        // the caller still throws with the stringified XDR in the message.
+        core_1.Logger.log.warn('extractTxResultCode', { decodeError: String(e) });
+        return undefined;
+    }
+}
+/**
+ * `JSON.stringify` that never throws. A real `xdr.TransactionResult` can hold
+ * `bigint` fields (e.g. `feeCharged`), which make `JSON.stringify` throw a
+ * `TypeError` — that would escape and replace the `AugustSDKError` this detail
+ * is only meant to enrich. Returns `''` on failure so the caller falls back to
+ * the status; the decoded `resultCode` still carries the precise reason.
+ */
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value) ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Submit a signed Soroban transaction and poll until confirmed.
+ *
+ * @param signedXdr - Base64-encoded XDR of the signed transaction
+ * @param network - Stellar network name
+ * @param sorobanRpcUrl - Optional override Soroban RPC endpoint (e.g. a keyed
+ *   Alchemy URL); becomes the primary with the SDK's public endpoints kept as
+ *   failover. Omit to use the public endpoints.
+ * @returns The transaction hash once the network confirms it as successful
+ * @throws {@link AugustTimeoutError} when the transaction is not confirmed
+ *   within the poll budget (`MAX_POLL_ATTEMPTS`).
+ * @throws {@link AugustSDKError} when the RPC rejects the submission or the
+ *   transaction confirms as failed. Its `context` carries `{ network, status }`
+ *   plus, when the result XDR decodes, a `resultCode` string holding the
+ *   transaction-level reason (e.g. `"txBadSeq"`, `"txTooLate"`); `resultCode`
+ *   is `undefined` when the code cannot be decoded.
+ * @example
+ * ```ts
+ * try {
+ *   const hash = await submitStellarTransaction(signedXdr, 'mainnet');
+ * } catch (err) {
+ *   if (err instanceof AugustSDKError && err.context?.resultCode === 'txBadSeq') {
+ *     // stale sequence number — rebuild the transaction and resubmit
+ *   }
+ * }
+ * ```
+ */
+async function submitStellarTransaction(signedXdr, network, sorobanRpcUrl) {
+    const config = (0, soroban_1.resolveNetworkConfig)(network, sorobanRpcUrl);
+    const { passphrase } = config;
+    const server = await (0, soroban_1.getHealthyServer)(config);
+    const tx = stellar_sdk_1.TransactionBuilder.fromXDR(signedXdr, passphrase);
+    const sendResult = await server.sendTransaction(tx);
+    if (sendResult.status === 'ERROR') {
+        const errorResult = 'errorResult' in sendResult ? sendResult.errorResult : undefined;
+        const resultCode = extractTxResultCode(errorResult);
+        const detail = errorResult ? safeStringify(errorResult) : '';
+        const msg = `Transaction submission failed: ${detail || sendResult.status}`;
+        core_1.Logger.log.error('submitStellarTransaction', msg, { network, resultCode });
+        throw new core_1.AugustSDKError('UNKNOWN', msg, {
+            context: { network, status: sendResult.status, resultCode },
+        });
+    }
+    // Only PENDING (and DUPLICATE) mean the tx was accepted by the RPC.
+    // DUPLICATE means this exact transaction was already submitted — it may
+    // already be confirmed or still pending from a prior submission.
+    // TRY_AGAIN_LATER and any other status should be surfaced immediately
+    // so callers can retry submission instead of waiting for a poll timeout.
+    if (sendResult.status !== 'PENDING' && sendResult.status !== 'DUPLICATE') {
+        const msg = `Transaction not accepted by RPC (status: ${sendResult.status}). ` +
+            'This may be retryable — the RPC node could be overloaded.';
+        core_1.Logger.log.error('submitStellarTransaction', msg, { network });
+        throw new core_1.AugustSDKError('UNKNOWN', msg, {
+            context: { network, status: sendResult.status },
+        });
+    }
+    // Geometric backoff (start POLL_INTERVAL_MS, ×POLL_INTERVAL_BACKOFF up to
+    // POLL_INTERVAL_MAX_MS) — fast on the happy path, gentler on slow ledgers.
+    let getResult = await server.getTransaction(sendResult.hash);
+    let polls = 0;
+    let nextDelay = constants_1.POLL_INTERVAL_MS;
+    while (getResult.status === 'NOT_FOUND') {
+        if (++polls >= constants_1.MAX_POLL_ATTEMPTS) {
+            const msg = `Transaction ${sendResult.hash} not confirmed after ${constants_1.MAX_POLL_ATTEMPTS} poll attempts`;
+            core_1.Logger.log.error('submitStellarTransaction', msg, {
+                hash: sendResult.hash,
+                network,
+            });
+            throw new core_1.AugustTimeoutError(msg, constants_1.POLL_INTERVAL_MAX_MS * polls, {
+                context: { hash: sendResult.hash, network },
+            });
+        }
+        await new Promise((r) => setTimeout(r, nextDelay));
+        nextDelay = Math.min(Math.round(nextDelay * constants_1.POLL_INTERVAL_BACKOFF), constants_1.POLL_INTERVAL_MAX_MS);
+        getResult = await server.getTransaction(sendResult.hash);
+    }
+    if (getResult.status === 'SUCCESS') {
+        return sendResult.hash;
+    }
+    const resultXdr = 'resultXdr' in getResult ? getResult.resultXdr : undefined;
+    const resultCode = extractTxResultCode(resultXdr);
+    const detail = resultXdr ? safeStringify(resultXdr) : '';
+    const failDetail = detail ? ` (${detail})` : '';
+    const msg = `Transaction failed: ${getResult.status}${failDetail}`;
+    core_1.Logger.log.error('submitStellarTransaction', msg, {
+        hash: sendResult.hash,
+        network,
+        resultCode,
+    });
+    throw new core_1.AugustSDKError('UNKNOWN', msg, {
+        context: {
+            hash: sendResult.hash,
+            network,
+            status: getResult.status,
+            resultCode,
+        },
+    });
+}
+//# sourceMappingURL=submit.js.map

package/lib/adapters/stellar/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Stellar Vault Types
+ */
+import type { IStellarNetwork } from '../../types/web3';
+export type { IStellarNetwork };
+/** Parameters for building an unsigned Stellar vault deposit transaction. */
+export interface IStellarDepositParams {
+    contractId: string;
+    amount: string;
+    senderAddress: string;
+    network: IStellarNetwork;
+    /**
+     * Optional override Soroban RPC endpoint (e.g. a keyed Alchemy URL). When set
+     * it is the primary, with the SDK's public endpoints kept behind it as
+     * failover.
+     */
+    sorobanRpcUrl?: string;
+}
+/** Parameters for building an unsigned Stellar vault redeem transaction. */
+export interface IStellarRedeemParams {
+    contractId: string;
+    shares: string;
+    receiverAddress: string;
+    network: IStellarNetwork;
+    /**
+     * Optional override Soroban RPC endpoint (e.g. a keyed Alchemy URL). When set
+     * it is the primary, with the SDK's public endpoints kept behind it as
+     * failover.
+     */
+    sorobanRpcUrl?: string;
+}
+/**
+ * User vault position returned by on-chain balance queries.
+ *
+ * `decimals` carries the share-token scale used to interpret `shares`. When the
+ * on-chain `decimals()` read fails, it falls back to STELLAR_FALLBACK_DECIMALS
+ * (7) and `decimalsFromFallback` is set to `true`. Callers that size a redeem
+ * from this position MUST check `decimalsFromFallback` and refuse to settle
+ * when it is `true` — trusting a fabricated 7 against an ERC4626 offset vault
+ * (share decimals = asset + offset) under-redeems by `10^offset`. See
+ * AUGUST-6381.
+ */
+export interface IStellarUserPosition {
+    /** Raw share balance in smallest unit, as a non-negative integer string */
+    shares: string;
+    /** Share-token decimals; may be the fallback — see `decimalsFromFallback`. */
+    decimals: number;
+    /**
+     * `true` when `decimals` is the fallback (the on-chain `decimals()` read
+     * failed), `false` when it is the authoritative on-chain value. Treat `true`
+     * as a decimals read failure: do not trust `decimals` to scale or redeem.
+     *
+     * Optional for source back-compat (a consumer's existing object literal still
+     * compiles), but `getStellarUserPosition` always populates it — so a position
+     * obtained from the SDK never omits it.
+     */
+    decimalsFromFallback?: boolean;
+}

package/lib/adapters/stellar/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Stellar Vault Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/adapters/stellar/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Stellar Utilities
+ */
+import type { IStellarNetwork } from './types';
+import { isStellarAddress } from '../../core/helpers/chain-address';
+export { isStellarAddress };
+/**
+ * Get the Stellar explorer URL for a given address or transaction.
+ */
+export declare function getExplorerLink({ id, type, network, }: {
+    id: string;
+    type?: 'contract' | 'account' | 'tx';
+    network?: IStellarNetwork;
+}): string;
+/**
+ * Throw if the given address is a Stellar address.
+ * Used as a guard in vault operations that don't yet support Stellar.
+ */
+export declare function assertNotStellar(address: string, operation: string): void;
+export declare const StellarUtils: {
+    isStellarAddress: typeof isStellarAddress;
+    getExplorerLink: typeof getExplorerLink;
+    assertNotStellar: typeof assertNotStellar;
+};

package/lib/adapters/stellar/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Stellar Utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarUtils = exports.isStellarAddress = void 0;
+exports.getExplorerLink = getExplorerLink;
+exports.assertNotStellar = assertNotStellar;
+const core_1 = require("../../core");
+const chain_address_1 = require("../../core/helpers/chain-address");
+Object.defineProperty(exports, "isStellarAddress", { enumerable: true, get: function () { return chain_address_1.isStellarAddress; } });
+/**
+ * Get the Stellar explorer URL for a given address or transaction.
+ */
+function getExplorerLink({ id, type = 'contract', network = 'mainnet', }) {
+    const baseUrl = 'https://stellar.expert/explorer';
+    const net = network === 'mainnet' ? 'public' : 'testnet';
+    return `${baseUrl}/${net}/${type}/${id}`;
+}
+/**
+ * Throw if the given address is a Stellar address.
+ * Used as a guard in vault operations that don't yet support Stellar.
+ */
+function assertNotStellar(address, operation) {
+    if ((0, chain_address_1.isStellarAddress)(address)) {
+        throw new core_1.AugustValidationError('INVALID_CHAIN', `${operation} is not yet supported for Stellar vaults: ${address}`);
+    }
+}
+exports.StellarUtils = {
+    isStellarAddress: chain_address_1.isStellarAddress,
+    getExplorerLink,
+    assertNotStellar,
+};
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,14 @@
+export { SUI_CHAIN_ID } from '../../core/constants/web3';
+export declare const EMBER_API_BASE_URL = "https://vaults.api.sui-prod.bluefin.io/api/v1/vaults";
+export declare const EMBER_ENDPOINTS: {
+    readonly VAULTS: "/";
+    readonly TVL: "/tvl-history";
+};
+export declare const EMBER_DEFAULTS: {
+    readonly DECIMALS: 18;
+    readonly USD_DECIMALS: 6;
+    readonly E9_DIVISOR: 1000000000;
+    readonly BPS_TO_PERCENT: 100;
+    readonly VERSION: "sui-0";
+};
+export declare const ALLOWED_SUI_VAULT_ADDRESSES: string[];

package/lib/adapters/sui/constants.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_SUI_VAULT_ADDRESSES = exports.EMBER_DEFAULTS = exports.EMBER_ENDPOINTS = exports.EMBER_API_BASE_URL = exports.SUI_CHAIN_ID = void 0;
+// Canonical definition lives in `core/constants/web3.ts` so `core/` can
+// recognise the Sui chain ID without importing the adapter layer. Re-exported
+// here to keep `adapters/sui/constants` import sites (and the published API)
+// unchanged.
+var web3_1 = require("../../core/constants/web3");
+Object.defineProperty(exports, "SUI_CHAIN_ID", { enumerable: true, get: function () { return web3_1.SUI_CHAIN_ID; } });
+exports.EMBER_API_BASE_URL = 'https://vaults.api.sui-prod.bluefin.io/api/v1/vaults';
+exports.EMBER_ENDPOINTS = {
+    VAULTS: '/',
+    TVL: '/tvl-history',
+};
+exports.EMBER_DEFAULTS = {
+    DECIMALS: 18,
+    USD_DECIMALS: 6,
+    E9_DIVISOR: 1e9,
+    BPS_TO_PERCENT: 100,
+    VERSION: 'sui-0',
+};
+exports.ALLOWED_SUI_VAULT_ADDRESSES = [
+    '0x94c2826b24e44f710c5f80e3ed7ce898258d7008e3a643c894d90d276924d4b9',
+    '0xfaf4d0ec9b76147c926c0c8b2aba39ea21ec991500c1e3e53b60d447b0e5f655',
+    '0x323578c2b24683ca845c68c1e2097697d65e235826a9dc931abce3b4b1e43642',
+    '0x1fdbd27ba90a7a5385185e3e0b76477202f2cadb0e4343163288c5625e7c5505',
+    '0x30844745c8197fdaf9fe06c4ffeb73fe05c092ce0040674a3758dbfcb032a1f4',
+].map((addr) => addr.toLowerCase());
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,9 @@
+import type { IEmberVault, IFetchEmberVaultsOptions } from './types';
+/**
+ * Fetch Ember vaults from API
+ */
+export declare function getEmberVaults(options?: IFetchEmberVaultsOptions): Promise<IEmberVault[]>;
+/**
+ * Fetch Ember TVL data
+ */
+export declare function getEmberTVL(limit?: number): Promise<number>;

package/lib/adapters/sui/getters.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmberVaults = getEmberVaults;
+exports.getEmberTVL = getEmberTVL;
+const constants_1 = require("./constants");
+const core_1 = require("../../core");
+const logger_1 = require("../../core/logger");
+/**
+ * Fetch Ember vaults from API
+ */
+async function getEmberVaults(options) {
+    try {
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.append('limit', options.limit.toString());
+        if (options?.offset)
+            params.append('offset', options.offset.toString());
+        if (options?.status)
+            params.append('status', options.status);
+        const queryString = params.toString();
+        const url = `${constants_1.EMBER_API_BASE_URL}${queryString ? `?${queryString}` : ''}`;
+        const response = await fetch(url, core_1.DEFAULT_FETCH_OPTIONS);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        return Array.isArray(data) ? data : [];
+    }
+    catch (error) {
+        logger_1.Logger.log.error('getEmberVaults', error);
+        return [];
+    }
+}
+/**
+ * Fetch Ember TVL data
+ */
+async function getEmberTVL(limit = 1) {
+    try {
+        const params = new URLSearchParams();
+        if (limit)
+            params.append('limit', limit.toString());
+        const queryString = params.toString();
+        const url = `${constants_1.EMBER_API_BASE_URL}${constants_1.EMBER_ENDPOINTS.TVL}${queryString ? `?${queryString}` : ''}`;
+        const response = await fetch(url, core_1.DEFAULT_FETCH_OPTIONS);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const result = await response.json();
+        if (Array.isArray(result) && result.length > 0) {
+            const latestEntry = result[0];
+            return Number(latestEntry.tvlE9) / constants_1.EMBER_DEFAULTS.E9_DIVISOR;
+        }
+        return 0;
+    }
+    catch (error) {
+        logger_1.Logger.log.error('getEmberTVL', error);
+        return 0;
+    }
+}
+//# sourceMappingURL=getters.js.map

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

@@ -0,0 +1,45 @@
+/**
+ * Sui Adapter for August SDK
+ *
+ * @module SuiAdapter
+ */
+import * as SuiConstants from './constants';
+import * as SuiGetters from './getters';
+import * as SuiUtils from './utils';
+import { transformEmberVaultToIVault, transformEmberVaultsToIVaults } from './transformer';
+import type { IEmberVault, IFetchEmberVaultsOptions } from './types';
+export declare const Sui: {
+    utils: typeof SuiUtils;
+    constants: typeof SuiConstants;
+    getters: typeof SuiGetters;
+    transformer: {
+        transformEmberVaultToIVault: typeof transformEmberVaultToIVault;
+        transformEmberVaultsToIVaults: typeof transformEmberVaultsToIVaults;
+    };
+};
+/**
+ * Sui Adapter for August SDK
+ *
+ * @example
+ * To access the Sui adapter instance
+ * ```
+ * const sdk = new AugustSDK()
+ * sdk.sui.getEmberVaults()
+ * ```
+ */
+declare class SuiAdapter {
+    private _apiBaseUrl;
+    private _chainId;
+    constructor(apiBaseUrl?: string, chainId?: number);
+    get apiBaseUrl(): string;
+    get chainId(): number;
+    getEmberVaults(options?: IFetchEmberVaultsOptions): Promise<IEmberVault[]>;
+    getEmberTVL(limit?: number): Promise<number>;
+    convertFromE9(value: string | number): number;
+    calculateUtilization(current: string | number, maximum: string | number): number;
+    isSuiAddress(address: string): boolean;
+    isSuiVault(chainId: number): boolean;
+    transformEmberVaultToIVault(emberVault: IEmberVault): import("../..").IVault;
+    transformEmberVaultsToIVaults(emberVaults: IEmberVault[]): import("../..").IVault[];
+}
+export default SuiAdapter;

package/lib/adapters/sui/index.js

@@ -0,0 +1,101 @@
+"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.Sui = void 0;
+/**
+ * Sui Adapter for August SDK
+ *
+ * @module SuiAdapter
+ */
+const SuiConstants = __importStar(require("./constants"));
+const SuiGetters = __importStar(require("./getters"));
+const SuiUtils = __importStar(require("./utils"));
+const transformer_1 = require("./transformer");
+exports.Sui = {
+    utils: SuiUtils,
+    constants: SuiConstants,
+    getters: SuiGetters,
+    transformer: { transformEmberVaultToIVault: transformer_1.transformEmberVaultToIVault, transformEmberVaultsToIVaults: transformer_1.transformEmberVaultsToIVaults },
+};
+/**
+ * Sui Adapter for August SDK
+ *
+ * @example
+ * To access the Sui adapter instance
+ * ```
+ * const sdk = new AugustSDK()
+ * sdk.sui.getEmberVaults()
+ * ```
+ */
+class SuiAdapter {
+    _apiBaseUrl;
+    _chainId;
+    constructor(apiBaseUrl = SuiConstants.EMBER_API_BASE_URL, chainId = SuiConstants.SUI_CHAIN_ID) {
+        this._apiBaseUrl = apiBaseUrl;
+        this._chainId = chainId;
+    }
+    get apiBaseUrl() {
+        return this._apiBaseUrl;
+    }
+    get chainId() {
+        return this._chainId;
+    }
+    async getEmberVaults(options) {
+        return await SuiGetters.getEmberVaults(options);
+    }
+    async getEmberTVL(limit = 1) {
+        return await SuiGetters.getEmberTVL(limit);
+    }
+    convertFromE9(value) {
+        return SuiUtils.convertFromE9(value);
+    }
+    calculateUtilization(current, maximum) {
+        return SuiUtils.calculateUtilization(current, maximum);
+    }
+    isSuiAddress(address) {
+        return SuiUtils.isSuiAddress(address);
+    }
+    isSuiVault(chainId) {
+        return SuiUtils.isSuiVault(chainId);
+    }
+    transformEmberVaultToIVault(emberVault) {
+        return (0, transformer_1.transformEmberVaultToIVault)(emberVault);
+    }
+    transformEmberVaultsToIVaults(emberVaults) {
+        return (0, transformer_1.transformEmberVaultsToIVaults)(emberVaults);
+    }
+}
+exports.default = SuiAdapter;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,10 @@
+import type { IVault } from '../../types';
+import type { IEmberVault } from './types';
+/**
+ * Transform Ember vault to IVault format
+ */
+export declare function transformEmberVaultToIVault(emberVault: IEmberVault): IVault;
+/**
+ * Transform multiple Ember vaults
+ */
+export declare function transformEmberVaultsToIVaults(emberVaults: IEmberVault[]): IVault[];

package/lib/adapters/sui/transformer.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformEmberVaultToIVault = transformEmberVaultToIVault;
+exports.transformEmberVaultsToIVaults = transformEmberVaultsToIVaults;
+const core_1 = require("../../core");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+/**
+ * Transform Ember vault to IVault format
+ */
+function transformEmberVaultToIVault(emberVault) {
+    const depositTokenDecimals = emberVault.depositCoin?.decimals || constants_1.EMBER_DEFAULTS.DECIMALS;
+    const receiptTokenDecimals = emberVault.receiptCoin?.decimals || constants_1.EMBER_DEFAULTS.DECIMALS;
+    const returnObj = {
+        chainId: constants_1.SUI_CHAIN_ID,
+        maxDailyDrawdown: 0,
+        risk: 'medium',
+        lagDuration: 0,
+        address: emberVault.address,
+        name: emberVault.name,
+        logoUrl: emberVault.logoUrl || '',
+        apy: {
+            apy: (0, utils_1.convertFromE9)(emberVault.reportedApy?.reportedApyE9 || 0) * 100,
+            pointsApy: null,
+            campaignApy: null,
+            explainer: '',
+            liquidApy: 0,
+            rewardsClaimable: 0,
+            rewardsCompounded: 0,
+            underlyingApy: (0, utils_1.convertFromE9)(emberVault.reportedApy?.reportedApyE9 || 0) * 100,
+        },
+        historical_apy: {
+            7: (0, utils_1.convertFromE9)(emberVault.reportedApy?.reportedApyE9 || 0),
+        },
+        strategists: (emberVault.managers ||
+            emberVault.subAccounts?.map((s) => s.manager) ||
+            []).map((manager) => ({
+            address: manager?.id || '',
+            logo: manager?.logoUrl || '',
+            name: manager?.name?.toLowerCase() === 'gamma'
+                ? 'Gamma Research'
+                : manager?.name || 'Unknown',
+            type: 'subaccount',
+            website_url: null,
+        })),
+        fees: {
+            performance: (0, utils_1.convertFromE9)(emberVault.weeklyPerformanceFeeBpsE9 || 0) /
+                constants_1.EMBER_DEFAULTS.BPS_TO_PERCENT,
+            management: (0, utils_1.convertFromE9)(emberVault.managementFeePercentE9 || 0) * 100,
+            isManagementWaived: false,
+            managementFeeWaivedUntilDate: null,
+            managementFeeWaivedUntilTvl: null,
+            isPerformanceWaived: false,
+            performanceFeeWaivedUntilDate: null,
+            performanceFeeWaivedUntilTvl: null,
+        },
+        rewards: {
+            points: '0',
+            multiplier: 0,
+            multipliers: [],
+            additionalPoints: [],
+            additionalPointsDetailed: [],
+        },
+        version: constants_1.EMBER_DEFAULTS.VERSION,
+        description: emberVault.description || '',
+        startDatetime: new Date(emberVault.createdAt || Date.now()).toISOString(),
+        status: emberVault.status === 'deprecated' ? 'closed' : 'active',
+        tags: ['Sui DeFi', emberVault.publicType].filter(Boolean),
+        isFeatured: false,
+        isSpotlighted: false,
+        withdrawalOnly: undefined,
+        isVisible: emberVault.status === 'active' || emberVault.status === 'beta',
+        reserveTarget: 0,
+        reserveTolerance: 0,
+        isDepositPaused: emberVault.status === 'deprecated',
+        decimals: receiptTokenDecimals,
+        isWithdrawalPaused: emberVault.status === 'deprecated',
+        operator: '',
+        idleAssets: (0, core_1.toNormalizedBn)(0, receiptTokenDecimals),
+        depositAssets: [
+            {
+                address: emberVault.depositCoin?.address,
+                symbol: emberVault.depositCoin?.symbol || '',
+                decimals: depositTokenDecimals,
+            },
+        ],
+        totalAssets: (0, core_1.toNormalizedBn)(BigInt(emberVault.totalDeposits || '0'), depositTokenDecimals),
+        totalSupply: (0, core_1.toNormalizedBn)(BigInt(emberVault.totalDeposits || '0'), receiptTokenDecimals),
+        maxSupply: (0, core_1.toNormalizedBn)(BigInt(emberVault.maxDepositsAllowed || '0'), depositTokenDecimals),
+        receipt: {
+            symbol: emberVault.receiptCoin?.symbol || '',
+            address: emberVault.receiptCoin?.address,
+            decimals: receiptTokenDecimals,
+        },
+        composabilityIntegrations: [],
+        eoa_operators: [],
+        operators: [],
+    };
+    return returnObj;
+}
+/**
+ * Transform multiple Ember vaults
+ */
+function transformEmberVaultsToIVaults(emberVaults) {
+    return emberVaults.map(transformEmberVaultToIVault);
+}
+//# sourceMappingURL=transformer.js.map