@upshiftfinance/sdk 0.0.0-stage → 0.1.0

package/lib/adapters/evm/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionsToCallReduction = exports.functionsToCallMapping = void 0;
+const core_1 = require("../../core");
+/**
+ * @todo
+ */
+const functionsToCallMapping = (provider, contract, functionCalls) => {
+    return functionCalls.map((f) => {
+        if (f === 'symbol') {
+            return (0, core_1.getSymbol)(provider, contract);
+        }
+        if (f === 'decimals') {
+            return (0, core_1.getDecimals)(provider, contract);
+        }
+        return contract[f]();
+    });
+};
+exports.functionsToCallMapping = functionsToCallMapping;
+/**
+ * @todo
+ */
+const functionsToCallReduction = (acc, curr, i, functionCalls, contractCalls) => {
+    let val;
+    if (functionCalls[i] === 'totalSupply' ||
+        functionCalls[i] === 'totalAssets' ||
+        functionCalls[i] === 'globalLoansAmount' ||
+        functionCalls[i] === 'maxSupply' ||
+        functionCalls[i] === 'depositCap') {
+        val = (0, core_1.toNormalizedBn)(curr, contractCalls[0]);
+    }
+    else if (functionCalls[i] === 'getTotalLoansDeployed') {
+        val = (0, core_1.toNormalizedBn)(curr, 0);
+    }
+    else if (functionCalls[i] === 'withdrawalFee') {
+        val = (0, core_1.toNormalizedBn)(curr, 2);
+    }
+    else if (functionCalls[i] === 'decimals') {
+        val = Number(curr.toString());
+    }
+    else if (functionCalls[i] === 'loansOperator') {
+        // TODO: hardcoded as we cannot pull the real strategist
+        val = '0x4DCb388488622e47683EAd1a147947140a31e485';
+    }
+    else {
+        val = curr;
+    }
+    return { ...acc, [functionCalls[i]]: val };
+};
+exports.functionsToCallReduction = functionsToCallReduction;
+//# sourceMappingURL=utils.js.map

package/lib/adapters/solana/confirm.d.ts

@@ -0,0 +1,88 @@
+import { AnchorProvider } from '@coral-xyz/anchor';
+import { type Commitment, type ConfirmOptions, type Connection, type Signer, type Transaction, type TransactionSignature, type VersionedTransaction } from '@solana/web3.js';
+/** Delay between signature-status polls. */
+export declare const CONFIRM_POLL_INTERVAL_MS = 2000;
+/**
+ * Wall-clock backstop, also bounding every in-flight RPC read (web3.js sets no
+ * request timeout). Expiry is normally seen first: a blockhash lasts ~150
+ * blocks (~60s, longer when slots are skipped), and the finalized height it is checked against lags ~13s.
+ */
+export declare const CONFIRM_TIMEOUT_MS = 120000;
+/** Cap on a single RPC read, so a hung request counts as a failed read rather than eating the backstop. */
+export declare const CONFIRM_READ_TIMEOUT_MS = 10000;
+/** Ceiling for the doubling wait after polls whose reads failed. */
+export declare const CONFIRM_MAX_BACKOFF_MS = 16000;
+/**
+ * Wait for a sent transaction to reach `commitment`, over HTTP only.
+ *
+ * Anchor's `.rpc()` confirms by signature alone: a WebSocket
+ * `signatureSubscribe` raced against a fixed 30s (`confirmed`) or 60s
+ * (`finalized`) timer, so a transaction that landed is reported as failed
+ * whenever the notification is missed. This polls `getSignatureStatuses`, and
+ * ends on the blockhash's real expiry rather than a timer.
+ *
+ * It never reports that resubmitting is safe. An expired transaction that no
+ * lookup can find very likely never landed, but an RPC node with incomplete
+ * history cannot prove it, and a wrong "safe" duplicates a deposit or redeem.
+ *
+ * @param connection - Connection the transaction was sent through.
+ * @param signature - Signature returned by `sendRawTransaction`.
+ * @param lastValidBlockHeight - Expiry of the blockhash the signed
+ *   transaction carries, checked against the finalized block height. Omit
+ *   when unknown (or for a durable-nonce transaction): the wait then ends only
+ *   on confirmation, failure or `timeoutMs`.
+ * @param commitment - Level the transaction must reach.
+ * @param pollIntervalMs - Delay between polls; must be positive. Defaults to {@link CONFIRM_POLL_INTERVAL_MS}.
+ * @param timeoutMs - Wall-clock backstop; must be positive. Defaults to {@link CONFIRM_TIMEOUT_MS}.
+ * @param readTimeoutMs - Cap on each RPC read; must be positive. Defaults to {@link CONFIRM_READ_TIMEOUT_MS}.
+ * @returns `signature`, once its status reaches `commitment` with no error.
+ * @throws {@link SendTransactionError} when the transaction failed at
+ *   `commitment`, with logs attached for Anchor's `translateError`.
+ * @throws {@link UpshiftTransactionError} `TRANSACTION_UNCONFIRMED` when no
+ *   outcome was established: the blockhash expired with the transaction
+ *   nowhere to be found, or `timeoutMs` passed. `context.reason` is
+ *   `expired_not_found` (very likely never landed — still check before
+ *   resubmitting), `below_commitment` (seen landing without error),
+ *   `failed_below_commitment` (seen failing, not yet final), `rpc_failing`
+ *   (reads failed) or `not_visible`; `context` also carries the last status
+ *   seen and read counts, and `cause` the last failed read.
+ * @throws {@link UpshiftValidationError} for a non-positive or non-finite interval or timeout.
+ * @remarks **RPC cost.** The first poll runs right after sending. Per poll: one `getSignatureStatuses`, plus one
+ *   finalized `getBlockHeight` while the transaction is not visible (and, past
+ *   expiry, one history lookup). Typically 1–3 calls at `confirmed`, ~7–10 at
+ *   `finalized`, ~60 for an expiring transaction; the `timeoutMs` backstop
+ *   allows ~60 polls of 1–3 calls, fewer while reads fail: the wait doubles
+ *   after each poll with a failed read, up to {@link CONFIRM_MAX_BACKOFF_MS}. Failed reads are tolerated, so a transient RPC
+ *   error never misreports a landed transaction.
+ */
+export declare function confirmByBlockhash({ connection, signature, lastValidBlockHeight, commitment, pollIntervalMs, timeoutMs, readTimeoutMs, }: {
+    connection: Connection;
+    signature: TransactionSignature;
+    lastValidBlockHeight?: number;
+    commitment: Commitment;
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    readTimeoutMs?: number;
+}): Promise<TransactionSignature>;
+/**
+ * `AnchorProvider` whose `sendAndConfirm` — what `program.methods…rpc()` calls —
+ * confirms with {@link confirmByBlockhash} instead of Anchor's signature-only
+ * WebSocket wait. Signing and Anchor's error translation are unchanged.
+ */
+export declare class BlockhashConfirmingProvider extends AnchorProvider {
+    /**
+     * Sign, send and confirm a transaction.
+     *
+     * @param tx - Transaction to send. Its blockhash (and fee payer, if unset)
+     *   are set here. A `VersionedTransaction` already carries a blockhash this
+     *   cannot learn the expiry of, so it takes Anchor's default path.
+     * @param signers - Extra signers besides the wallet.
+     * @param opts - Defaults to the provider's options.
+     * @returns The transaction signature.
+     * @throws See {@link confirmByBlockhash}; also whatever the wallet or
+     *   `sendRawTransaction` throws (user rejection, preflight failure).
+     * @remarks **RPC cost.** `getLatestBlockhash` + `sendRawTransaction`, then
+     *   the confirmation polls described on {@link confirmByBlockhash}.
+     */
+    sendAndConfirm(tx: Transaction | VersionedTransaction, signers?: Signer[], opts?: ConfirmOptions): Promise<TransactionSignature>;
+}

package/lib/adapters/solana/confirm.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockhashConfirmingProvider = exports.CONFIRM_MAX_BACKOFF_MS = exports.CONFIRM_READ_TIMEOUT_MS = exports.CONFIRM_TIMEOUT_MS = exports.CONFIRM_POLL_INTERVAL_MS = void 0;
+exports.confirmByBlockhash = confirmByBlockhash;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const core_1 = require("../../core");
+const concurrency_1 = require("../../core/helpers/concurrency");
+/** Delay between signature-status polls. */
+exports.CONFIRM_POLL_INTERVAL_MS = 2_000;
+/**
+ * Wall-clock backstop, also bounding every in-flight RPC read (web3.js sets no
+ * request timeout). Expiry is normally seen first: a blockhash lasts ~150
+ * blocks (~60s, longer when slots are skipped), and the finalized height it is checked against lags ~13s.
+ */
+exports.CONFIRM_TIMEOUT_MS = 120_000;
+/** Cap on a single RPC read, so a hung request counts as a failed read rather than eating the backstop. */
+exports.CONFIRM_READ_TIMEOUT_MS = 10_000;
+/** Ceiling for the doubling wait after polls whose reads failed. */
+exports.CONFIRM_MAX_BACKOFF_MS = 16_000;
+const COMMITMENT_RANK = {
+    processed: 0,
+    recent: 0,
+    confirmed: 1,
+    single: 1,
+    singleGossip: 1,
+    finalized: 2,
+    max: 2,
+    root: 2,
+};
+/**
+ * The level a status has reached. Older RPCs omit `confirmationStatus`; the
+ * level is then inferred from `confirmations` as Agave's
+ * `TransactionStatus::satisfies_commitment` does: `null` is rooted, more than
+ * one confirmation is `confirmed`, anything else `processed`.
+ */
+function levelOf(status) {
+    if (status.confirmationStatus)
+        return status.confirmationStatus;
+    if (status.confirmations === null)
+        return 'finalized';
+    return status.confirmations > 1 ? 'confirmed' : 'processed';
+}
+function reaches(status, commitment) {
+    return COMMITMENT_RANK[levelOf(status)] >= COMMITMENT_RANK[commitment];
+}
+/**
+ * Wait for a sent transaction to reach `commitment`, over HTTP only.
+ *
+ * Anchor's `.rpc()` confirms by signature alone: a WebSocket
+ * `signatureSubscribe` raced against a fixed 30s (`confirmed`) or 60s
+ * (`finalized`) timer, so a transaction that landed is reported as failed
+ * whenever the notification is missed. This polls `getSignatureStatuses`, and
+ * ends on the blockhash's real expiry rather than a timer.
+ *
+ * It never reports that resubmitting is safe. An expired transaction that no
+ * lookup can find very likely never landed, but an RPC node with incomplete
+ * history cannot prove it, and a wrong "safe" duplicates a deposit or redeem.
+ *
+ * @param connection - Connection the transaction was sent through.
+ * @param signature - Signature returned by `sendRawTransaction`.
+ * @param lastValidBlockHeight - Expiry of the blockhash the signed
+ *   transaction carries, checked against the finalized block height. Omit
+ *   when unknown (or for a durable-nonce transaction): the wait then ends only
+ *   on confirmation, failure or `timeoutMs`.
+ * @param commitment - Level the transaction must reach.
+ * @param pollIntervalMs - Delay between polls; must be positive. Defaults to {@link CONFIRM_POLL_INTERVAL_MS}.
+ * @param timeoutMs - Wall-clock backstop; must be positive. Defaults to {@link CONFIRM_TIMEOUT_MS}.
+ * @param readTimeoutMs - Cap on each RPC read; must be positive. Defaults to {@link CONFIRM_READ_TIMEOUT_MS}.
+ * @returns `signature`, once its status reaches `commitment` with no error.
+ * @throws {@link SendTransactionError} when the transaction failed at
+ *   `commitment`, with logs attached for Anchor's `translateError`.
+ * @throws {@link UpshiftTransactionError} `TRANSACTION_UNCONFIRMED` when no
+ *   outcome was established: the blockhash expired with the transaction
+ *   nowhere to be found, or `timeoutMs` passed. `context.reason` is
+ *   `expired_not_found` (very likely never landed — still check before
+ *   resubmitting), `below_commitment` (seen landing without error),
+ *   `failed_below_commitment` (seen failing, not yet final), `rpc_failing`
+ *   (reads failed) or `not_visible`; `context` also carries the last status
+ *   seen and read counts, and `cause` the last failed read.
+ * @throws {@link UpshiftValidationError} for a non-positive or non-finite interval or timeout.
+ * @remarks **RPC cost.** The first poll runs right after sending. Per poll: one `getSignatureStatuses`, plus one
+ *   finalized `getBlockHeight` while the transaction is not visible (and, past
+ *   expiry, one history lookup). Typically 1–3 calls at `confirmed`, ~7–10 at
+ *   `finalized`, ~60 for an expiring transaction; the `timeoutMs` backstop
+ *   allows ~60 polls of 1–3 calls, fewer while reads fail: the wait doubles
+ *   after each poll with a failed read, up to {@link CONFIRM_MAX_BACKOFF_MS}. Failed reads are tolerated, so a transient RPC
+ *   error never misreports a landed transaction.
+ */
+async function confirmByBlockhash({ connection, signature, lastValidBlockHeight, commitment, pollIntervalMs = exports.CONFIRM_POLL_INTERVAL_MS, timeoutMs = exports.CONFIRM_TIMEOUT_MS, readTimeoutMs = exports.CONFIRM_READ_TIMEOUT_MS, }) {
+    for (const [name, value] of [
+        ['pollIntervalMs', pollIntervalMs],
+        ['timeoutMs', timeoutMs],
+        ['readTimeoutMs', readTimeoutMs],
+    ]) {
+        if (!Number.isFinite(value) || value <= 0)
+            throw new core_1.UpshiftValidationError('INVALID_INPUT', `confirmByBlockhash: ${name} must be a positive finite number, got ${value}.`);
+    }
+    const deadline = Date.now() + timeoutMs;
+    let reads = 0;
+    let failedReads = 0;
+    let lastReadError;
+    let lastSeen;
+    /** Finalized block height at which the transaction was found expired and absent. */
+    let expiredAt;
+    /** One RPC read; `undefined` when it failed or hung (outcome unknown). */
+    const read = async (call) => {
+        reads += 1;
+        const remaining = deadline - Date.now();
+        // Records whether the RPC itself rejected, so a timeout is told apart from
+        // a failure by which promise lost, not by reading the clock.
+        let rpcFailure;
+        const pending = call().catch((error) => {
+            rpcFailure = { error };
+            throw error;
+        });
+        try {
+            return await (0, concurrency_1.withTimeout)(pending, Math.min(readTimeoutMs, remaining), 'Solana RPC read');
+        }
+        catch (timeout) {
+            // The timer was the backstop's, not the per-read cap: not an RPC failure.
+            if (!rpcFailure && remaining < readTimeoutMs)
+                return undefined;
+            failedReads += 1;
+            lastReadError = rpcFailure ? rpcFailure.error : timeout;
+            return undefined;
+        }
+    };
+    const statusOf = (searchTransactionHistory = false) => read(() => connection
+        .getSignatureStatuses([signature], { searchTransactionHistory })
+        .then((r) => r.value[0]));
+    /**
+     * `true` once `status` is final at `commitment`; throws if it failed there.
+     * A failure seen below `commitment` is not final yet, as in Anchor.
+     */
+    const settled = async (status) => {
+        lastSeen = status;
+        if (!reaches(status, commitment))
+            return false;
+        if (!status.err)
+            return true;
+        const tx = await read(() => connection.getTransaction(signature, {
+            commitment: 'confirmed',
+            maxSupportedTransactionVersion: 0,
+        }));
+        // Keep `JSON.stringify(status.err)` in the message: without logs, Anchor's
+        // `ProgramError.parse` recovers the program error code from its
+        // `"Custom":N}`.
+        throw new web3_js_1.SendTransactionError({
+            action: 'send',
+            signature,
+            transactionMessage: `Transaction failed: ${JSON.stringify(status.err)}`,
+            logs: tx?.meta?.logMessages ?? undefined,
+        });
+    };
+    /** One poll: `true` once confirmed; throws on a definitive failure. */
+    const pollOnce = async () => {
+        // `undefined` = read failed (unknown); `null` = not visible to the RPC.
+        const status = await statusOf();
+        if (status)
+            return settled(status);
+        // Seen before but gone now (dropped fork): no longer evidence it landed.
+        if (status === null)
+            lastSeen = undefined;
+        if (status === undefined || lastValidBlockHeight === undefined)
+            return false;
+        // Finalized, whatever `commitment` is: a `processed`/`confirmed` height can
+        // belong to a fork that is later dropped while the transaction still lands
+        // on the surviving one. Past the finalized height, every fork is expired.
+        const height = await read(() => connection.getBlockHeight('finalized'));
+        if (height === undefined || height <= lastValidBlockHeight)
+            return false;
+        // Past expiry. Last look, including history, in case it landed between polls.
+        const final = await statusOf(true);
+        if (final)
+            return settled(final);
+        if (final === null)
+            expiredAt = height;
+        return false;
+    };
+    // Poll first: a transaction often lands within a second of sending. After a
+    // poll with a failed read, the wait doubles (up to the ceiling) so a failing
+    // RPC is not hit at full cadence; a clean poll restores the normal interval.
+    let backoff = 0;
+    for (;;) {
+        const failedBefore = failedReads;
+        if (await pollOnce())
+            return signature;
+        if (expiredAt !== undefined)
+            break;
+        backoff = failedReads > failedBefore ? backoff + 1 : 0;
+        const interval = Math.min(pollIntervalMs * 2 ** backoff, Math.max(pollIntervalMs, exports.CONFIRM_MAX_BACKOFF_MS));
+        const wait = Math.min(interval, deadline - Date.now());
+        if (wait <= 0)
+            break;
+        await new Promise((r) => setTimeout(r, wait));
+    }
+    const seconds = timeoutMs / 1000;
+    const seenAt = lastSeen ? levelOf(lastSeen) : null;
+    const reason = expiredAt !== undefined
+        ? 'expired_not_found'
+        : !lastSeen
+            ? failedReads > 0
+                ? 'rpc_failing'
+                : 'not_visible'
+            : lastSeen.err
+                ? 'failed_below_commitment'
+                : 'below_commitment';
+    const message = {
+        expired_not_found: `Transaction ${signature} was not found and its blockhash has expired (block height exceeded), ` +
+            'so it very likely never landed. This cannot be proven from the RPC; check the signature before resubmitting.',
+        below_commitment: `Transaction ${signature} landed without error (${seenAt}) but was not confirmed in ${seconds} seconds ` +
+            `at '${commitment}'. Do not resubmit; it is most likely to finalize.`,
+        failed_below_commitment: `Transaction ${signature} was seen failing (${seenAt}) but was not confirmed in ${seconds} seconds ` +
+            `at '${commitment}', so the failure is not final yet. Check the signature before resubmitting.`,
+        rpc_failing: undefined,
+        not_visible: undefined,
+    }[reason];
+    throw new core_1.UpshiftTransactionError(message ??
+        `Transaction ${signature} was not confirmed in ${seconds} seconds. ` +
+            'It is unknown if it succeeded or failed; check the signature before resubmitting.', signature, {
+        cause: expiredAt !== undefined
+            ? new web3_js_1.TransactionExpiredBlockheightExceededError(signature)
+            : lastReadError,
+        context: {
+            signature,
+            commitment,
+            reason,
+            ...(expiredAt !== undefined && {
+                lastValidBlockHeight,
+                blockHeight: expiredAt,
+            }),
+            lastSeenStatus: seenAt,
+            lastSeenErr: lastSeen?.err ?? null,
+            reads,
+            failedReads,
+        },
+    });
+}
+/**
+ * `AnchorProvider` whose `sendAndConfirm` — what `program.methods…rpc()` calls —
+ * confirms with {@link confirmByBlockhash} instead of Anchor's signature-only
+ * WebSocket wait. Signing and Anchor's error translation are unchanged.
+ */
+class BlockhashConfirmingProvider extends anchor_1.AnchorProvider {
+    /**
+     * Sign, send and confirm a transaction.
+     *
+     * @param tx - Transaction to send. Its blockhash (and fee payer, if unset)
+     *   are set here. A `VersionedTransaction` already carries a blockhash this
+     *   cannot learn the expiry of, so it takes Anchor's default path.
+     * @param signers - Extra signers besides the wallet.
+     * @param opts - Defaults to the provider's options.
+     * @returns The transaction signature.
+     * @throws See {@link confirmByBlockhash}; also whatever the wallet or
+     *   `sendRawTransaction` throws (user rejection, preflight failure).
+     * @remarks **RPC cost.** `getLatestBlockhash` + `sendRawTransaction`, then
+     *   the confirmation polls described on {@link confirmByBlockhash}.
+     */
+    async sendAndConfirm(tx, signers, opts = this.opts) {
+        if ('version' in tx)
+            return super.sendAndConfirm(tx, signers, opts);
+        const commitment = opts.commitment ?? this.connection.commitment ?? 'finalized';
+        const preflightCommitment = opts.preflightCommitment ?? commitment;
+        const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash(preflightCommitment);
+        tx.feePayer = tx.feePayer ?? this.wallet.publicKey;
+        tx.recentBlockhash = blockhash;
+        for (const signer of signers ?? [])
+            tx.partialSign(signer);
+        const signed = await this.wallet.signTransaction(tx);
+        const signature = await this.connection.sendRawTransaction(signed.serialize(), {
+            skipPreflight: opts.skipPreflight,
+            preflightCommitment,
+            maxRetries: opts.maxRetries,
+            minContextSlot: opts.minContextSlot,
+        });
+        return confirmByBlockhash({
+            connection: this.connection,
+            signature,
+            // The expiry fetched here only bounds a tx that carries this blockhash.
+            // A wallet may re-stamp it when signing, and a durable-nonce tx
+            // serializes its nonce instead; either way it could still land.
+            lastValidBlockHeight: !signed.nonceInfo && signed.recentBlockhash === blockhash
+                ? lastValidBlockHeight
+                : undefined,
+            commitment,
+        });
+    }
+}
+exports.BlockhashConfirmingProvider = BlockhashConfirmingProvider;
+//# sourceMappingURL=confirm.js.map

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

@@ -0,0 +1,42 @@
+import type { ISolanaNetwork } from '../../types';
+import { vaultIdl } from './idl/vault-idl';
+declare const fallbackDecimals = 8;
+declare const fallbackNetwork: ISolanaNetwork;
+/**
+ * Program ids deployed on one Solana network. `withdrawalQueue` is absent where
+ * the queue program is not deployed.
+ */
+type ISolanaProgramIds = {
+    vault: string;
+    withdrawalQueue?: string;
+};
+declare const fallbackRpcEndpoints: {
+    readonly devnet: "https://api.devnet.solana.com";
+    readonly mainnet: "https://api.mainnet-beta.solana.com";
+    readonly testnet: "https://api.testnet.solana.com";
+    readonly localnet: "http://127.0.0.1:8899";
+};
+declare const programIds: {
+    devnet: {
+        vault: string;
+        withdrawalQueue: string;
+    };
+    "mainnet-beta": {
+        vault: string;
+        withdrawalQueue: string;
+    };
+    localnet: {
+        vault: string;
+        withdrawalQueue: string;
+    };
+};
+/** Solana networks the canonical august_vault program is actually deployed on. */
+type ISolanaDeployedNetwork = keyof typeof programIds;
+/**
+ * Program ids for `network`, or `undefined` when the canonical program has no
+ * deployment there (currently `testnet`). Callers must handle `undefined` —
+ * silently substituting a default would hand back a dead address.
+ */
+declare function getDeployedProgramIds(network: ISolanaNetwork): ISolanaProgramIds | undefined;
+export { fallbackDecimals, fallbackNetwork, fallbackRpcEndpoints, getDeployedProgramIds, programIds, vaultIdl, };
+export type { ISolanaDeployedNetwork, ISolanaProgramIds };

package/lib/adapters/solana/constants.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultIdl = exports.programIds = exports.fallbackRpcEndpoints = exports.fallbackNetwork = exports.fallbackDecimals = void 0;
+exports.getDeployedProgramIds = getDeployedProgramIds;
+const vault_idl_1 = require("./idl/vault-idl");
+Object.defineProperty(exports, "vaultIdl", { enumerable: true, get: function () { return vault_idl_1.vaultIdl; } });
+const fallbackDecimals = 8;
+exports.fallbackDecimals = fallbackDecimals;
+const fallbackNetwork = 'mainnet-beta';
+exports.fallbackNetwork = fallbackNetwork;
+const fallbackRpcEndpoints = {
+    devnet: 'https://api.devnet.solana.com',
+    mainnet: 'https://api.mainnet-beta.solana.com',
+    testnet: 'https://api.testnet.solana.com',
+    localnet: 'http://127.0.0.1:8899',
+};
+exports.fallbackRpcEndpoints = fallbackRpcEndpoints;
+// The shared, canonical august_vault program (multi-vault), deployed under the
+// same id (`up12…`) on devnet and mainnet-beta. Per-vault program deploys (e.g.
+// the legacy SyrupBTC `7B8n…`, and the interim devnet `C8B1…`) are retired. At
+// runtime the program id is resolved from backend vault metadata; this map is
+// the default/fallback.
+//
+// Deliberately partial: no `testnet` entry — the program isn't deployed there,
+// and mapping it would hand callers a dead address that only fails deep inside a
+// transaction. Unmapped networks throw from `getProgram`/`getProgramId` instead.
+// `satisfies` keeps the literal ids in the generated docs while checking keys
+// against ISolanaNetwork, so `testnet` is absent from the type, not optional.
+//
+// `withdrawalQueue` is the august_withdrawal_queue program. Its id is fixed (the
+// vault binary hardcodes it as `WITHDRAWAL_QUEUE_PROGRAM_ID`), and it is mapped
+// where deployed: mainnet-beta since release v0.3.0 (14 Oct 2026), devnet and
+// localnet. Mapping the program says nothing about any one vault: whether a
+// vault redeems through a queue is read per vault, from its
+// `withdrawalQueueAuthority`, and a vault without one keeps direct redemption.
+const programIds = {
+    devnet: {
+        vault: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+        withdrawalQueue: 'upQhC7mgYwmHLVaatRWoGAu394piLT9th9FiQZHnPrW',
+    },
+    ['mainnet-beta']: {
+        vault: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+        withdrawalQueue: 'upQhC7mgYwmHLVaatRWoGAu394piLT9th9FiQZHnPrW',
+    },
+    localnet: {
+        vault: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+        withdrawalQueue: 'upQhC7mgYwmHLVaatRWoGAu394piLT9th9FiQZHnPrW',
+    },
+};
+exports.programIds = programIds;
+/**
+ * Program ids for `network`, or `undefined` when the canonical program has no
+ * deployment there (currently `testnet`). Callers must handle `undefined` —
+ * silently substituting a default would hand back a dead address.
+ */
+function getDeployedProgramIds(network) {
+    return programIds[network];
+}
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,42 @@
+import type { ITokenizedVault } from '../../types';
+import type { IVaultBaseOptions } from '../../modules/vaults/types';
+/**
+ * Fetch Solana vault data from on-chain program state.
+ * Falls back to backend-only data when Solana RPC is unavailable,
+ * ensuring vaults always appear in the list even without on-chain access.
+ *
+ * When the vault has a withdrawal queue, `withdrawalQueue` carries its live
+ * summary, at the cost of one extra `getMultipleAccountsInfo` (the queue and a
+ * fresh read of the vault state, for `enabled`). A failed queue read is
+ * logged and leaves the field out rather than failing the vault.
+ * @param tokenizedVault Vault metadata from backend
+ * @param options RPC configuration with Solana service
+ * @returns Formatted vault object with Solana-specific fields
+ */
+export declare const getSolanaVault: (tokenizedVault: ITokenizedVault, options: IVaultBaseOptions) => Promise<import("../../types").IVault>;
+/**
+ * A Solana vault's AUM in USD, split the way its program stores it.
+ */
+export interface ISolanaVaultAumUsd {
+    /** `deployed_aum`: what the operator has marked as deployed. */
+    deployedUsd: number;
+    /** `local_aum`: what the vault program itself holds. */
+    idleUsd: number;
+}
+/**
+ * Read a Solana vault's AUM in USD fresh from its state account.
+ *
+ * For comparing the vault with live portfolio data: the state cache behind
+ * {@link getSolanaVault} can be up to 24h old, which would show yield accrued
+ * since as unattributed. Costs one uncached vault-state read (plus the deposit
+ * mint's decimals), then one cached price lookup.
+ *
+ * Never rejects. A failed read, a missing state account or symbol, or a
+ * non-positive price returns `null`, so the caller can drop the comparison
+ * without losing the rest of its result.
+ *
+ * @param tokenizedVault - Backend row of the Solana vault
+ * @param options - Must carry `solanaService` for the RPC connection
+ * @returns The vault's deployed and idle AUM in USD, or `null`
+ */
+export declare function getSolanaVaultAumUsd(tokenizedVault: ITokenizedVault, options: IVaultBaseOptions): Promise<ISolanaVaultAumUsd | null>;