@defillama/sdk 5.0.236 → 5.0.240

package/build/chains/substrate.d.ts

@@ -1,333 +0,0 @@
-export declare const DEFAULT_ENDPOINTS: Record<string, string>;
-export type Bytes = Buffer | Uint8Array | number[] | string;
-export interface ChainOptions {
-    /** chain key (`polkadot`, `bifrost`, ...) or a literal `https://` endpoint (comma separated list allowed) */
-    chain: string;
-    /** total attempts across endpoints (default: max(3, endpoints)) */
-    retries?: number;
-}
-/** `Buffer` from a `0x` hex string, utf8 string, byte array or Buffer/Uint8Array */
-export declare function toBuf(value: Bytes | undefined | null): Buffer;
-/** `0x` prefixed lowercase hex */
-export declare function hex(value: Bytes): string;
-/** little endian u64 (8 bytes) */
-export declare function u64le(n: bigint | number): Buffer;
-/** xxHash64 of `data` with `seed` -> unsigned 64 bit bigint */
-export declare function xxhash64(data: Bytes, seed?: bigint | number): bigint;
-/** twox64: xxhash64(data, 0) as 8 LE bytes */
-export declare const twox64: (data: Bytes) => Buffer;
-/** twox128: xxhash64(data, 0) ++ xxhash64(data, 1) */
-export declare const twox128: (data: Bytes) => Buffer;
-/** twox256: xxhash64 with seeds 0..3 */
-export declare const twox256: (data: Bytes) => Buffer;
-/** blake2b digest of `data`, `outLen` bytes (1..64, default 32), no key */
-export declare function blake2b(data: Bytes, outLen?: number): Buffer;
-export declare const blake2_128: (data: Bytes) => Buffer;
-export declare const blake2_256: (data: Bytes) => Buffer;
-export declare const blake2_512: (data: Bytes) => Buffer;
-/** base58 (bitcoin alphabet) decode, keeps leading zero bytes */
-export declare function base58Decode(str: string): Buffer;
-/** base58 (bitcoin alphabet) encode */
-export declare function base58Encode(data: Bytes): string;
-/** ss58 address -> { prefix, pubkey } (checksum verified) */
-export declare function ss58DecodeFull(address: string): {
-    prefix: number;
-    pubkey: Buffer;
-};
-/**
- * ss58 address -> 32 byte account id. A Buffer / Uint8Array / `0x` hex account id is
- * returned as-is so callers can accept both address formats.
- */
-export declare function ss58Decode(address: string | Uint8Array): Buffer;
-/** account id (32 bytes) -> ss58 address with `prefix` (0 = polkadot, 2 = kusama, 42 = generic) */
-export declare function ss58Encode(pubkey: Bytes, prefix?: number): string;
-export declare const encodeU8: (n: number) => Buffer;
-export declare const encodeU16: (n: number) => Buffer;
-export declare const encodeU32: (n: number) => Buffer;
-export declare const encodeU64: (n: bigint | number | string) => Buffer;
-export declare const encodeU128: (n: bigint | number | string) => Buffer;
-/** little endian unsigned integer of `bytes` bytes */
-export declare function encodeUint(n: bigint | number | string, bytes: number): Buffer;
-/** SCALE Compact<uN> */
-export declare function encodeCompact(value: bigint | number | string): Buffer;
-/** little endian unsigned integer at `offset`, `bytes` wide (default u128); missing bytes read as 0 */
-export declare function decodeUint(value: Bytes | null | undefined, { offset, bytes }?: {
-    offset?: number;
-    bytes?: number;
-}): bigint;
-/** SCALE Compact<uN> at `offset` -> { value, length: bytes consumed } */
-export declare function decodeCompact(value: Bytes, offset?: number): {
-    value: bigint;
-    length: number;
-};
-/** Sequential SCALE reader for hand decoding structs */
-export declare class ScaleReader {
-    buf: Buffer;
-    offset: number;
-    constructor(value: Bytes);
-    get remaining(): number;
-    private need;
-    /** next `n` raw bytes (view, not a copy) */
-    bytes(n: number): Buffer;
-    skip(n: number): this;
-    u8(): number;
-    u16(): number;
-    u32(): number;
-    u64(): bigint;
-    u128(): bigint;
-    u256(): bigint;
-    i32(): number;
-    i64(): bigint;
-    bool(): boolean;
-    compact(): bigint;
-    /** Option<T>: `null` when the tag byte is 0 */
-    option<T>(fn: (r: ScaleReader) => T): T | null;
-    /** Vec<T> */
-    vec<T>(fn: (r: ScaleReader) => T): T[];
-    /** Vec<u8> / BoundedVec<u8> */
-    bytesVec(): Buffer;
-    string(): string;
-    /** 32 byte AccountId as `0x` hex */
-    accountId(): string;
-    /** H256 as `0x` hex */
-    hash(): string;
-}
-export interface Hasher {
-    encode: (key: Bytes) => Buffer;
-    /** bytes preceding the raw key in a concat hasher (0 when the key is not recoverable) */
-    hashLength: number;
-    /** true when the raw key follows the hash (Identity / *Concat hashers) */
-    concat: boolean;
-}
-export declare const twox64Concat: (key: Bytes) => Buffer;
-export declare const blake2_128Concat: (key: Bytes) => Buffer;
-export declare const identity: (key: Bytes) => Buffer;
-/** key hashers as used in pallet storage definitions (looked up case-insensitively) */
-export declare const hashers: Record<string, Hasher>;
-export declare const DEFAULT_HASHER = "Twox64Concat";
-export declare function getHasher(name?: string): Hasher;
-/** twox128(pallet) ++ twox128(item) */
-export declare const storagePrefix: (pallet: string, item: string) => Buffer;
-export interface StorageKeyParams {
-    pallet: string;
-    item: string;
-    /** single map key (SCALE encoded bytes / hex); prepended to `keys` */
-    key?: Bytes;
-    /** hasher for `key`, default Twox64Concat */
-    hasher?: string;
-    /** (double / n) map keys in order */
-    keys?: {
-        key: Bytes;
-        hasher?: string;
-    }[];
-}
-/** full storage key as `0x` hex */
-export declare function storageKey({ pallet, item, key, hasher, keys }: StorageKeyParams): string;
-/** strip the hash part of a concat hasher from an entry's `rest` buffer -> raw SCALE key */
-export declare function stripHasher(rest: Bytes, hasher?: string): Buffer;
-export declare function getEndpoints({ chain }: {
-    chain: string;
-}): string[];
-/** Raw JSON-RPC call; rotates endpoints, retries transient failures, runs under a per-chain limiter */
-export declare function rpc({ chain, method, params, retries }: ChainOptions & {
-    method: string;
-    params?: any[];
-}): Promise<any>;
-export interface Header {
-    number: number;
-    hash?: string;
-    parentHash: string;
-    stateRoot: string;
-    extrinsicsRoot: string;
-    digest: any;
-}
-export interface Block {
-    number: number;
-    hash: string;
-    parentHash: string;
-    /** unix seconds from the `timestamp.set` inherent (or Timestamp.Now storage); undefined when neither is available */
-    timestamp?: number;
-    /** raw SCALE extrinsics (`0x` hex) */
-    extrinsics: string[];
-    header: Header;
-}
-export interface RuntimeVersion {
-    specName: string;
-    implName: string;
-    specVersion: number;
-    implVersion: number;
-    transactionVersion: number;
-    authoringVersion?: number;
-    apis?: any[];
-    [key: string]: any;
-}
-export declare const getFinalizedHead: ({ chain, retries }: ChainOptions) => Promise<string>;
-/** block hash of `number` (latest best block when omitted); `null` when unknown */
-export declare function getBlockHash({ chain, number, retries }: ChainOptions & {
-    number?: number;
-}): Promise<string | null>;
-/** header at `hash` (finalized head when omitted) */
-export declare function getHeader({ chain, hash, retries }: ChainOptions & {
-    hash?: string;
-}): Promise<Header>;
-/** `state_getRuntimeVersion` */
-export declare const getRuntimeVersion: ({ chain, at, retries }: ChainOptions & {
-    at?: string;
-}) => Promise<RuntimeVersion>;
-/**
- * Decode the `timestamp.set` inherent (first bare extrinsic, call index 0, Compact<u64> ms).
- * Returns unix seconds or undefined when the block has no recognisable timestamp inherent.
- */
-export declare function decodeTimestampInherent(extrinsics: string[] | undefined): number | undefined;
-/** Timestamp.Now (u64 ms) at `at` -> unix seconds */
-export declare function getTimestampAt({ chain, at, retries }: ChainOptions & {
-    at?: string;
-}): Promise<number>;
-/** block by `hash` or `number` (finalized head when neither is given), with its timestamp */
-export declare function getBlock({ chain, hash, number, retries }: ChainOptions & {
-    hash?: string;
-    number?: number;
-}): Promise<Block>;
-export declare const getLatestBlock: (options: ChainOptions) => Promise<Block>;
-/**
- * Last block whose timestamp is <= `timestamp` (unix seconds, ms accepted). Brackets the
- * range assuming ~6s blocks then binary searches on Timestamp.Now at each block hash
- * (falls back to the timestamp inherent on nodes with pruned state).
- */
-export declare function getBlockAtTimestamp({ chain, timestamp, retries }: ChainOptions & {
-    timestamp: number;
-}): Promise<Block>;
-export interface StorageOptions extends ChainOptions {
-    /** block hash; latest when omitted */
-    at?: string;
-}
-/** `state_getStorage` for a raw storage key -> `0x` hex value or null */
-export declare function getStorageRaw({ chain, key, at, retries }: StorageOptions & {
-    key: Bytes;
-}): Promise<string | null>;
-/** plain item or a single (double) map entry -> raw `0x` hex value or null */
-export declare function getStorage({ chain, pallet, item, key, hasher, keys, at, retries }: StorageOptions & StorageKeyParams): Promise<string | null>;
-/** `state_queryStorageAt` for many keys -> values in key order (null when unset) */
-export declare function getStorageBatch({ chain, storageKeys, at, chunkSize, retries }: StorageOptions & {
-    storageKeys: string[];
-    chunkSize?: number;
-}): Promise<(string | null)[]>;
-/** one page of `state_getKeysPaged` */
-export declare function getKeysPaged({ chain, prefix, pageSize, startKey, at, retries }: StorageOptions & {
-    prefix: Bytes;
-    pageSize?: number;
-    startKey?: string | null;
-}): Promise<string[]>;
-/** every storage key under `prefix` (paginates `state_getKeysPaged`) */
-export declare function getAllKeys({ chain, prefix, pageSize, at, retries }: StorageOptions & {
-    prefix: Bytes;
-    pageSize?: number;
-}): Promise<string[]>;
-export interface StorageEntry {
-    /** full storage key (`0x` hex) */
-    key: string;
-    /** raw value (`0x` hex) or null */
-    value: string | null;
-    /** key bytes after the pallet/item prefix and the given partial keys (hash ++ raw key for concat hashers) */
-    rest: Buffer;
-}
-/**
- * Every entry of a map (optionally under partial `keys` for double maps) -> [{ key, value, rest }].
- * Use `stripHasher(entry.rest, hasher)` to recover the raw SCALE key of concat hashers.
- */
-export declare function getStorageEntries({ chain, pallet, item, keys, pageSize, at, retries }: StorageOptions & {
-    pallet: string;
-    item: string;
-    keys?: {
-        key: Bytes;
-        hasher?: string;
-    }[];
-    pageSize?: number;
-}): Promise<StorageEntry[]>;
-/** runtime api call (`state_call`), e.g. `stateCall({ chain, method: 'CurrenciesApi_account', data })` -> `0x` hex */
-export declare function stateCall({ chain, method, data, at, retries }: StorageOptions & {
-    method: string;
-    data: Bytes;
-}): Promise<string>;
-export interface AccountInfo {
-    nonce: number;
-    consumers: number;
-    providers: number;
-    sufficients: number;
-    /** balances as decimal bigint strings */
-    free: string;
-    reserved: string;
-    /** `frozen` (new AccountData) / `miscFrozen` (legacy AccountData) */
-    frozen: string;
-    miscFrozen: string;
-    /** 4th balance field: `flags` on new runtimes, `feeFrozen` on legacy ones */
-    feeFrozen: string;
-    flags: string;
-}
-/**
- * frame_system AccountInfo: nonce u32, consumers u32, providers u32, sufficients u32,
- * data { free, reserved, frozen|miscFrozen, flags|feeFrozen }. Balances are u128 on most
- * chains; `balanceBytes: 8` for u64 balance chains (e.g. bittensor), auto-detected from
- * the value length when omitted.
- */
-export declare function decodeAccountInfo(value: Bytes | null | undefined, { balanceBytes }?: {
-    balanceBytes?: number;
-}): AccountInfo;
-/** System.Account of an ss58 address (or raw 32 byte account id) */
-export declare function getSystemAccount({ chain, address, at, balanceBytes, retries }: StorageOptions & {
-    address: string | Uint8Array;
-    balanceBytes?: number;
-}): Promise<AccountInfo>;
-/** free native balance (raw units, decimal string) */
-export declare function getFreeBalance({ chain, address, at, balanceBytes, retries }: StorageOptions & {
-    address: string | Uint8Array;
-    balanceBytes?: number;
-}): Promise<string>;
-/** Balances.TotalIssuance (raw units, decimal string) */
-export declare function getTotalIssuance({ chain, at, pallet, retries }: StorageOptions & {
-    pallet?: string;
-}): Promise<string>;
-export interface OrmlAccountData {
-    free: string;
-    reserved: string;
-    frozen: string;
-}
-/** orml_tokens AccountData: free u128, reserved u128, frozen u128 */
-export declare function decodeOrmlAccountData(value: Bytes | null | undefined): OrmlAccountData;
-/** orml Tokens.Accounts(AccountId: Blake2_128Concat, CurrencyId: Twox64Concat); `currencyId` is the SCALE encoded id (hex / bytes) */
-export declare function getTokensAccount({ chain, address, currencyId, at, pallet, retries }: StorageOptions & {
-    address: string | Uint8Array;
-    currencyId: Bytes;
-    pallet?: string;
-}): Promise<OrmlAccountData>;
-export interface BifrostCurrencyId {
-    variant: string;
-    raw: Buffer;
-    symbol?: string;
-    id?: number;
-    /** mirrors polkadot.js toHuman(), e.g. { Token: 'KSM' } or { VToken2: '0' } */
-    human?: Record<string, string>;
-}
-/** reads one CurrencyId from a ScaleReader */
-declare function bifrostReadCurrencyId(r: ScaleReader): BifrostCurrencyId;
-/** Bifrost CurrencyId SCALE codec (bifrost-primitives) */
-export declare const bifrost: {
-    CURRENCY: Record<string, number>;
-    VARIANT_NAMES: Record<number, string>;
-    TOKEN_SYMBOLS: Record<number, string>;
-    TOKEN_IDS: Record<string, number>;
-    TOKEN2_SYMBOLS: Record<number, string>;
-    /** `encodeCurrencyId('Token', 'KSM')` / `encodeCurrencyId('VToken2', 0)` -> 2 byte SCALE CurrencyId */
-    encodeCurrencyId(variant: string, payload: number | string): Buffer;
-    token: (symbol: string) => Buffer;
-    vToken: (symbol: string) => Buffer;
-    vsToken: (symbol: string) => Buffer;
-    native: (symbol: string) => Buffer;
-    stable: (symbol: string) => Buffer;
-    token2: (id: number) => Buffer;
-    vToken2: (id: number) => Buffer;
-    vsToken2: (id: number) => Buffer;
-    readCurrencyId: typeof bifrostReadCurrencyId;
-    decodeCurrencyId: (value: Bytes) => BifrostCurrencyId;
-};
-export {};