@defillama/sdk 5.0.235 → 5.0.236

package/build/chains/svm.js

@@ -0,0 +1,760 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAMPORTS_PER_SOL = exports.TOKEN_ACCOUNT_SIZE = exports.MINT_ACCOUNT_SIZE = exports.SYSVAR_RENT_ID = exports.SYSTEM_PROGRAM_ID = exports.STAKE_PROGRAM_ID = exports.ASSOCIATED_TOKEN_PROGRAM_ID = exports.TOKEN_2022_PROGRAM_ID = exports.TOKEN_PROGRAM_ID = exports.svmChains = exports.DEFAULT_ENDPOINTS = void 0;
+exports.isSvmChain = isSvmChain;
+exports.getEndpoints = getEndpoints;
+exports.getEndpoint = getEndpoint;
+exports.base58Encode = base58Encode;
+exports.base58Decode = base58Decode;
+exports.isValidPublicKey = isValidPublicKey;
+exports.readBigUInt64LE = readBigUInt64LE;
+exports.i80f48ToNumber = i80f48ToNumber;
+exports.readI80F48 = readI80F48;
+exports.decodeMintAccount = decodeMintAccount;
+exports.decodeTokenAccount = decodeTokenAccount;
+exports.readScaledUiMultiplier = readScaledUiMultiplier;
+exports.decodeStakePool = decodeStakePool;
+exports.extractPubkey = extractPubkey;
+exports.isOnCurve = isOnCurve;
+exports.usesWeb3js = usesWeb3js;
+exports.createProgramAddress = createProgramAddress;
+exports.findProgramAddress = findProgramAddress;
+exports.getAssociatedTokenAddress = getAssociatedTokenAddress;
+exports.call = call;
+exports.getSlot = getSlot;
+exports.getBlockTime = getBlockTime;
+exports.getBlockHeight = getBlockHeight;
+exports.getLatestBlock = getLatestBlock;
+exports.getEpochInfo = getEpochInfo;
+exports.getBalance = getBalance;
+exports.getBalances = getBalances;
+exports.getAccountInfo = getAccountInfo;
+exports.getAccountBuffer = getAccountBuffer;
+exports.getAccounts = getAccounts;
+exports.getAccountBuffers = getAccountBuffers;
+exports.getProgramAccounts = getProgramAccounts;
+exports.getTokenSupply = getTokenSupply;
+exports.getTokenSupplies = getTokenSupplies;
+exports.getTokenAccountBalances = getTokenAccountBalances;
+exports.getTokenAccountsByOwner = getTokenAccountsByOwner;
+exports.getTokenBalance = getTokenBalance;
+exports.getSignaturesForAddress = getSignaturesForAddress;
+exports.getTransaction = getTransaction;
+exports.getStakedSol = getStakedSol;
+exports.getSolBalanceFromStakePool = getSolBalanceFromStakePool;
+/**
+ * Solana-VM family client (solana, eclipse, soon, soon_base, soon_bsc, fogo,
+ * cookiechain, renec) over raw JSON-RPC. No hard `@solana/web3.js` dependency: base58,
+ * SPL token layouts, PDA derivation (with a real ed25519 on-curve check) and the
+ * Token-2022 ScaledUiAmount extension are implemented here. When `@solana/web3.js`
+ * is installed in the host repo (optional peer dependency) PDA derivation is
+ * delegated to it, see `usesWeb3js`.
+ *
+ * Replaces the RPC / codec parts of:
+ *   - DefiLlama-Adapters  projects/helper/solana.js (getConnection, getProvider,
+ *     getAssociatedTokenAddress, getTokenSupplies, getTokenAccountBalances,
+ *     getMultipleAccounts, getEndpoint, readBigUInt64LE, getStakedSol,
+ *     getSolBalanceFromStakePool, runInChunks, i80f48ToNumber)
+ *   - DefiLlama-Adapters  projects/helper/svmChainConfig.js (chain -> env key map)
+ *   - DefiLlama-Adapters  projects/helper/env.js (SVM `<CHAIN>_RPC` defaults)
+ *   - DefiLlama-Adapters  projects/helper/utils/solana/layout.js (mint / tokenAccount decoders)
+ *   - defillama-server    coins/src/adapters/solana/utils.ts (getTokenSupplies,
+ *     getTokenAccountBalances, getMultipleAccounts, getMultipleAccountBuffers)
+ *   - defillama-server    defi/l2/utils.ts (readScaledUiMultiplier, getSolanaTokenSupply)
+ *   - peggedassets-server src/adapters/peggedAssets/helper/solana.js (getTokenSupply, getTokenBalance)
+ *   - dimension-adapters  helpers/solana.ts (getTokenSupply, getTokenBalance)
+ *   - dimension-adapters  fees/marginfi/index.ts (readI80F48, getProgramAccounts with retry)
+ *   - dimension-adapters  fees/exponent/index.ts (extractPubkey)
+ *   - dimension-adapters  fees/neutral-trade/index.ts (b58decode, b58encode, derivePDA)
+ *   - dimension-adapters  fees/solstice-usx/index.ts (getSignaturesForAddress)
+ *   - dimension-adapters  fees/save-staked-sol/index.ts (getAccountInfo, stake pool lamports)
+ *
+ * TVL coupling (Balances / ChainApi / coingecko maps / sumTokens) is intentionally
+ * left out; every function returns raw chain values.
+ *
+ * Usage: `sdk.chains.svm.getTokenSupply({ chain: 'solana', token })`
+ */
+const crypto_1 = require("crypto");
+const env_1 = require("../util/env");
+const debugLog_1 = require("../util/debugLog");
+const rpc_1 = require("./rpc");
+// ---------------------------------------------------------------------------
+// config
+// ---------------------------------------------------------------------------
+/** Built-in endpoints, overridable with `<CHAIN>_RPC` (also `SDK_` / `LLAMA_SDK_` prefixed). */
+exports.DEFAULT_ENDPOINTS = {
+    solana: "https://api.mainnet-beta.solana.com",
+    soon: "https://rpc.mainnet.soo.network/rpc",
+    soon_base: "https://rpc.soonbase.soo.network/rpc",
+    soon_bsc: "https://rpc.svmbnbmainnet.soo.network/rpc",
+    eclipse: "https://mainnetbeta-rpc.eclipse.xyz",
+    renec: "https://api-mainnet-beta.renec.foundation:8899/",
+    fogo: "https://mainnet.fogo.io",
+    cookiechain: "https://rpc.cookiescan.io",
+};
+exports.svmChains = Object.keys(exports.DEFAULT_ENDPOINTS);
+const svmChainSet = new Set(exports.svmChains);
+function isSvmChain(chain) {
+    return svmChainSet.has(chain);
+}
+/**
+ * Endpoint list for a chain: `<CHAIN>_RPC` env wins, then `DEFAULT_ENDPOINTS`.
+ * For solana with `isClient`, `SOLANA_RPC_CLIENT` is checked first.
+ */
+function getEndpoints({ chain = 'solana', isClient = false } = {}) {
+    if (isClient && chain === 'solana') {
+        const client = (0, env_1.getEnvValue)('SOLANA_RPC_CLIENT');
+        if (client)
+            return client.split(',').map(i => i.trim()).filter(Boolean);
+    }
+    return (0, rpc_1.getEndpoints)(chain, exports.DEFAULT_ENDPOINTS[chain]);
+}
+function getEndpoint(options = {}) {
+    return getEndpoints(options)[0];
+}
+// ---------------------------------------------------------------------------
+// constants
+// ---------------------------------------------------------------------------
+exports.TOKEN_PROGRAM_ID = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
+exports.TOKEN_2022_PROGRAM_ID = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
+exports.ASSOCIATED_TOKEN_PROGRAM_ID = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL';
+exports.STAKE_PROGRAM_ID = 'Stake11111111111111111111111111111111111111';
+exports.SYSTEM_PROGRAM_ID = '11111111111111111111111111111111';
+exports.SYSVAR_RENT_ID = 'SysvarRent111111111111111111111111111111111';
+exports.MINT_ACCOUNT_SIZE = 82;
+exports.TOKEN_ACCOUNT_SIZE = 165;
+exports.LAMPORTS_PER_SOL = 1000000000;
+// ---------------------------------------------------------------------------
+// base58
+// ---------------------------------------------------------------------------
+const B58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const B58_MAP = {};
+for (let i = 0; i < B58_ALPHABET.length; i++)
+    B58_MAP[B58_ALPHABET[i]] = i;
+/** Bitcoin-style base58 (leading zero bytes become leading '1's). */
+function base58Encode(bytes) {
+    if (!bytes.length)
+        return '';
+    let zeros = 0;
+    while (zeros < bytes.length && bytes[zeros] === 0)
+        zeros++;
+    // upper bound on output length: log(256)/log(58) ~ 1.37
+    const size = Math.ceil(((bytes.length - zeros) * 138) / 100) + 1;
+    const digits = new Uint8Array(size);
+    let length = 0;
+    for (let i = zeros; i < bytes.length; i++) {
+        let carry = bytes[i];
+        let j = 0;
+        for (let k = size - 1; (carry !== 0 || j < length) && k >= 0; k--, j++) {
+            carry += 256 * digits[k];
+            digits[k] = carry % 58;
+            carry = Math.floor(carry / 58);
+        }
+        length = j;
+    }
+    let start = size - length;
+    while (start < size && digits[start] === 0)
+        start++;
+    let out = '1'.repeat(zeros);
+    for (let i = start; i < size; i++)
+        out += B58_ALPHABET[digits[i]];
+    return out;
+}
+function base58Decode(str) {
+    if (typeof str !== 'string')
+        throw new Error('base58Decode: expected string');
+    if (!str.length)
+        return new Uint8Array(0);
+    let zeros = 0;
+    while (zeros < str.length && str[zeros] === '1')
+        zeros++;
+    const size = Math.ceil(((str.length - zeros) * 733) / 1000) + 1; // log(58)/log(256) ~ 0.733
+    const bytes = new Uint8Array(size);
+    let length = 0;
+    for (let i = zeros; i < str.length; i++) {
+        let carry = B58_MAP[str[i]];
+        if (carry === undefined)
+            throw new Error(`base58Decode: invalid character "${str[i]}"`);
+        let j = 0;
+        for (let k = size - 1; (carry !== 0 || j < length) && k >= 0; k--, j++) {
+            carry += 58 * bytes[k];
+            bytes[k] = carry & 0xff;
+            carry >>= 8;
+        }
+        length = j;
+    }
+    let start = size - length;
+    while (start < size && bytes[start] === 0)
+        start++;
+    const out = new Uint8Array(zeros + (size - start));
+    out.set(bytes.subarray(start), zeros);
+    return out;
+}
+function isValidPublicKey(str) {
+    if (typeof str !== 'string' || str.length < 32 || str.length > 44)
+        return false;
+    try {
+        return base58Decode(str).length === 32;
+    }
+    catch {
+        return false;
+    }
+}
+function toPubkeyBytes(key, label = 'public key') {
+    const bytes = typeof key === 'string' ? base58Decode(key) : key;
+    if (bytes.length !== 32)
+        throw new Error(`Invalid ${label}: ${typeof key === 'string' ? key : `${bytes.length} bytes`}`);
+    return Buffer.from(bytes);
+}
+// ---------------------------------------------------------------------------
+// numeric codecs
+// ---------------------------------------------------------------------------
+/** Little-endian u64 -> bigint, works on any Uint8Array (not only Buffer). */
+function readBigUInt64LE(buffer, offset = 0) {
+    const first = buffer[offset];
+    const last = buffer[offset + 7];
+    if (first === undefined || last === undefined)
+        throw new Error(`readBigUInt64LE: out of range (offset ${offset}, length ${buffer.length})`);
+    const lo = first + buffer[offset + 1] * 2 ** 8 + buffer[offset + 2] * 2 ** 16 + buffer[offset + 3] * 2 ** 24;
+    const hi = buffer[offset + 4] + buffer[offset + 5] * 2 ** 8 + buffer[offset + 6] * 2 ** 16 + last * 2 ** 24;
+    return BigInt(lo) + (BigInt(hi) << BigInt(32));
+}
+function readU32LE(buffer, offset) {
+    return (buffer[offset] + buffer[offset + 1] * 2 ** 8 + buffer[offset + 2] * 2 ** 16 + buffer[offset + 3] * 2 ** 24) >>> 0;
+}
+const TWO_POW_48 = BigInt(2) ** BigInt(48);
+const TWO_POW_127 = BigInt(2) ** BigInt(127);
+const TWO_POW_128 = BigInt(2) ** BigInt(128);
+const MASK_48 = TWO_POW_48 - BigInt(1);
+/**
+ * Fixed point I80F48 (signed i128, 48 fractional bits) -> number.
+ * Accepts a bigint / decimal string, `{ val }` / `{ value }` wrappers (anchor BN
+ * style) or the 16 little-endian bytes of the raw i128.
+ */
+function i80f48ToNumber(i80f48) {
+    var _a;
+    let raw = i80f48;
+    if (raw && typeof raw === 'object' && !Array.isArray(raw) && !(raw instanceof Uint8Array))
+        raw = (_a = raw.val) !== null && _a !== void 0 ? _a : raw.value;
+    let value;
+    if (Array.isArray(raw) || raw instanceof Uint8Array) {
+        if (raw.length !== 16)
+            throw new Error(`i80f48ToNumber: expected 16 bytes, got ${raw.length}`);
+        value = BigInt(0);
+        for (let i = 15; i >= 0; i--)
+            value = (value << BigInt(8)) + BigInt(raw[i]);
+        if (value >= TWO_POW_127)
+            value -= TWO_POW_128;
+    }
+    else if (typeof raw === 'bigint') {
+        value = raw;
+    }
+    else if (typeof raw === 'string' || typeof raw === 'number') {
+        value = BigInt(raw);
+    }
+    else if (raw && typeof raw.toString === 'function') {
+        value = BigInt(raw.toString());
+    }
+    else {
+        throw new Error('i80f48ToNumber: unsupported input');
+    }
+    const integerPart = value >> BigInt(48);
+    const fractionalPart = value & MASK_48;
+    return Number(integerPart) + Number(fractionalPart) / Number(TWO_POW_48);
+}
+/** Little-endian I80F48 at `offset` (marginfi WrappedI80F48). */
+function readI80F48(buf, offset) {
+    return i80f48ToNumber(buf.subarray(offset, offset + 16));
+}
+/** Decode an SPL / Token-2022 mint account (first 82 bytes; extensions are ignored). */
+function decodeMintAccount(buf) {
+    var _a;
+    if (!buf || buf.length < exports.MINT_ACCOUNT_SIZE)
+        throw new Error(`decodeMintAccount: need ${exports.MINT_ACCOUNT_SIZE} bytes, got ${(_a = buf === null || buf === void 0 ? void 0 : buf.length) !== null && _a !== void 0 ? _a : 0}`);
+    const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+    return {
+        mintAuthority: readU32LE(b, 0) ? base58Encode(b.subarray(4, 36)) : null,
+        supply: readBigUInt64LE(b, 36).toString(),
+        decimals: b[44],
+        isInitialized: b[45] !== 0,
+        freezeAuthority: readU32LE(b, 46) ? base58Encode(b.subarray(50, 82)) : null,
+    };
+}
+/** Decode an SPL / Token-2022 token account (first 165 bytes; extensions are ignored). */
+function decodeTokenAccount(buf) {
+    var _a;
+    if (!buf || buf.length < exports.TOKEN_ACCOUNT_SIZE)
+        throw new Error(`decodeTokenAccount: need ${exports.TOKEN_ACCOUNT_SIZE} bytes, got ${(_a = buf === null || buf === void 0 ? void 0 : buf.length) !== null && _a !== void 0 ? _a : 0}`);
+    const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+    return {
+        mint: base58Encode(b.subarray(0, 32)),
+        owner: base58Encode(b.subarray(32, 64)),
+        amount: readBigUInt64LE(b, 64).toString(),
+        delegate: readU32LE(b, 72) ? base58Encode(b.subarray(76, 108)) : null,
+        state: b[108],
+        isNative: readU32LE(b, 109) ? readBigUInt64LE(b, 113).toString() : null,
+        delegatedAmount: readBigUInt64LE(b, 121).toString(),
+        closeAuthority: readU32LE(b, 129) ? base58Encode(b.subarray(133, 165)) : null,
+    };
+}
+// Token-2022 ExtensionType::ScaledUiAmountConfig (=25): displayed balance = raw x multiplier.
+// A mint is padded to the 165-byte Account length; account_type sits at 165 and the TLV
+// extension list begins at 166.
+const T22_TLV_START = 166;
+const EXT_SCALED_UI_AMOUNT = 25;
+/**
+ * Currently-effective UI multiplier of a Token-2022 mint with the ScaledUiAmount
+ * extension, or 1 for a classic SPL mint / a mint without this extension.
+ */
+function readScaledUiMultiplier(data, nowSeconds = Math.floor(Date.now() / 1000)) {
+    if (!data || data.length <= exports.TOKEN_ACCOUNT_SIZE)
+        return 1;
+    let off = T22_TLV_START;
+    while (off + 4 <= data.length) {
+        const extType = data.readUInt16LE(off);
+        const len = data.readUInt16LE(off + 2);
+        const dataStart = off + 4;
+        if (extType === EXT_SCALED_UI_AMOUNT && dataStart + 56 <= data.length) {
+            // authority(32) multiplier:f64(8) newMultiplierEffectiveTimestamp:i64(8) newMultiplier:f64(8)
+            const p = dataStart + 32;
+            const multiplier = data.readDoubleLE(p);
+            const effectiveTs = Number(data.readBigInt64LE(p + 8));
+            const newMultiplier = data.readDoubleLE(p + 16);
+            const m = nowSeconds >= effectiveTs ? newMultiplier : multiplier;
+            return Number.isFinite(m) && m > 0 ? m : 1; // never zero/NaN out a real supply
+        }
+        if (extType === 0 && len === 0)
+            break; // uninitialized padding
+        off = dataStart + len;
+    }
+    return 1;
+}
+/** SPL stake pool: `total_lamports` u64 at offset 258, `pool_token_supply` u64 at 266. */
+function decodeStakePool(buf) {
+    var _a;
+    if (!buf || buf.length < 274)
+        throw new Error(`decodeStakePool: need 274 bytes, got ${(_a = buf === null || buf === void 0 ? void 0 : buf.length) !== null && _a !== void 0 ? _a : 0}`);
+    return {
+        totalLamports: readBigUInt64LE(buf, 258).toString(),
+        poolTokenSupply: readBigUInt64LE(buf, 266).toString(),
+    };
+}
+/** Read the 32-byte pubkey at `offset` of a base64 encoded account payload. */
+function extractPubkey(base64Data, offset) {
+    const buffer = Buffer.from(base64Data, 'base64');
+    if (buffer.length < offset + 32)
+        throw new Error(`extractPubkey: offset ${offset} out of range (length ${buffer.length})`);
+    return base58Encode(buffer.subarray(offset, offset + 32));
+}
+// ---------------------------------------------------------------------------
+// ed25519 / PDA derivation
+// ---------------------------------------------------------------------------
+const P = (BigInt(1) << BigInt(255)) - BigInt(19);
+const ONE = BigInt(1);
+const ZERO = BigInt(0);
+function mod(a, m = P) {
+    const r = a % m;
+    return r < ZERO ? r + m : r;
+}
+function modPow(base, exp, m = P) {
+    let result = ONE;
+    base = mod(base, m);
+    while (exp > ZERO) {
+        if (exp & ONE)
+            result = (result * base) % m;
+        base = (base * base) % m;
+        exp >>= ONE;
+    }
+    return result;
+}
+function modInv(a, m = P) {
+    // p is prime: a^(p-2)
+    return modPow(a, m - BigInt(2), m);
+}
+// d = -121665 / 121666 mod p
+const ED25519_D = mod(-BigInt(121665) * modInv(BigInt(121666)));
+const LEGENDRE_EXP = (P - ONE) / BigInt(2);
+/**
+ * True when the 32 bytes decompress to a point on the ed25519 curve
+ * (curve25519-dalek `CompressedEdwardsY::decompress` semantics). A PDA must be
+ * off-curve so it can never have a private key.
+ */
+function isOnCurve(pubkey) {
+    const bytes = toPubkeyBytes(pubkey);
+    let y = ZERO;
+    for (let i = 31; i >= 0; i--)
+        y = (y << BigInt(8)) + BigInt(bytes[i]);
+    y &= (ONE << BigInt(255)) - ONE; // drop the sign bit
+    y = mod(y);
+    const y2 = (y * y) % P;
+    const u = mod(y2 - ONE); // y^2 - 1
+    const v = mod(ED25519_D * y2 + ONE); // d*y^2 + 1
+    // x^2 = u / v ; sqrt_ratio_i: valid when u == 0, invalid when v == 0 (u != 0),
+    // otherwise valid iff u/v is a quadratic residue
+    if (u === ZERO)
+        return true;
+    if (v === ZERO)
+        return false;
+    const x2 = (u * modInv(v)) % P;
+    return modPow(x2, LEGENDRE_EXP) === ONE;
+}
+const PDA_MARKER = Buffer.from('ProgramDerivedAddress');
+const MAX_SEED_LENGTH = 32;
+const MAX_SEEDS = 16;
+/**
+ * `@solana/web3.js` is an optional peer dependency: when the host repo has it
+ * installed (DefiLlama-Adapters, server/coins) PDA derivation is delegated to
+ * `PublicKey.createProgramAddressSync` / `findProgramAddressSync`, and the
+ * hand-rolled ed25519 check above is only the fallback for repos without it.
+ * Set `SVM_DISABLE_WEB3JS=true` to force the built-in implementation.
+ */
+let web3js;
+function loadWeb3js() {
+    var _a;
+    if (web3js !== undefined)
+        return web3js;
+    if ((0, env_1.getEnvValue)('SVM_DISABLE_WEB3JS') === 'true')
+        return (web3js = null);
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        web3js = require('@solana/web3.js');
+        if (typeof ((_a = web3js === null || web3js === void 0 ? void 0 : web3js.PublicKey) === null || _a === void 0 ? void 0 : _a.findProgramAddressSync) !== 'function')
+            web3js = null;
+    }
+    catch {
+        web3js = null;
+    }
+    return web3js;
+}
+/** True when PDA derivation is delegated to an installed `@solana/web3.js`. */
+function usesWeb3js() {
+    return !!loadWeb3js();
+}
+function toSeedBuffer(seed) {
+    const buf = typeof seed === 'string' ? Buffer.from(seed, 'utf8') : Buffer.from(seed);
+    if (buf.length > MAX_SEED_LENGTH)
+        throw new Error(`Max seed length exceeded (${buf.length} > ${MAX_SEED_LENGTH})`);
+    return buf;
+}
+/** sha256(seeds || programId || "ProgramDerivedAddress"); throws when the result is on-curve. */
+function createProgramAddress(seeds, programId, bump) {
+    if (seeds.length > MAX_SEEDS)
+        throw new Error(`Max seeds exceeded (${seeds.length} > ${MAX_SEEDS})`);
+    const web3 = loadWeb3js();
+    if (web3) {
+        const allSeeds = seeds.map(toSeedBuffer);
+        if (bump !== undefined)
+            allSeeds.push(Buffer.from([bump]));
+        return web3.PublicKey.createProgramAddressSync(allSeeds, new web3.PublicKey(programId)).toBase58();
+    }
+    const hash = (0, crypto_1.createHash)('sha256');
+    for (const seed of seeds)
+        hash.update(toSeedBuffer(seed));
+    if (bump !== undefined) {
+        if (!Number.isInteger(bump) || bump < 0 || bump > 255)
+            throw new Error(`Invalid bump seed: ${bump}`);
+        hash.update(Buffer.from([bump]));
+    }
+    hash.update(toPubkeyBytes(programId, 'program id'));
+    hash.update(PDA_MARKER);
+    const digest = hash.digest();
+    if (isOnCurve(digest))
+        throw new Error('Invalid seeds, address must fall off the curve');
+    return base58Encode(digest);
+}
+/** Find the first off-curve address for `seeds`, walking bump 255 -> 0. */
+function findProgramAddress(seeds, programId) {
+    const web3 = loadWeb3js();
+    if (web3) {
+        const [address, bump] = web3.PublicKey.findProgramAddressSync(seeds.map(toSeedBuffer), new web3.PublicKey(programId));
+        return [address.toBase58(), bump];
+    }
+    for (let bump = 255; bump >= 0; bump--) {
+        try {
+            return [createProgramAddress(seeds, programId, bump), bump];
+        }
+        catch (e) {
+            if (!String(e === null || e === void 0 ? void 0 : e.message).includes('off the curve'))
+                throw e;
+        }
+    }
+    throw new Error('Unable to find a viable program address nonce');
+}
+function getAssociatedTokenAddress({ mint, owner, programId = exports.TOKEN_PROGRAM_ID, associatedTokenProgramId = exports.ASSOCIATED_TOKEN_PROGRAM_ID }) {
+    const [address] = findProgramAddress([
+        toPubkeyBytes(owner, 'owner'),
+        toPubkeyBytes(programId, 'program id'),
+        toPubkeyBytes(mint, 'mint'),
+    ], associatedTokenProgramId);
+    return address;
+}
+const DEFAULT_CONCURRENCY = 10;
+function limiterFor(chain) {
+    return (0, rpc_1.getLimiter)(chain.toUpperCase(), DEFAULT_CONCURRENCY);
+}
+/** Raw JSON-RPC call against the chain's endpoints (rate limited per chain, retried). */
+async function call({ chain = 'solana', method, params = [], commitment, timeout, retries }) {
+    const endpoints = getEndpoints({ chain, isClient: true });
+    if (commitment)
+        params = withCommitment(params, commitment);
+    return limiterFor(chain)(() => (0, rpc_1.jsonRpc)(method, params, { chain, endpoints, timeout, retries }));
+}
+function withCommitment(params, commitment) {
+    const last = params[params.length - 1];
+    if (last && typeof last === 'object' && !Array.isArray(last))
+        return [...params.slice(0, -1), { ...last, commitment }];
+    return [...params, { commitment }];
+}
+async function getSlot({ chain = 'solana', commitment } = {}) {
+    return call({ chain, method: 'getSlot', params: [], commitment });
+}
+async function getBlockTime({ chain = 'solana', slot }) {
+    const res = await call({ chain, method: 'getBlockTime', params: [slot] });
+    return res === null || res === undefined ? null : Number(res);
+}
+async function getBlockHeight({ chain = 'solana', commitment } = {}) {
+    return call({ chain, method: 'getBlockHeight', params: [], commitment });
+}
+/** Latest slot and its block time (walks back over skipped slots without a time). */
+async function getLatestBlock({ chain = 'solana', commitment } = {}) {
+    let slot = await getSlot({ chain, commitment });
+    for (let i = 0; i < 10; i++) {
+        const timestamp = await getBlockTime({ chain, slot }).catch((e) => {
+            (0, debugLog_1.debugLog)(`[chains.svm] ${chain} getBlockTime(${slot}) failed: ${e === null || e === void 0 ? void 0 : e.message}`);
+            return null;
+        });
+        if (timestamp)
+            return { number: slot, timestamp };
+        slot--;
+    }
+    throw new Error(`[chains.svm] ${chain}: unable to resolve block time for the latest slots`);
+}
+async function getEpochInfo({ chain = 'solana', commitment } = {}) {
+    return call({ chain, method: 'getEpochInfo', params: [], commitment });
+}
+/** Lamport balance of a single account. */
+async function getBalance({ chain = 'solana', account, commitment }) {
+    var _a;
+    const res = await call({ chain, method: 'getBalance', params: [account], commitment });
+    return Number((_a = res === null || res === void 0 ? void 0 : res.value) !== null && _a !== void 0 ? _a : 0);
+}
+/** Lamport balances of many accounts (batched `getMultipleAccounts`, 0 for missing accounts). */
+async function getBalances({ chain = 'solana', accounts, commitment }) {
+    const infos = await getAccounts({ chain, accounts, commitment, dataSlice: { offset: 0, length: 0 } });
+    return infos.map(i => i ? Number(i.lamports) : 0);
+}
+async function getAccountInfo({ chain = 'solana', account, encoding = 'base64', commitment, dataSlice }) {
+    var _a;
+    const config = { encoding };
+    if (dataSlice)
+        config.dataSlice = dataSlice;
+    const res = await call({ chain, method: 'getAccountInfo', params: [account, config], commitment });
+    return (_a = res === null || res === void 0 ? void 0 : res.value) !== null && _a !== void 0 ? _a : null;
+}
+/** Base64 payload of one account as a Buffer, or null when it does not exist. */
+async function getAccountBuffer({ chain = 'solana', account, commitment }) {
+    const info = await getAccountInfo({ chain, account, encoding: 'base64', commitment });
+    return accountDataToBuffer(info);
+}
+/** Batched `getMultipleAccounts`; result is in input order with `null` for missing accounts. */
+async function getAccounts({ chain = 'solana', accounts, encoding = 'base64', commitment, dataSlice, chunkSize = 99, concurrency = 5, sleepTime = 0 }) {
+    if (!accounts.length)
+        return [];
+    const config = { encoding };
+    if (dataSlice)
+        config.dataSlice = dataSlice;
+    (0, debugLog_1.debugLog)(`[chains.svm] ${chain} getAccounts: ${accounts.length} accounts in chunks of ${chunkSize}`);
+    return (0, rpc_1.runInChunks)(accounts, async (chunk) => {
+        var _a;
+        const res = await call({ chain, method: 'getMultipleAccounts', params: [chunk, config], commitment });
+        const value = (_a = res === null || res === void 0 ? void 0 : res.value) !== null && _a !== void 0 ? _a : [];
+        if (value.length !== chunk.length)
+            throw new Error(`[chains.svm] ${chain} getMultipleAccounts returned ${value.length} entries for ${chunk.length} accounts`);
+        return value;
+    }, { chunkSize, concurrency, sleepTime });
+}
+function accountDataToBuffer(info) {
+    if (!info)
+        return null;
+    const data = info.data;
+    if (Array.isArray(data))
+        return data[1] === 'base58' ? Buffer.from(base58Decode(data[0])) : Buffer.from(data[0], 'base64');
+    if (typeof data === 'string')
+        return Buffer.from(data, 'base64');
+    return null;
+}
+/** Raw account payloads as Buffers, in input order (`null` for missing accounts). */
+async function getAccountBuffers(options) {
+    const infos = await getAccounts({ ...options, encoding: 'base64' });
+    return infos.map(accountDataToBuffer);
+}
+async function getProgramAccounts({ chain = 'solana', programId, filters, encoding = 'base64', dataSlice, commitment, withContext, retries = 5, timeout = 120000 }) {
+    const config = { encoding };
+    if (filters === null || filters === void 0 ? void 0 : filters.length)
+        config.filters = filters;
+    if (dataSlice)
+        config.dataSlice = dataSlice;
+    if (withContext)
+        config.withContext = true;
+    const res = await call({ chain, method: 'getProgramAccounts', params: [programId, config], commitment, retries, timeout });
+    if (withContext)
+        return res;
+    if (!Array.isArray(res))
+        throw new Error(`[chains.svm] ${chain} getProgramAccounts(${programId}) returned no array`);
+    return res;
+}
+async function getTokenSupply({ chain = 'solana', token, commitment }) {
+    var _a, _b;
+    const res = await call({ chain, method: 'getTokenSupply', params: [token], commitment });
+    const value = res === null || res === void 0 ? void 0 : res.value;
+    if (!value)
+        throw new Error(`[chains.svm] ${chain} getTokenSupply(${token}): empty result`);
+    return { amount: String(value.amount), decimals: Number(value.decimals), uiAmount: Number((_b = (_a = value.uiAmount) !== null && _a !== void 0 ? _a : value.uiAmountString) !== null && _b !== void 0 ? _b : 0), uiAmountString: value.uiAmountString };
+}
+function supplyFromMint(mint) {
+    const uiAmount = Number(mint.supply) / 10 ** mint.decimals;
+    return { amount: mint.supply, decimals: mint.decimals, uiAmount, uiAmountString: String(uiAmount) };
+}
+async function getTokenSupplies({ chain = 'solana', tokens, commitment, chunkSize, concurrency, sleepTime, allowError = false }) {
+    if (!tokens.length)
+        return [];
+    const buffers = await getAccountBuffers({ chain, accounts: tokens, commitment, chunkSize, concurrency, sleepTime });
+    return Promise.all(buffers.map(async (buf, i) => {
+        if (buf) {
+            try {
+                return supplyFromMint(decodeMintAccount(buf));
+            }
+            catch (e) {
+                (0, debugLog_1.debugLog)(`[chains.svm] ${chain} mint ${tokens[i]} failed to decode (${e === null || e === void 0 ? void 0 : e.message}), falling back to getTokenSupply`);
+            }
+        }
+        else {
+            (0, debugLog_1.debugLog)(`[chains.svm] ${chain} mint ${tokens[i]}: account not found, falling back to getTokenSupply`);
+        }
+        try {
+            return await getTokenSupply({ chain, token: tokens[i], commitment });
+        }
+        catch (e) {
+            if (allowError)
+                return null;
+            throw e;
+        }
+    }));
+}
+async function getTokenAccountBalances({ chain = 'solana', tokenAccounts, individual = false, allowError = false, withDecimals = false, commitment, chunkSize, concurrency, sleepTime }) {
+    const buffers = tokenAccounts.length ? await getAccountBuffers({ chain, accounts: tokenAccounts, commitment, chunkSize, concurrency, sleepTime }) : [];
+    const individualBalances = [];
+    const balances = {};
+    buffers.forEach((buf, i) => {
+        var _a;
+        const account = tokenAccounts[i];
+        let decoded;
+        try {
+            if (!buf)
+                throw new Error('account not found');
+            decoded = decodeTokenAccount(buf);
+        }
+        catch (e) {
+            (0, debugLog_1.debugLog)(`[chains.svm] ${chain} token account ${account}: ${e === null || e === void 0 ? void 0 : e.message}`);
+            if (!allowError)
+                throw new Error(`[chains.svm] ${chain} invalid token account ${account}: ${e === null || e === void 0 ? void 0 : e.message}`);
+            if (individual)
+                individualBalances.push({ mint: 'error', amount: '0', owner: '' });
+            return;
+        }
+        if (individual)
+            individualBalances.push({ mint: decoded.mint, amount: decoded.amount, owner: decoded.owner });
+        else
+            balances[decoded.mint] = ((_a = balances[decoded.mint]) !== null && _a !== void 0 ? _a : BigInt(0)) + BigInt(decoded.amount);
+    });
+    if (!individual) {
+        const res = {};
+        for (const mint of Object.keys(balances))
+            res[mint] = balances[mint].toString();
+        return res;
+    }
+    if (withDecimals) {
+        const mints = [...new Set(individualBalances.map(i => i.mint).filter(i => i !== 'error'))];
+        const supplies = await getTokenSupplies({ chain, tokens: mints, commitment, allowError: true });
+        const decimals = {};
+        mints.forEach((mint, i) => { if (supplies[i])
+            decimals[mint] = supplies[i].decimals; });
+        individualBalances.forEach(i => { if (decimals[i.mint] !== undefined)
+            i.decimals = decimals[i.mint]; });
+    }
+    return individualBalances;
+}
+/**
+ * Token accounts of `owner` (jsonParsed). With neither `mint` nor `programId`,
+ * both the Token and Token-2022 programs are queried.
+ */
+async function getTokenAccountsByOwner({ chain = 'solana', owner, mint, programId, commitment }) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const filters = [];
+    if (mint)
+        filters.push({ mint });
+    else if (programId)
+        filters.push({ programId });
+    else
+        filters.push({ programId: exports.TOKEN_PROGRAM_ID }, { programId: exports.TOKEN_2022_PROGRAM_ID });
+    const results = await Promise.all(filters.map(filter => call({ chain, method: 'getTokenAccountsByOwner', params: [owner, filter, { encoding: 'jsonParsed' }], commitment })));
+    const out = [];
+    for (const res of results) {
+        for (const entry of (_a = res === null || res === void 0 ? void 0 : res.value) !== null && _a !== void 0 ? _a : []) {
+            const info = (_d = (_c = (_b = entry === null || entry === void 0 ? void 0 : entry.account) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.parsed) === null || _d === void 0 ? void 0 : _d.info;
+            if (!info)
+                continue;
+            out.push({
+                pubkey: entry.pubkey,
+                mint: info.mint,
+                owner: info.owner,
+                amount: String((_f = (_e = info.tokenAmount) === null || _e === void 0 ? void 0 : _e.amount) !== null && _f !== void 0 ? _f : '0'),
+                decimals: Number((_h = (_g = info.tokenAmount) === null || _g === void 0 ? void 0 : _g.decimals) !== null && _h !== void 0 ? _h : 0),
+                uiAmount: Number((_k = (_j = info.tokenAmount) === null || _j === void 0 ? void 0 : _j.uiAmount) !== null && _k !== void 0 ? _k : 0),
+                programId: entry.account.owner,
+                state: info.state,
+            });
+        }
+    }
+    return out;
+}
+/** Raw token amount (string) of `mint` held by `owner`, summed over all of the owner's token accounts. */
+async function getTokenBalance({ chain = 'solana', owner, mint, commitment }) {
+    const accounts = await getTokenAccountsByOwner({ chain, owner, mint, commitment });
+    return accounts.reduce((sum, i) => sum + BigInt(i.amount), BigInt(0)).toString();
+}
+async function getSignaturesForAddress({ chain = 'solana', address, before, until, limit = 1000, commitment }) {
+    const config = { limit };
+    if (before)
+        config.before = before;
+    if (until)
+        config.until = until;
+    const res = await call({ chain, method: 'getSignaturesForAddress', params: [address, config], commitment });
+    return Array.isArray(res) ? res : [];
+}
+async function getTransaction({ chain = 'solana', signature, encoding = 'json', maxSupportedTransactionVersion = 0, commitment }) {
+    return call({ chain, method: 'getTransaction', params: [signature, { encoding, maxSupportedTransactionVersion }], commitment });
+}
+/**
+ * Lamports in all stake accounts whose stake authority (default, as in the
+ * adapters helper) or withdraw authority is `address`.
+ */
+async function getStakedSol({ chain = 'solana', address, authority = 'staker', commitment }) {
+    // StakeStateV2: u32 enum tag, then Meta { rent_exempt_reserve: u64, authorized: { staker: Pubkey, withdrawer: Pubkey }, .. }
+    const offset = authority === 'withdrawer' ? 4 + 8 + 32 : 4 + 8;
+    const stakeAccounts = await getProgramAccounts({
+        chain,
+        programId: exports.STAKE_PROGRAM_ID,
+        filters: [{ memcmp: { offset, bytes: address } }],
+        dataSlice: { offset: 0, length: 1 }, // only lamports are needed
+        commitment,
+    });
+    return stakeAccounts.reduce((total, { account }) => total + Number(account.lamports), 0);
+}
+/** `total_lamports` of an SPL stake pool account (lamports, as number). */
+async function getSolBalanceFromStakePool({ chain = 'solana', address, commitment }) {
+    const buf = await getAccountBuffer({ chain, account: address, commitment });
+    if (!buf)
+        throw new Error(`[chains.svm] ${chain} stake pool ${address} not found`);
+    return Number(decodeStakePool(buf).totalLamports);
+}