@defillama/sdk 5.0.235 → 5.0.236

package/build/chains/ton.js

@@ -0,0 +1,788 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitReader = exports.Address = exports.MASTERCHAIN_SHARD = exports.DEFAULT_ENDPOINTS = void 0;
+exports.getToncenterEndpoints = getToncenterEndpoints;
+exports.getToncenterEndpoint = getToncenterEndpoint;
+exports.getTonapiEndpoints = getTonapiEndpoints;
+exports.getTonapiEndpoint = getTonapiEndpoint;
+exports.toncenterGet = toncenterGet;
+exports.toncenterPost = toncenterPost;
+exports.getAccountState = getAccountState;
+exports.getTonBalance = getTonBalance;
+exports.getJettonMaster = getJettonMaster;
+exports.getJettonSupply = getJettonSupply;
+exports.getJettonWallets = getJettonWallets;
+exports.getJettonWalletBalance = getJettonWalletBalance;
+exports.runGetMethod = runGetMethod;
+exports.decodeStackItem = decodeStackItem;
+exports.call = call;
+exports.getTransactions = getTransactions;
+exports.getMessages = getMessages;
+exports.getMasterchainInfo = getMasterchainInfo;
+exports.lookupBlock = lookupBlock;
+exports.getBlockAtTimestamp = getBlockAtTimestamp;
+exports.getLatestBlock = getLatestBlock;
+exports.tonapiGet = tonapiGet;
+exports.tonapiPost = tonapiPost;
+exports.getJettonBalances = getJettonBalances;
+exports.jettonBalancesByAddress = jettonBalancesByAddress;
+exports.getJettonInfo = getJettonInfo;
+exports.getJettonsInfo = getJettonsInfo;
+exports.getTokenRates = getTokenRates;
+exports.crc16 = crc16;
+exports.parseAddress = parseAddress;
+exports.normalizeAddress = normalizeAddress;
+exports.toRawAddress = toRawAddress;
+exports.isAddress = isAddress;
+exports.addressToInt = addressToInt;
+exports.convertIntToAddress = convertIntToAddress;
+exports.compareAddress = compareAddress;
+exports.decodeBase64 = decodeBase64;
+exports.parseBoc = parseBoc;
+exports.serializeAddress = serializeAddress;
+exports.readAddressFromSlice = readAddressFromSlice;
+exports.tryReadAddressFromSlice = tryReadAddressFromSlice;
+/**
+ * TON client: toncenter (v2 + v3), tonapi, and a dependency-free address / BoC codec.
+ *
+ * Replaces the TON glue scattered across the DefiLlama repos:
+ * - DefiLlama-Adapters `projects/helper/chain/ton.js` (getTonBalance, getJettonBalances,
+ *   getTokenRates, getJettonsInfo, call/runGetMethod, processTVMSliceReadAddress, parseBoc,
+ *   BitReader, serializeAddress, computeCRC16) — the TVL parts (sumTokens, addJettonBalances,
+ *   addTonBalances) are intentionally not ported.
+ * - DefiLlama-Adapters `projects/helper/chain/utils/ton-address.js` (addressToInt,
+ *   convertIntToAddress, compareAddress)
+ * - DefiLlama-Adapters `projects/helper/utils/ton.js` and defillama-server
+ *   `coins/src/utils/ton.ts` (ton-core `Address` + crc16)
+ * - defillama-server `coins/src/adapters/other/ton.ts` (runGetMethod stack decoding) and
+ *   `coins/src/scripts/coingeckoUtils.ts` (jetton symbol / decimals lookup)
+ * - peggedassets-server `helper/getSupply.ts` tonTokenSupply (v3 jetton/masters)
+ * - dimension-adapters `fees/sTONks`, `fees/hipo` (v3 /transactions and /messages window
+ *   pagination) and `helpers/getBlock.ts` getTonBlock (v2 lookupBlock)
+ *
+ * Endpoints: `TON_RPC` (toncenter base, default https://toncenter.com) and `TON_API_RPC`
+ * (tonapi base, default https://tonapi.io). Keys: `TONCENTER_API_KEY` (sent as `X-API-Key`)
+ * and `TON_API_KEY` (tonapi bearer token). Unauthenticated toncenter / tonapi allow about one
+ * request per second, so every call goes through a per-service limiter that spaces requests
+ * (`TON_RPC_MIN_INTERVAL_MS` / `TONAPI_RPC_MIN_INTERVAL_MS` override the spacing,
+ * `TON_RPC_CONCURRENCY` / `TONAPI_RPC_CONCURRENCY` the concurrency).
+ */
+const env_1 = require("../util/env");
+const debugLog_1 = require("../util/debugLog");
+const rpc_1 = require("./rpc");
+// ---------------------------------------------------------------------------
+// config
+// ---------------------------------------------------------------------------
+exports.DEFAULT_ENDPOINTS = {
+    toncenter: 'https://toncenter.com',
+    tonapi: 'https://tonapi.io',
+};
+/** All configured toncenter base urls (`TON_RPC`, comma separated) */
+function getToncenterEndpoints() {
+    return (0, rpc_1.getEndpoints)('ton', exports.DEFAULT_ENDPOINTS.toncenter);
+}
+function getToncenterEndpoint() {
+    return getToncenterEndpoints()[0];
+}
+/** All configured tonapi base urls (`TON_API_RPC`, comma separated) */
+function getTonapiEndpoints() {
+    return (0, rpc_1.getEndpoints)('ton', exports.DEFAULT_ENDPOINTS.tonapi, { envKey: 'TON_API_RPC' });
+}
+function getTonapiEndpoint() {
+    return getTonapiEndpoints()[0];
+}
+function getToncenterApiKey() {
+    return (0, env_1.getEnvValue)('TONCENTER_API_KEY');
+}
+function getTonapiKey() {
+    return (0, env_1.getEnvValue)('TON_API_KEY');
+}
+function toncenterHeaders() {
+    const key = getToncenterApiKey();
+    return key ? { 'X-API-Key': key } : {};
+}
+function tonapiHeaders() {
+    const key = getTonapiKey();
+    if (!key)
+        return {};
+    // the adapters repo stores the key with the scheme already included ("Bearer xxx"), accept both forms
+    return { Authorization: /^bearer /i.test(key) ? key : `Bearer ${key}` };
+}
+// ---------------------------------------------------------------------------
+// rate limiting
+// ---------------------------------------------------------------------------
+const lastRequestAt = {};
+/**
+ * Serialise requests per service and keep at least `minIntervalMs` between them. Without an
+ * API key both toncenter and tonapi allow roughly one request per second; with a key the
+ * spacing is dropped and the limiter allows a few parallel requests.
+ */
+async function paced(service, fn) {
+    const hasKey = service === 'TON' ? !!getToncenterApiKey() : !!getTonapiKey();
+    const envInterval = (0, env_1.getEnvValue)(`${service}_RPC_MIN_INTERVAL_MS`);
+    const minIntervalMs = envInterval !== undefined ? +envInterval : hasKey ? 0 : 1100;
+    const limiter = (0, rpc_1.getLimiter)(service, hasKey ? 5 : 1);
+    return limiter(async () => {
+        var _a;
+        const wait = ((_a = lastRequestAt[service]) !== null && _a !== void 0 ? _a : 0) + minIntervalMs - Date.now();
+        if (wait > 0)
+            await (0, rpc_1.sleep)(wait);
+        try {
+            return await fn();
+        }
+        finally {
+            lastRequestAt[service] = Date.now();
+        }
+    });
+}
+// 429s from toncenter need a longer pause than the transport default
+const TONCENTER_RETRY = { retries: 4, delay: 1500, maxDelay: 8000 };
+const TONAPI_RETRY = { retries: 3, delay: 1500, maxDelay: 8000 };
+function toncenterPath(path, version) {
+    return `/api/v${version}/${path.replace(/^\/+/, '')}`;
+}
+function dropUndefined(params = {}) {
+    const res = {};
+    Object.keys(params).forEach(k => { if (params[k] !== undefined && params[k] !== null)
+        res[k] = params[k]; });
+    return res;
+}
+/** toncenter v2 wraps everything in `{ ok, result, error }`; unwrap and surface errors */
+function unwrapV2(res, label) {
+    var _a, _b;
+    if (res && typeof res === 'object' && 'ok' in res) {
+        if (!res.ok)
+            throw new Error(`toncenter ${label} failed: ${(_b = (_a = res.error) !== null && _a !== void 0 ? _a : res.result) !== null && _b !== void 0 ? _b : 'unknown error'}${res.code !== undefined ? ` (code ${res.code})` : ''}`);
+        return res.result;
+    }
+    return res;
+}
+/** GET `/api/v{version}/{path}` on toncenter. Returns the raw response body (v2 bodies are `{ok, result}`). */
+async function toncenterGet({ path, params, version = 3 }) {
+    return paced('TON', () => (0, rpc_1.httpGet)(getToncenterEndpoints(), {
+        path: toncenterPath(path, version),
+        params: dropUndefined(params),
+        headers: toncenterHeaders(),
+        ...TONCENTER_RETRY,
+    }));
+}
+/** POST to `/api/v{version}/{path}` on toncenter. Returns the raw response body. */
+async function toncenterPost({ path, body = {}, version = 2 }) {
+    return paced('TON', () => (0, rpc_1.httpPost)(getToncenterEndpoints(), body, {
+        path: toncenterPath(path, version),
+        headers: toncenterHeaders(),
+        ...TONCENTER_RETRY,
+    }));
+}
+// ---------------------------------------------------------------------------
+// toncenter: accounts & jettons
+// ---------------------------------------------------------------------------
+/** Full v3 account state: `{ balance, status, code, data, last_transaction_lt, last_transaction_hash, frozen_hash }` */
+async function getAccountState({ address }) {
+    return toncenterGet({ path: 'account', params: { address } });
+}
+/** TON balance in nanoton, as a decimal string */
+async function getTonBalance({ address }) {
+    const res = await getAccountState({ address });
+    if ((res === null || res === void 0 ? void 0 : res.balance) === undefined || (res === null || res === void 0 ? void 0 : res.balance) === null)
+        throw new Error(`toncenter account: no balance for ${address}`);
+    return String(res.balance);
+}
+/** v3 `jetton/masters` entry for one jetton. Throws when the address is not a jetton master. */
+async function getJettonMaster({ address }) {
+    var _a;
+    const res = await toncenterGet({ path: 'jetton/masters', params: { address, limit: 1, offset: 0 } });
+    const master = (_a = res === null || res === void 0 ? void 0 : res.jetton_masters) === null || _a === void 0 ? void 0 : _a[0];
+    if (!master)
+        throw new Error(`toncenter jetton/masters: ${address} is not a known jetton master`);
+    return master;
+}
+function parseDecimals(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : undefined;
+}
+/** `{ supply, decimals }` of a jetton from its v3 master record. `decimals` is undefined when the content is off-chain. */
+async function getJettonSupply({ address }) {
+    var _a;
+    const master = await getJettonMaster({ address });
+    return { supply: String(master.total_supply), decimals: parseDecimals((_a = master.jetton_content) === null || _a === void 0 ? void 0 : _a.decimals) };
+}
+/** v3 `jetton/wallets` filtered by owner and/or jetton, all pages by default */
+async function getJettonWallets({ owner, jetton, limit = 256, offset = 0, paginate = true, excludeZeroBalance }) {
+    var _a;
+    if (!owner && !jetton)
+        throw new Error('getJettonWallets: owner or jetton is required');
+    const owner_address = Array.isArray(owner) ? owner.join(',') : owner;
+    const all = [];
+    for (let page = 0;; page++) {
+        const res = await toncenterGet({
+            path: 'jetton/wallets',
+            params: { owner_address, jetton_address: jetton, limit, offset: offset + page * limit, exclude_zero_balance: excludeZeroBalance },
+        });
+        const wallets = (_a = res === null || res === void 0 ? void 0 : res.jetton_wallets) !== null && _a !== void 0 ? _a : [];
+        all.push(...wallets);
+        if (!paginate || wallets.length < limit)
+            break;
+        (0, debugLog_1.debugLog)(`[chains.ton] jetton/wallets page ${page + 1} (${all.length} so far)`);
+    }
+    return all;
+}
+/** Balance (smallest units, decimal string) of `owner` in `jetton`; '0' when no wallet exists */
+async function getJettonWalletBalance({ owner, jetton }) {
+    const wallets = await getJettonWallets({ owner, jetton, limit: 16, paginate: false });
+    let total = BigInt(0);
+    wallets.forEach(w => { var _a; total += BigInt((_a = w.balance) !== null && _a !== void 0 ? _a : 0); });
+    return total.toString();
+}
+/** v2 `runGetMethod`; returns the unwrapped result `{ exit_code, gas_used, stack }` */
+async function runGetMethod({ address, method, stack = [] }) {
+    const res = await toncenterPost({ path: 'runGetMethod', body: { address, method, stack }, version: 2 });
+    return unwrapV2(res, `runGetMethod ${method}`);
+}
+function parseStackNumber(value) {
+    const s = String(value).trim();
+    const big = s.startsWith('-') ? -BigInt(s.slice(1)) : BigInt(s);
+    const n = Number(big);
+    return Number.isSafeInteger(n) ? n : big;
+}
+function stackBytes(item) {
+    const payload = item[1];
+    if (typeof payload === 'string')
+        return payload;
+    return payload === null || payload === void 0 ? void 0 : payload.bytes;
+}
+/** Decode one runGetMethod stack entry: num -> number (bigint when unsafe), cell/slice holding an address -> friendly address, anything else is returned as-is */
+function decodeStackItem(item) {
+    const [type] = item;
+    if (type === 'num')
+        return parseStackNumber(item[1]);
+    if (type === 'cell' || type === 'slice' || type === 'tvm.Cell' || type === 'tvm.Slice') {
+        const bytes = stackBytes(item);
+        if (bytes) {
+            const address = tryReadAddressFromSlice(bytes);
+            if (address)
+                return address;
+        }
+    }
+    return item;
+}
+/**
+ * Call a get method and decode the stack. `num` entries become numbers (bigint when they do
+ * not fit a safe integer, where the adapters helper silently lost precision), cells / slices
+ * that hold a `MsgAddressInt` become friendly addresses, everything else stays raw.
+ */
+async function call({ target, abi, method, params = [], rawStack = false }) {
+    const name = method !== null && method !== void 0 ? method : abi;
+    if (!name)
+        throw new Error('call: method (or abi) is required');
+    const { exit_code, stack } = await runGetMethod({ address: target, method: name, stack: params });
+    if (exit_code !== 0)
+        throw new Error(`Expected a zero exit code, but got ${exit_code} (${name} on ${target})`);
+    if (rawStack)
+        return stack;
+    return stack.map(decodeStackItem);
+}
+function txTime(tx) {
+    var _a;
+    const t = (_a = tx === null || tx === void 0 ? void 0 : tx.now) !== null && _a !== void 0 ? _a : tx === null || tx === void 0 ? void 0 : tx.utime;
+    return t === undefined || t === null ? undefined : Number(t);
+}
+function inWindow(time, start, end) {
+    if (time === undefined)
+        return true;
+    if (start !== undefined && time < start)
+        return false;
+    if (end !== undefined && time >= end)
+        return false;
+    return true;
+}
+/**
+ * Every v3 transaction of `account` in `[startTimestamp, endTimestamp)`, paging through
+ * `/transactions` (toncenter's `end_utime` is inclusive, so the last second is dropped to
+ * keep consecutive windows disjoint).
+ */
+async function getTransactions({ account, startTimestamp, endTimestamp, limit = 128, sort = 'desc', dedupe = true, maxPages, params }) {
+    var _a;
+    const all = [];
+    const seen = new Set();
+    const accountParam = Array.isArray(account) ? account.join(',') : account;
+    for (let page = 0;; page++) {
+        const res = await toncenterGet({
+            path: 'transactions',
+            params: { account: accountParam, start_utime: startTimestamp, end_utime: endTimestamp, limit, offset: page * limit, sort, ...params },
+        });
+        // a body without a transactions array is a failure wearing a 200
+        if (!Array.isArray(res === null || res === void 0 ? void 0 : res.transactions))
+            throw new Error(`Expected a transactions array from toncenter for ${accountParam}`);
+        const txs = res.transactions;
+        for (const tx of txs) {
+            if (dedupe) {
+                const key = (_a = tx.hash) !== null && _a !== void 0 ? _a : `${tx.lt}:${txTime(tx)}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+            }
+            if (!inWindow(txTime(tx), startTimestamp, endTimestamp))
+                continue;
+            all.push(tx);
+        }
+        if (txs.length < limit)
+            break;
+        if (maxPages !== undefined && page + 1 >= maxPages)
+            break;
+        (0, debugLog_1.debugLog)(`[chains.ton] transactions page ${page + 1} for ${accountParam} (${all.length} so far)`);
+    }
+    return all;
+}
+/** Every v3 message matching the filters in `[startTimestamp, endTimestamp)`, paging through `/messages` */
+async function getMessages({ source, destination, direction, opcode, bodyHash, startTimestamp, endTimestamp, limit = 128, sort = 'desc', dedupe = true, maxPages, params }) {
+    var _a, _b;
+    if (!source && !destination && !bodyHash && !opcode)
+        throw new Error('getMessages: source, destination, opcode or bodyHash is required');
+    const all = [];
+    const seen = new Set();
+    const label = (_b = (_a = source !== null && source !== void 0 ? source : destination) !== null && _a !== void 0 ? _a : bodyHash) !== null && _b !== void 0 ? _b : opcode;
+    for (let page = 0;; page++) {
+        const res = await toncenterGet({
+            path: 'messages',
+            params: { source, destination, direction, opcode, body_hash: bodyHash, start_utime: startTimestamp, end_utime: endTimestamp, limit, offset: page * limit, sort, ...params },
+        });
+        if (!Array.isArray(res === null || res === void 0 ? void 0 : res.messages))
+            throw new Error(`Expected a messages array from toncenter for ${label}`);
+        const messages = res.messages;
+        for (const message of messages) {
+            if (dedupe && message.hash) {
+                if (seen.has(message.hash))
+                    continue;
+                seen.add(message.hash);
+            }
+            const created = message.created_at === undefined || message.created_at === null ? undefined : Number(message.created_at);
+            if (!inWindow(created, startTimestamp, endTimestamp))
+                continue;
+            all.push(message);
+        }
+        if (messages.length < limit)
+            break;
+        if (maxPages !== undefined && page + 1 >= maxPages)
+            break;
+        (0, debugLog_1.debugLog)(`[chains.ton] messages page ${page + 1} for ${label} (${all.length} so far)`);
+    }
+    return all;
+}
+// ---------------------------------------------------------------------------
+// toncenter: blocks
+// ---------------------------------------------------------------------------
+exports.MASTERCHAIN_SHARD = '-9223372036854775808';
+/** v3 `masterchainInfo`: `{ first: block, last: block }` where `last.seqno` is the current masterchain height */
+async function getMasterchainInfo() {
+    return toncenterGet({ path: 'masterchainInfo' });
+}
+/** v2 `lookupBlock` by seqno, unixtime or lt. Returns `{ workchain, shard, seqno, root_hash, file_hash }` */
+async function lookupBlock({ workchain = -1, shard = exports.MASTERCHAIN_SHARD, seqno, utime, lt } = {}) {
+    if (seqno === undefined && utime === undefined && lt === undefined)
+        throw new Error('lookupBlock: seqno, utime or lt is required');
+    const res = await toncenterGet({ path: 'lookupBlock', params: { workchain, shard, seqno, unixtime: utime, lt }, version: 2 });
+    return unwrapV2(res, 'lookupBlock');
+}
+/** Masterchain block at `timestamp`: `{ number: seqno, timestamp, block }` */
+async function getBlockAtTimestamp({ timestamp }) {
+    const block = await lookupBlock({ utime: timestamp });
+    return { number: Number(block.seqno), timestamp, block };
+}
+/** Latest masterchain block: `{ number: seqno, timestamp: gen_utime, block }` */
+async function getLatestBlock() {
+    const { last } = await getMasterchainInfo();
+    if (!(last === null || last === void 0 ? void 0 : last.seqno))
+        throw new Error('toncenter masterchainInfo: no last block');
+    return { number: Number(last.seqno), timestamp: Number(last.gen_utime), block: last };
+}
+// ---------------------------------------------------------------------------
+// tonapi
+// ---------------------------------------------------------------------------
+function tonapiPath(path) {
+    return `/v2/${path.replace(/^\/+/, '')}`;
+}
+/** GET `/v2/{path}` on tonapi */
+async function tonapiGet({ path, params }) {
+    return paced('TONAPI', () => (0, rpc_1.httpGet)(getTonapiEndpoints(), {
+        path: tonapiPath(path),
+        params: dropUndefined(params),
+        headers: tonapiHeaders(),
+        ...TONAPI_RETRY,
+    }));
+}
+/** POST to `/v2/{path}` on tonapi */
+async function tonapiPost({ path, body = {} }) {
+    return paced('TONAPI', () => (0, rpc_1.httpPost)(getTonapiEndpoints(), body, {
+        path: tonapiPath(path),
+        headers: tonapiHeaders(),
+        ...TONAPI_RETRY,
+    }));
+}
+/**
+ * Jetton balances of an account from tonapi `accounts/{address}/jettons`, with USD prices.
+ * Returns the `balances` array (the adapters helper re-keyed it by jetton address; use
+ * `jettonBalancesByAddress` for that shape). Addresses are in raw `0:...` form.
+ */
+async function getJettonBalances({ address, currencies = 'usd' }) {
+    const res = await tonapiGet({ path: `accounts/${encodeURIComponent(address)}/jettons`, params: { currencies } });
+    if (!Array.isArray(res === null || res === void 0 ? void 0 : res.balances))
+        throw new Error(`tonapi accounts/${address}/jettons: no balances array`);
+    return res.balances;
+}
+/** `{ [rawJettonAddress]: { balance, price, decimals } }`, the shape the adapters helper returned */
+function jettonBalancesByAddress(balances, currency = 'USD') {
+    const res = {};
+    balances.forEach(b => {
+        var _a, _b;
+        res[b.jetton.address] = { balance: b.balance, price: (_b = (_a = b.price) === null || _a === void 0 ? void 0 : _a.prices) === null || _b === void 0 ? void 0 : _b[currency], decimals: b.jetton.decimals };
+    });
+    return res;
+}
+/** tonapi `jettons/{address}`: `{ mintable, total_supply, metadata: { symbol, decimals, name, ... }, holders_count, ... }` */
+async function getJettonInfo({ address }) {
+    return tonapiGet({ path: `jettons/${encodeURIComponent(address)}` });
+}
+/** tonapi `jettons/_bulk`, 100 addresses per request */
+async function getJettonsInfo({ addresses }) {
+    var _a;
+    const result = [];
+    for (const chunk of (0, rpc_1.sliceIntoChunks)(addresses, 100)) {
+        const res = await tonapiPost({ path: 'jettons/_bulk', body: { account_ids: chunk } });
+        result.push(...((_a = res === null || res === void 0 ? void 0 : res.jettons) !== null && _a !== void 0 ? _a : []));
+    }
+    return result;
+}
+/** USD prices from tonapi `rates`, keyed by the token string that was passed in ('ton' or a jetton address) */
+async function getTokenRates({ tokens, currency = 'usd' }) {
+    var _a;
+    if (!tokens.length)
+        return {};
+    const res = await tonapiGet({ path: 'rates', params: { tokens: tokens.join(','), currencies: currency } });
+    const rates = (_a = res === null || res === void 0 ? void 0 : res.rates) !== null && _a !== void 0 ? _a : {};
+    const prices = {};
+    const key = currency.toUpperCase();
+    tokens.forEach(token => {
+        var _a, _b;
+        const price = (_b = (_a = rates[token]) === null || _a === void 0 ? void 0 : _a.prices) === null || _b === void 0 ? void 0 : _b[key];
+        if (price !== undefined && price !== null)
+            prices[token] = price;
+    });
+    return prices;
+}
+// ---------------------------------------------------------------------------
+// codec: crc16 & Address
+// ---------------------------------------------------------------------------
+const BOUNCEABLE_TAG = 0x11;
+const NON_BOUNCEABLE_TAG = 0x51;
+const TEST_FLAG = 0x80;
+/** CRC-16/XMODEM (poly 0x1021, init 0), the checksum used by friendly TON addresses */
+function crc16(data) {
+    let crc = 0;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i] << 8;
+        for (let j = 0; j < 8; j++) {
+            crc = crc & 0x8000 ? ((crc << 1) ^ 0x1021) & 0xffff : (crc << 1) & 0xffff;
+        }
+    }
+    return crc;
+}
+function base64ToBuffer(source) {
+    return Buffer.from(source.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+}
+function bufferToBase64(buffer, urlSafe) {
+    const b64 = buffer.toString('base64');
+    return urlSafe ? b64.replace(/\+/g, '-').replace(/\//g, '_') : b64;
+}
+function parseFriendlyBuffer(data, source) {
+    // 1 byte tag + 1 byte workchain + 32 bytes hash + 2 bytes crc
+    if (data.length !== 36)
+        throw new Error(`Unknown address type: byte length is not equal to 36 (${source})`);
+    const addr = data.subarray(0, 34);
+    if (crc16(addr) !== data.readUInt16BE(34))
+        throw new Error(`Invalid checksum: ${source}`);
+    let tag = addr[0];
+    let isTestOnly = false;
+    if (tag & TEST_FLAG) {
+        isTestOnly = true;
+        tag ^= TEST_FLAG;
+    }
+    if (tag !== BOUNCEABLE_TAG && tag !== NON_BOUNCEABLE_TAG)
+        throw new Error(`Unknown address tag ${tag} (${source})`);
+    const workchain = addr.readInt8(1);
+    return { isTestOnly, isBounceable: tag === BOUNCEABLE_TAG, workchain, hashPart: Buffer.from(addr.subarray(2, 34)) };
+}
+/**
+ * TON address (workchain + 256 bit hash), ported from ton-core. Parses friendly
+ * (`EQ...` / `UQ...`, base64 or base64url) and raw (`0:abcd...`) forms.
+ */
+class Address {
+    constructor(workChain, hash) {
+        if (hash.length !== 32)
+            throw new Error(`Invalid address hash length: ${hash.length}`);
+        this.workChain = workChain;
+        this.hash = hash;
+        Object.freeze(this);
+    }
+    static isAddress(src) {
+        return src instanceof Address;
+    }
+    /** shape check only (48 base64 chars); use `isAddress` to also verify the checksum */
+    static isFriendly(source) {
+        return typeof source === 'string' && /^[A-Za-z0-9+/_-]{48}$/.test(source);
+    }
+    static isRaw(source) {
+        if (typeof source !== 'string')
+            return false;
+        const parts = source.split(':');
+        if (parts.length !== 2)
+            return false;
+        const [wc, hash] = parts;
+        if (!/^-?\d+$/.test(wc))
+            return false;
+        return /^[a-fA-F0-9]{64}$/.test(hash);
+    }
+    static parse(source) {
+        if (Address.isAddress(source))
+            return source;
+        if (Address.isFriendly(source))
+            return Address.parseFriendly(source).address;
+        if (Address.isRaw(source))
+            return Address.parseRaw(source);
+        throw new Error(`Unknown address type: ${source}`);
+    }
+    static parseRaw(source) {
+        if (!Address.isRaw(source))
+            throw new Error(`Invalid raw address: ${source}`);
+        const [wc, hash] = source.split(':');
+        return new Address(parseInt(wc, 10), Buffer.from(hash, 'hex'));
+    }
+    static parseFriendly(source) {
+        let data;
+        if (Buffer.isBuffer(source))
+            data = source;
+        else {
+            if (!Address.isFriendly(source))
+                throw new Error(`Unknown address type: ${source}`);
+            data = base64ToBuffer(source);
+        }
+        const r = parseFriendlyBuffer(data, Buffer.isBuffer(source) ? source.toString('base64') : source);
+        return { isBounceable: r.isBounceable, isTestOnly: r.isTestOnly, address: new Address(r.workchain, r.hashPart) };
+    }
+    /** friendly form of any address string (or Address), bounceable + url-safe by default */
+    static normalize(source, options) {
+        return Address.parse(source).toString(options);
+    }
+    toRawString() {
+        return `${this.workChain}:${this.hash.toString('hex')}`;
+    }
+    /** 36 bytes: hash followed by the workchain repeated 4 times (ton-core `toRaw`) */
+    toRaw() {
+        const out = Buffer.alloc(36);
+        out.set(this.hash);
+        const wc = this.workChain & 0xff;
+        out.set([wc, wc, wc, wc], 32);
+        return out;
+    }
+    toStringBuffer({ bounceable = true, testOnly = false } = {}) {
+        let tag = bounceable ? BOUNCEABLE_TAG : NON_BOUNCEABLE_TAG;
+        if (testOnly)
+            tag |= TEST_FLAG;
+        const out = Buffer.alloc(36);
+        out[0] = tag;
+        out.writeInt8(this.workChain, 1);
+        out.set(this.hash, 2);
+        out.writeUInt16BE(crc16(out.subarray(0, 34)), 34);
+        return out;
+    }
+    toString(options = {}) {
+        const { urlSafe = true } = options;
+        return bufferToBase64(this.toStringBuffer(options), urlSafe);
+    }
+    equals(src) {
+        return src.workChain === this.workChain && src.hash.equals(this.hash);
+    }
+}
+exports.Address = Address;
+/** `Address.parse` */
+function parseAddress(source) {
+    return Address.parse(source);
+}
+/** Friendly form of any address string, bounceable + url-safe by default */
+function normalizeAddress(source, { bounceable = true, urlSafe = true, testOnly = false } = {}) {
+    return Address.parse(source).toString({ bounceable, urlSafe, testOnly });
+}
+/** `wc:hex` form of any address string */
+function toRawAddress(source) {
+    return Address.parse(source).toRawString();
+}
+/** true when `source` parses as a friendly (checksum verified) or raw address */
+function isAddress(source) {
+    if (Address.isAddress(source))
+        return true;
+    if (typeof source !== 'string')
+        return false;
+    try {
+        Address.parse(source);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 256 bit account hash as a bigint (the workchain is dropped) */
+function addressToInt(address) {
+    return BigInt(`0x${Address.parse(address).hash.toString('hex')}`);
+}
+/** Inverse of `addressToInt`, workchain 0 by default */
+function convertIntToAddress(value, workChain = 0) {
+    const hex = BigInt(value).toString(16).padStart(64, '0');
+    if (hex.length !== 64)
+        throw new Error(`convertIntToAddress: value does not fit 256 bits`);
+    return Address.parseRaw(`${workChain}:${hex}`);
+}
+/** true when both parse and point at the same workchain + hash, false for anything unparsable */
+function compareAddress(a, b) {
+    if (!a || !b)
+        return false;
+    try {
+        return Address.parse(a).equals(Address.parse(b));
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// codec: BoC & bit reader
+// ---------------------------------------------------------------------------
+function decodeBase64(source) {
+    return base64ToBuffer(source);
+}
+/** MSB-first bit reader over a buffer */
+class BitReader {
+    constructor(buffer, startByte = 0, startBit = 0) {
+        this.buffer = buffer;
+        this.byteOffset = startByte;
+        this.bitOffset = startBit;
+    }
+    get remainingBits() {
+        return (this.buffer.length - this.byteOffset) * 8 - this.bitOffset;
+    }
+    readBit() {
+        if (this.byteOffset >= this.buffer.length)
+            throw new Error('Buffer overflow while reading bits');
+        const bit = (this.buffer[this.byteOffset] >> (7 - this.bitOffset)) & 1;
+        this.bitOffset++;
+        if (this.bitOffset === 8) {
+            this.bitOffset = 0;
+            this.byteOffset++;
+        }
+        return bit;
+    }
+    /** unsigned integer of `n` bits (n <= 53) */
+    readBits(n) {
+        if (n > 53)
+            throw new Error('readBits: use readBigUint for more than 53 bits');
+        let value = 0;
+        for (let i = 0; i < n; i++)
+            value = value * 2 + this.readBit();
+        return value;
+    }
+    readUint(n) {
+        return this.readBits(n);
+    }
+    /** two's complement signed integer of `n` bits */
+    readInt(n) {
+        const value = this.readBits(n);
+        return value >= 2 ** (n - 1) ? value - 2 ** n : value;
+    }
+    readBigUint(n) {
+        let value = BigInt(0);
+        for (let i = 0; i < n; i++)
+            value = (value << BigInt(1)) | BigInt(this.readBit());
+        return value;
+    }
+    readBytes(n) {
+        const out = Buffer.alloc(n);
+        for (let i = 0; i < n; i++)
+            out[i] = this.readBits(8);
+        return out;
+    }
+    skip(n) {
+        for (let i = 0; i < n; i++)
+            this.readBit();
+    }
+}
+exports.BitReader = BitReader;
+/** Parse a serialized bag-of-cells header (`b5ee9c72` magic) and return the raw cell data */
+function parseBoc(buffer) {
+    if (buffer.length < 4)
+        throw new Error('Buffer is too short to contain magic bytes');
+    if (buffer.readUInt32BE(0) !== 0xb5ee9c72)
+        throw new Error('Invalid magic');
+    let offset = 4;
+    const byte = buffer[offset++];
+    const hasIdx = !!((byte >> 7) & 1);
+    const hasCrc32c = !!((byte >> 6) & 1);
+    const hasCacheBits = !!((byte >> 5) & 1);
+    const flags = (byte >> 3) & 0b11;
+    const size = byte & 0b111;
+    const offBytes = buffer.readUInt8(offset++);
+    const cells = buffer.readUIntBE(offset, size);
+    offset += size;
+    const roots = buffer.readUIntBE(offset, size);
+    offset += size;
+    const absent = buffer.readUIntBE(offset, size);
+    offset += size;
+    const totalCellSize = buffer.readUIntBE(offset, offBytes);
+    offset += offBytes;
+    const root = [];
+    for (let i = 0; i < roots; i++) {
+        root.push(buffer.readUIntBE(offset, size));
+        offset += size;
+    }
+    let index = null;
+    if (hasIdx) {
+        index = buffer.subarray(offset, offset + cells * offBytes);
+        offset += cells * offBytes;
+    }
+    const cellData = buffer.subarray(offset, offset + totalCellSize);
+    offset += totalCellSize;
+    return { hasIdx, hasCrc32c, hasCacheBits, flags, size, offBytes, cells, roots, absent, totalCellSize, root, index, cellData, offset };
+}
+/** Friendly address for a workchain + 32 byte hash (bounceable, url-safe by default) */
+function serializeAddress(wc, hash, options = {}) {
+    return new Address(wc, hash).toString(options);
+}
+/**
+ * Read the `MsgAddressInt` (addr_std) stored at the start of the first cell of a base64
+ * BoC, as returned in a runGetMethod `cell` / `slice` stack entry. Returns the friendly
+ * bounceable address. Throws when the cell does not start with an addr_std.
+ */
+function readAddressFromSlice(base64Boc) {
+    const { cellData } = parseBoc(decodeBase64(base64Boc));
+    if (cellData.length < 2 + 33)
+        throw new Error('Cell too short to hold an address');
+    // cell layout: d1 (refs descriptor), d2 (data length descriptor), data bits
+    const reader = new BitReader(cellData, 2, 0);
+    const tag = reader.readBits(2);
+    if (tag !== 0b10)
+        throw new Error(`Not an addr_std (tag ${tag})`);
+    const anycast = reader.readBit();
+    if (anycast !== 0)
+        throw new Error('Anycast addresses are not supported');
+    const wc = reader.readInt(8);
+    const hash = reader.readBytes(32);
+    return serializeAddress(wc, hash);
+}
+/** `readAddressFromSlice` that returns null instead of throwing */
+function tryReadAddressFromSlice(base64Boc) {
+    try {
+        return readAddressFromSlice(base64Boc);
+    }
+    catch {
+        return null;
+    }
+}