@defillama/sdk 5.0.235 → 5.0.236

package/build/chains/ton.d.ts

@@ -0,0 +1,353 @@
+export declare const DEFAULT_ENDPOINTS: {
+    toncenter: string;
+    tonapi: string;
+};
+/** All configured toncenter base urls (`TON_RPC`, comma separated) */
+export declare function getToncenterEndpoints(): string[];
+export declare function getToncenterEndpoint(): string;
+/** All configured tonapi base urls (`TON_API_RPC`, comma separated) */
+export declare function getTonapiEndpoints(): string[];
+export declare function getTonapiEndpoint(): string;
+export interface ToncenterGetOptions {
+    path: string;
+    params?: Record<string, any>;
+    /** api version, default 3 */
+    version?: 2 | 3;
+}
+export interface ToncenterPostOptions {
+    path: string;
+    body?: any;
+    /** api version, default 2 */
+    version?: 2 | 3;
+}
+/** GET `/api/v{version}/{path}` on toncenter. Returns the raw response body (v2 bodies are `{ok, result}`). */
+export declare function toncenterGet({ path, params, version }: ToncenterGetOptions): Promise<any>;
+/** POST to `/api/v{version}/{path}` on toncenter. Returns the raw response body. */
+export declare function toncenterPost({ path, body, version }: ToncenterPostOptions): Promise<any>;
+/** Full v3 account state: `{ balance, status, code, data, last_transaction_lt, last_transaction_hash, frozen_hash }` */
+export declare function getAccountState({ address }: {
+    address: string;
+}): Promise<any>;
+/** TON balance in nanoton, as a decimal string */
+export declare function getTonBalance({ address }: {
+    address: string;
+}): Promise<string>;
+export interface JettonMaster {
+    address: string;
+    total_supply: string;
+    mintable: boolean;
+    admin_address: string | null;
+    jetton_content: Record<string, any> | null;
+    jetton_wallet_code_hash: string;
+    code_hash: string;
+    data_hash: string;
+    last_transaction_lt: string;
+    [key: string]: any;
+}
+/** v3 `jetton/masters` entry for one jetton. Throws when the address is not a jetton master. */
+export declare function getJettonMaster({ address }: {
+    address: string;
+}): Promise<JettonMaster>;
+/** `{ supply, decimals }` of a jetton from its v3 master record. `decimals` is undefined when the content is off-chain. */
+export declare function getJettonSupply({ address }: {
+    address: string;
+}): Promise<{
+    supply: string;
+    decimals?: number;
+}>;
+export interface JettonWallet {
+    address: string;
+    balance: string;
+    owner: string;
+    jetton: string;
+    last_transaction_lt: string;
+    code_hash: string;
+    data_hash: string;
+    [key: string]: any;
+}
+export interface GetJettonWalletsOptions {
+    /** owner address(es); several are sent comma separated */
+    owner?: string | string[];
+    /** jetton master address */
+    jetton?: string;
+    /** page size, default 256 */
+    limit?: number;
+    offset?: number;
+    /** fetch every page, default true */
+    paginate?: boolean;
+    excludeZeroBalance?: boolean;
+}
+/** v3 `jetton/wallets` filtered by owner and/or jetton, all pages by default */
+export declare function getJettonWallets({ owner, jetton, limit, offset, paginate, excludeZeroBalance }: GetJettonWalletsOptions): Promise<JettonWallet[]>;
+/** Balance (smallest units, decimal string) of `owner` in `jetton`; '0' when no wallet exists */
+export declare function getJettonWalletBalance({ owner, jetton }: {
+    owner: string;
+    jetton: string;
+}): Promise<string>;
+/** toncenter v2 stack entry, e.g. `['num', '0x1']`, `['cell', { bytes }]`, `['tuple', ...]` */
+export type StackItem = [string, any];
+export interface RunGetMethodResult {
+    exit_code: number;
+    gas_used: number;
+    stack: StackItem[];
+    [key: string]: any;
+}
+/** v2 `runGetMethod`; returns the unwrapped result `{ exit_code, gas_used, stack }` */
+export declare function runGetMethod({ address, method, stack }: {
+    address: string;
+    method: string;
+    stack?: any[];
+}): Promise<RunGetMethodResult>;
+/** Decode one runGetMethod stack entry: num -> number (bigint when unsafe), cell/slice holding an address -> friendly address, anything else is returned as-is */
+export declare function decodeStackItem(item: StackItem): any;
+export interface CallOptions {
+    target: string;
+    /** get method name (alias of `method`, kept from the adapters helper) */
+    abi?: string;
+    method?: string;
+    params?: any[];
+    /** return the untouched stack */
+    rawStack?: boolean;
+}
+/**
+ * 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.
+ */
+export declare function call({ target, abi, method, params, rawStack }: CallOptions): Promise<any[]>;
+export interface GetTransactionsOptions {
+    /** account address(es); several are sent comma separated */
+    account: string | string[];
+    /** inclusive lower bound (unix seconds) */
+    startTimestamp?: number;
+    /** exclusive upper bound (unix seconds) */
+    endTimestamp?: number;
+    /** page size, default 128 (toncenter max 1000) */
+    limit?: number;
+    sort?: 'asc' | 'desc';
+    /** drop transactions seen twice across pages, default true */
+    dedupe?: boolean;
+    /** stop after this many pages */
+    maxPages?: number;
+    /** extra v3 query params (e.g. `{ workchain, seqno, lt }`) */
+    params?: Record<string, any>;
+}
+/**
+ * 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).
+ */
+export declare function getTransactions({ account, startTimestamp, endTimestamp, limit, sort, dedupe, maxPages, params }: GetTransactionsOptions): Promise<any[]>;
+export interface GetMessagesOptions {
+    source?: string;
+    destination?: string;
+    direction?: 'in' | 'out';
+    /** message hash, body hash or opcode filters straight from the v3 api */
+    opcode?: string;
+    bodyHash?: string;
+    /** inclusive lower bound (unix seconds) */
+    startTimestamp?: number;
+    /** exclusive upper bound (unix seconds) */
+    endTimestamp?: number;
+    /** page size, default 128 (toncenter max 1000) */
+    limit?: number;
+    sort?: 'asc' | 'desc';
+    dedupe?: boolean;
+    maxPages?: number;
+    params?: Record<string, any>;
+}
+/** Every v3 message matching the filters in `[startTimestamp, endTimestamp)`, paging through `/messages` */
+export declare function getMessages({ source, destination, direction, opcode, bodyHash, startTimestamp, endTimestamp, limit, sort, dedupe, maxPages, params }: GetMessagesOptions): Promise<any[]>;
+export declare const MASTERCHAIN_SHARD = "-9223372036854775808";
+/** v3 `masterchainInfo`: `{ first: block, last: block }` where `last.seqno` is the current masterchain height */
+export declare function getMasterchainInfo(): Promise<{
+    first: any;
+    last: any;
+}>;
+export interface LookupBlockOptions {
+    workchain?: number;
+    shard?: string;
+    seqno?: number;
+    /** unix seconds; resolves the block at or before this time */
+    utime?: number;
+    lt?: number | string;
+}
+/** v2 `lookupBlock` by seqno, unixtime or lt. Returns `{ workchain, shard, seqno, root_hash, file_hash }` */
+export declare function lookupBlock({ workchain, shard, seqno, utime, lt }?: LookupBlockOptions): Promise<any>;
+/** Masterchain block at `timestamp`: `{ number: seqno, timestamp, block }` */
+export declare function getBlockAtTimestamp({ timestamp }: {
+    timestamp: number;
+}): Promise<{
+    number: number;
+    timestamp: number;
+    block: any;
+}>;
+/** Latest masterchain block: `{ number: seqno, timestamp: gen_utime, block }` */
+export declare function getLatestBlock(): Promise<{
+    number: number;
+    timestamp: number;
+    block: any;
+}>;
+/** GET `/v2/{path}` on tonapi */
+export declare function tonapiGet({ path, params }: {
+    path: string;
+    params?: Record<string, any>;
+}): Promise<any>;
+/** POST to `/v2/{path}` on tonapi */
+export declare function tonapiPost({ path, body }: {
+    path: string;
+    body?: any;
+}): Promise<any>;
+export interface TonapiJettonBalance {
+    balance: string;
+    price?: {
+        prices?: Record<string, number>;
+        diff_24h?: Record<string, string>;
+    };
+    wallet_address: {
+        address: string;
+        is_scam?: boolean;
+        is_wallet?: boolean;
+        name?: string;
+    };
+    jetton: {
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        image?: string;
+        verification?: string;
+    };
+    [key: string]: any;
+}
+/**
+ * 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.
+ */
+export declare function getJettonBalances({ address, currencies }: {
+    address: string;
+    currencies?: string;
+}): Promise<TonapiJettonBalance[]>;
+/** `{ [rawJettonAddress]: { balance, price, decimals } }`, the shape the adapters helper returned */
+export declare function jettonBalancesByAddress(balances: TonapiJettonBalance[], currency?: string): Record<string, {
+    balance: string;
+    price?: number;
+    decimals: number;
+}>;
+/** tonapi `jettons/{address}`: `{ mintable, total_supply, metadata: { symbol, decimals, name, ... }, holders_count, ... }` */
+export declare function getJettonInfo({ address }: {
+    address: string;
+}): Promise<any>;
+/** tonapi `jettons/_bulk`, 100 addresses per request */
+export declare function getJettonsInfo({ addresses }: {
+    addresses: string[];
+}): Promise<any[]>;
+/** USD prices from tonapi `rates`, keyed by the token string that was passed in ('ton' or a jetton address) */
+export declare function getTokenRates({ tokens, currency }: {
+    tokens: string[];
+    currency?: string;
+}): Promise<Record<string, number>>;
+/** CRC-16/XMODEM (poly 0x1021, init 0), the checksum used by friendly TON addresses */
+export declare function crc16(data: Buffer | Uint8Array): number;
+export interface AddressStringOptions {
+    /** default true */
+    urlSafe?: boolean;
+    /** default true */
+    bounceable?: boolean;
+    /** default false */
+    testOnly?: boolean;
+}
+/**
+ * TON address (workchain + 256 bit hash), ported from ton-core. Parses friendly
+ * (`EQ...` / `UQ...`, base64 or base64url) and raw (`0:abcd...`) forms.
+ */
+export declare class Address {
+    readonly workChain: number;
+    readonly hash: Buffer;
+    constructor(workChain: number, hash: Buffer);
+    static isAddress(src: any): src is Address;
+    /** shape check only (48 base64 chars); use `isAddress` to also verify the checksum */
+    static isFriendly(source: string): boolean;
+    static isRaw(source: string): boolean;
+    static parse(source: string | Address): Address;
+    static parseRaw(source: string): Address;
+    static parseFriendly(source: string | Buffer): {
+        isBounceable: boolean;
+        isTestOnly: boolean;
+        address: Address;
+    };
+    /** friendly form of any address string (or Address), bounceable + url-safe by default */
+    static normalize(source: string | Address, options?: AddressStringOptions): string;
+    toRawString(): string;
+    /** 36 bytes: hash followed by the workchain repeated 4 times (ton-core `toRaw`) */
+    toRaw(): Buffer;
+    toStringBuffer({ bounceable, testOnly }?: AddressStringOptions): Buffer;
+    toString(options?: AddressStringOptions): string;
+    equals(src: Address): boolean;
+}
+/** `Address.parse` */
+export declare function parseAddress(source: string | Address): Address;
+/** Friendly form of any address string, bounceable + url-safe by default */
+export declare function normalizeAddress(source: string | Address, { bounceable, urlSafe, testOnly }?: AddressStringOptions): string;
+/** `wc:hex` form of any address string */
+export declare function toRawAddress(source: string | Address): string;
+/** true when `source` parses as a friendly (checksum verified) or raw address */
+export declare function isAddress(source: any): boolean;
+/** 256 bit account hash as a bigint (the workchain is dropped) */
+export declare function addressToInt(address: string | Address): bigint;
+/** Inverse of `addressToInt`, workchain 0 by default */
+export declare function convertIntToAddress(value: bigint | number | string, workChain?: number): Address;
+/** true when both parse and point at the same workchain + hash, false for anything unparsable */
+export declare function compareAddress(a: string | Address | undefined | null, b: string | Address | undefined | null): boolean;
+export declare function decodeBase64(source: string): Buffer;
+/** MSB-first bit reader over a buffer */
+export declare class BitReader {
+    buffer: Buffer;
+    byteOffset: number;
+    bitOffset: number;
+    constructor(buffer: Buffer, startByte?: number, startBit?: number);
+    get remainingBits(): number;
+    readBit(): number;
+    /** unsigned integer of `n` bits (n <= 53) */
+    readBits(n: number): number;
+    readUint(n: number): number;
+    /** two's complement signed integer of `n` bits */
+    readInt(n: number): number;
+    readBigUint(n: number): bigint;
+    readBytes(n: number): Buffer;
+    skip(n: number): void;
+}
+export interface ParsedBoc {
+    hasIdx: boolean;
+    hasCrc32c: boolean;
+    hasCacheBits: boolean;
+    flags: number;
+    /** bytes used for cell counts */
+    size: number;
+    /** bytes used for offsets */
+    offBytes: number;
+    cells: number;
+    roots: number;
+    absent: number;
+    totalCellSize: number;
+    /** root cell indices */
+    root: number[];
+    index: Buffer | null;
+    /** serialized cells, starting with the first root's descriptors */
+    cellData: Buffer;
+    /** byte offset right after the cell data */
+    offset: number;
+}
+/** Parse a serialized bag-of-cells header (`b5ee9c72` magic) and return the raw cell data */
+export declare function parseBoc(buffer: Buffer): ParsedBoc;
+/** Friendly address for a workchain + 32 byte hash (bounceable, url-safe by default) */
+export declare function serializeAddress(wc: number, hash: Buffer, options?: AddressStringOptions): string;
+/**
+ * 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.
+ */
+export declare function readAddressFromSlice(base64Boc: string): string;
+/** `readAddressFromSlice` that returns null instead of throwing */
+export declare function tryReadAddressFromSlice(base64Boc: string): string | null;