upshift-config 0.5.14

package/lib/adapters/evm/index.js

@@ -0,0 +1,434 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const write_actions_1 = require("../../modules/vaults/write.actions");
+const swap_router_1 = require("../../core/helpers/swap-router");
+const read_actions_1 = require("../../modules/vaults/read.actions");
+const signer_1 = require("../../core/helpers/signer");
+__exportStar(require("./getters"), exports);
+/**
+ * EVM Adapter for August SDK
+ * Supports both ethers Signer/Wallet and wagmi/viem WalletClient
+ *
+ * @example
+ * To access the EVM adapter instance
+ * ```
+ * const sdk = new AugustSDK()
+ * sdk.evm.vaultRedeem()
+ * ```
+ */
+class EVMAdapter {
+    signer;
+    rawSigner;
+    constructor(signer) {
+        this.rawSigner = signer;
+        // Don't normalize in constructor - do it lazily when needed
+    }
+    /**
+     * Set a new signer (supports both ethers and viem/wagmi)
+     * @param signer - Either an ethers Signer/Wallet or viem WalletClient
+     */
+    setSigner(signer) {
+        this.rawSigner = signer;
+        this.signer = undefined; // Reset normalized signer
+    }
+    /**
+     * Get the normalized ethers-compatible signer
+     * Converts viem WalletClient to ethers Signer if needed
+     */
+    async getSigner() {
+        if (!this.rawSigner) {
+            throw new Error('No signer provided');
+        }
+        // If we already have a normalized signer, return it
+        if (this.signer) {
+            return this.signer;
+        }
+        // Normalize and cache the signer. The attribution wrap is unconditional
+        // and reads the process-global config at send time, so a cached signer
+        // honors attribution enabled or reset after caching.
+        this.signer = (0, signer_1.wrapSignerWithAttribution)(await (0, signer_1.normalizeSigner)(this.rawSigner));
+        return this.signer;
+    }
+    // Core EVM operations
+    async vaultApprove(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.vaultApprove)(signer, options);
+    }
+    /**
+     * Approve a vault to spend a deposit token, returning a discriminated
+     * {@link ApproveResult} so callers can tell `sent` from `sufficient`
+     * (existing allowance covers) and `native` (no allowance applies).
+     * Prefer this over {@link vaultApprove} for new integrations.
+     *
+     * @example
+     * ```ts
+     * const r = await augustSdk.evm.approve({
+     *   target: vaultAddress,
+     *   wallet: walletAddress,
+     *   amount: '100',
+     *   wait: true,
+     * });
+     * if (r.kind === 'sent') console.log('approve tx', r.hash);
+     * ```
+     */
+    async approve(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.approve)(signer, options);
+    }
+    /**
+     * Read the ERC-20 allowance the wallet has granted the vault to spend its
+     * underlying asset, returned as a normalized number. For the newer typed
+     * read that returns a raw `bigint` and accepts an explicit `asset` override,
+     * use {@link EVMAdapter.allowance}.
+     *
+     * Only `target` (vault address) and `wallet` are read from `options`; the
+     * remaining {@link IContractWriteOptions} fields are ignored.
+     *
+     * @param options - `{ target, wallet }` (other fields ignored).
+     * @returns Normalized allowance (`{ raw, normalized }`), or `undefined` when
+     *   `target` / `wallet` fail address validation.
+     *
+     * @example
+     * ```ts
+     * const a = await augustSdk.evm.vaultAllowance({
+     *   target: vaultAddress,
+     *   wallet: walletAddress,
+     * });
+     * console.log(a?.normalized);
+     * ```
+     */
+    async vaultAllowance(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.vaultAllowance)(signer, options);
+    }
+    // Vault operations (delegate to modules)
+    /**
+     * Deposit into an August vault. Routes automatically: V1 single-asset vaults
+     * deposit the underlying directly; V2 multi-asset vaults route through the
+     * adapter for non-underlying `depositAsset`. If allowance is insufficient
+     * the method submits an approve transaction first (the approve step always
+     * waits for confirmation to close a race window, regardless of `wait`).
+     *
+     * @param options - {@link IContractWriteOptions}. `target` and `wallet` are
+     *   required; pass `amount`, `depositAsset` (defaults to the vault's
+     *   underlying), `chainId`, `poolName`, `wait`, and `isDepositWithPermit`
+     *   as needed.
+     * @returns The deposit `TransactionResponse`, or `undefined` if an
+     *   approval-only path was taken and no deposit transaction was sent.
+     * @throws AugustValidationError on invalid inputs (bad address, bad amount).
+     * @throws AugustSDKError on RPC / contract revert during the deposit.
+     *
+     * @example
+     * ```ts
+     * const tx = await augustSdk.evm.vaultDeposit({
+     *   target: vaultAddress,
+     *   wallet: walletAddress,
+     *   amount: '100',
+     *   wait: true,
+     * });
+     * ```
+     */
+    async vaultDeposit(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.vaultDeposit)(signer, options);
+    }
+    /**
+     * Submit a redemption request against a vault. Shares are escrowed and the
+     * underlying assets are released asynchronously by the protocol; callers
+     * collect the matured assets via {@link EVMAdapter.vaultRedeem}, or use the
+     * instant-redeem variant by setting `isInstantRedeem: true`.
+     *
+     * @param options - {@link IContractWriteOptions}. `target`, `wallet`, and
+     *   `amount` (in shares) are required. Set `isInstantRedeem: true` to take
+     *   the instant-redeem path when the vault supports it.
+     * @returns The request `TransactionResponse`, or `undefined` if the request
+     *   could not be built (validation failure).
+     * @throws AugustValidationError on invalid inputs.
+     * @throws AugustSDKError on RPC / contract revert.
+     *
+     * @example
+     * ```ts
+     * const tx = await augustSdk.evm.vaultRequestRedeem({
+     *   target: vaultAddress,
+     *   wallet: walletAddress,
+     *   amount: shareAmount,
+     *   wait: true,
+     * });
+     * ```
+     */
+    async vaultRequestRedeem(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.vaultRequestRedeem)(signer, options);
+    }
+    /**
+     * Deposit the chain's native asset (ETH / AVAX / etc.) into a vault by
+     * routing through the `MultiAssetNativeDepositWrapper`. The wrapper handles
+     * native-to-wrapped conversion and the subsequent vault deposit in a single
+     * transaction.
+     *
+     * @param options - {@link INativeDepositOptions}: `wrapperAddress`, `amount`
+     *   (native, scaled by the chain's native decimals), optional `receiver`
+     *   (defaults to the signer), and optional `wait`.
+     * @returns The deposit `TransactionResponse`.
+     * @throws AugustValidationError on invalid inputs.
+     * @throws AugustSDKError on RPC / contract revert.
+     *
+     * @example
+     * ```ts
+     * const tx = await augustSdk.evm.depositNative({
+     *   wrapperAddress: nativeWrapperAddress,
+     *   amount: parseEther('1'),
+     *   wait: true,
+     * });
+     * ```
+     */
+    async depositNative(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.depositNative)(signer, options);
+    }
+    /**
+     * Swap one or more whitelisted ERC-20s into a vault's reference asset via
+     * the on-chain `SwapRouter` and deposit the proceeds. The router handles
+     * fee accrual, slippage protection, and the v1/v3 vs v2 deposit-interface
+     * branching. Approval is sent automatically for each `swaps[i].tokenIn`
+     * when the caller's allowance against the SwapRouter is below `amountIn`.
+     *
+     * @param options - {@link ISwapAndDepositOptions}.
+     * @returns The transaction hash of the `swapAndDeposit` call.
+     * @throws AugustValidationError on invalid inputs (bad chain, empty swaps).
+     * @throws AugustSDKError on RPC / contract revert.
+     *
+     * @example
+     * ```ts
+     * const quote = await fetchSwapQuote({
+     *   chainId: 1, srcToken: WBTC, srcDecimals: 8,
+     *   destToken: USDC, destDecimals: 6, amount: 100_000_000n,
+     *   receiver: SWAP_ROUTER_ADDRESSES[1]!,
+     * });
+     * const hash = await augustSdk.evm.swapAndDeposit({
+     *   chainId: 1, vault, receiver: wallet,
+     *   swaps: [{ tokenIn: WBTC, tokenOut: USDC, amountIn: 100_000_000n,
+     *     minAmountOut: quote.minAmountOut, router: quote.router, payload: quote.payload }],
+     * });
+     * ```
+     */
+    async swapAndDeposit(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.swapAndDeposit)(signer, options);
+    }
+    /**
+     * Deposit a vault's reference asset through the SwapRouter — no swap.
+     * Use this when the caller already holds the reference asset but wants
+     * the origin/referral fee accounting that the SwapRouter path provides.
+     *
+     * @param options - {@link ISwapRouterDirectDepositOptions}.
+     * @returns The transaction hash of the `deposit` call.
+     */
+    async depositViaSwapRouter(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.depositViaSwapRouter)(signer, options);
+    }
+    /**
+     * Deposit native ETH (or chain-native equivalent) into a vault via the
+     * SwapRouter. Only valid when the vault's reference asset is the chain's
+     * wrapped-native token — the SwapRouter wraps `amount` and deposits.
+     *
+     * @param options - {@link ISwapRouterNativeDepositOptions}.
+     * @returns The transaction hash of the `depositNativeToken` call.
+     */
+    async depositNativeViaSwapRouter(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.depositNativeViaSwapRouter)(signer, options);
+    }
+    /**
+     * Deposit into a vault through the on-chain `SwapRouter`, choosing the router
+     * path from `depositAsset` (direct deposit, native wrap, or a swap to the
+     * reference asset). The high-level, explicit counterpart to the SwapRouter
+     * branch inside {@link vaultDeposit} — the caller opts into the router
+     * deliberately, so a native-deposit vault is never accidentally swapped.
+     *
+     * Reads the vault's reference asset + decimals on-chain, resolves the swap
+     * quote and fail-closes on aggregator/whitelist drift, and sends the ERC-20
+     * approval to the SwapRouter when allowance is short.
+     *
+     * @param options - {@link ISwapRouterDepositOptions}.
+     * @returns The transaction hash of the router deposit call.
+     * @throws AugustValidationError on unsupported chain, invalid address, zero
+     *   amount, a native deposit into a non-wrapped-native vault, or quote drift.
+     * @example
+     * ```ts
+     * const hash = await augustSdk.evm.swapRouterDeposit({
+     *   chainId: 1, vault, depositAsset: USDT, amount: '100', slippageBps: 50,
+     * });
+     * ```
+     */
+    async swapRouterDeposit(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.swapRouterDeposit)(signer, options);
+    }
+    /**
+     * Resolves the real, post-execution outcome of a SwapRouter deposit from
+     * its mined receipt — the actual amount that reached the vault (and shares
+     * minted), decoded from the vault's own `Deposit` event, rather than the
+     * pre-trade quote shown before submission.
+     *
+     * @param options - {@link ISwapRouterDepositResultOptions}.
+     * @returns The decoded {@link ISwapRouterDepositResult}, or `null` if the
+     *   receipt isn't found yet or carries no matching `Deposit` log.
+     * @example
+     * ```ts
+     * const hash = await augustSdk.evm.swapRouterDeposit({ ... });
+     * const result = await augustSdk.evm.getSwapRouterDepositResult({ txHash: hash, vault });
+     * ```
+     */
+    async getSwapRouterDepositResult(options) {
+        const signer = await this.getSigner();
+        return (0, swap_router_1.getSwapRouterDepositResult)(signer, options);
+    }
+    /**
+     * Claim assets from a matured redemption request on a dated-redemption
+     * (RWA-style) vault. The `year`, `month`, `day`, and `receiverIndex` tuple
+     * identifies which batch of the user's matured requests to redeem from —
+     * these are emitted at request-time and indexed by the subgraph.
+     *
+     * For non-dated vaults that complete their redemption via `instantRedeem`,
+     * see {@link EVMAdapter.vaultRequestRedeem} with `isInstantRedeem: true`.
+     *
+     * @param options - {@link IContractWriteOptions} plus `year` / `month` /
+     *   `day` / `receiverIndex` identifying the matured batch to claim.
+     * @returns The redeem `TransactionResponse`.
+     * @throws AugustValidationError on invalid inputs.
+     * @throws AugustSDKError on RPC / contract revert.
+     *
+     * @example
+     * ```ts
+     * const tx = await augustSdk.evm.vaultRedeem({
+     *   target: vaultAddress,
+     *   wallet: walletAddress,
+     *   amount: shareAmount,
+     *   year: '2026',
+     *   month: '06',
+     *   day: '02',
+     *   receiverIndex: '0',
+     *   wait: true,
+     * });
+     * ```
+     */
+    async vaultRedeem(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.vaultRedeem)(signer, options);
+    }
+    async sendersWhitelistAddress(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.sendersWhitelistAddress)(signer, options);
+    }
+    async isWhitelisted(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.isWhitelisted)(signer, options);
+    }
+    async getDeposited(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.getDeposited)(signer, options);
+    }
+    async getRemainingAllocations(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.getRemainingAllocations)(signer, options);
+    }
+    /**
+     * Preview the share output of a deposit without broadcasting a transaction.
+     * See {@link readPreviewDeposit} for the routing details (EVM-1 vs EVM-2
+     * multi-asset vaults).
+     *
+     * @returns Shares minted in raw on-chain units (share-token decimals).
+     *
+     * @example
+     * ```ts
+     * const shares = await augustSdk.evm.previewDeposit({
+     *   vault: '0x...',
+     *   amount: 1_000_000n,
+     * });
+     * ```
+     */
+    async previewDeposit(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.previewDeposit)(signer, options);
+    }
+    /**
+     * Preview the assets returned by redeeming a number of shares, without
+     * broadcasting a transaction.
+     *
+     * @returns Assets returned in raw on-chain units (asset decimals).
+     *
+     * @example
+     * ```ts
+     * const assets = await augustSdk.evm.previewRedeem({
+     *   vault: '0x...',
+     *   shares: 1_000_000_000_000_000_000n,
+     * });
+     * ```
+     */
+    async previewRedeem(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.previewRedeem)(signer, options);
+    }
+    /**
+     * Read the ERC-20 allowance an owner has granted the vault. Defaults to the
+     * vault's underlying asset; pass `asset` to override.
+     *
+     * @returns Allowance as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const raw = await augustSdk.evm.allowance({ vault, owner });
+     * ```
+     */
+    async allowance(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.allowance)(signer, options);
+    }
+    /**
+     * Read an ERC-20 token balance.
+     *
+     * @returns Balance as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const raw = await augustSdk.evm.balanceOf({ asset: usdcAddress, owner });
+     * ```
+     */
+    async balanceOf(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.balanceOf)(signer, options);
+    }
+    /**
+     * Read the maximum deposit accepted by the vault for the supplied
+     * receiver. Useful for "vault is full" gates.
+     *
+     * @returns Max deposit as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const cap = await augustSdk.evm.maxDeposit({ vault });
+     * ```
+     */
+    async maxDeposit(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.maxDeposit)(signer, options);
+    }
+}
+exports.default = EVMAdapter;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * @todo
+ */
+export declare const functionsToCallMapping: (provider: any, contract: any, functionCalls: any[]) => any[];
+/**
+ * @todo
+ */
+export declare const functionsToCallReduction: (acc: any, curr: any, i: number, functionCalls: any[], contractCalls: any[]) => any;

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/constants.d.ts

@@ -0,0 +1,33 @@
+import type { ISolanaNetwork } from '../../types';
+import { vaultIdl } from './idl/vault-idl';
+declare const fallbackDecimals = 8;
+declare const fallbackNetwork: ISolanaNetwork;
+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;
+    };
+    "mainnet-beta": {
+        vault: string;
+    };
+    localnet: {
+        vault: 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): {
+    vault: string;
+} | undefined;
+export { fallbackDecimals, fallbackNetwork, fallbackRpcEndpoints, getDeployedProgramIds, programIds, vaultIdl, };
+export type { ISolanaDeployedNetwork };

package/lib/adapters/solana/constants.js

@@ -0,0 +1,52 @@
+"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;
+// ============================================================================
+// SOLANA CONFIGURATION
+// ============================================================================
+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.
+const programIds = {
+    devnet: {
+        vault: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+    },
+    ['mainnet-beta']: {
+        vault: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+    },
+    localnet: {
+        vault: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+    },
+};
+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,11 @@
+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.
+ * @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>;