@tonappchain/sdk 0.6.1-v3.0.1 → 0.6.1-v3.0.3

package/dist/structs/Struct.d.ts

@@ -0,0 +1,334 @@
+import { SandboxContract } from '@ton/sandbox';
+import type { Address, Cell, Contract, OpenedContract } from '@ton/ton';
+import { AbstractProvider, Addressable, Interface, InterfaceAbi } from 'ethers';
+export interface ContractOpener {
+    open<T extends Contract>(src: T): OpenedContract<T> | SandboxContract<T>;
+    getContractState(address: Address): Promise<{
+        balance: bigint;
+        state: 'active' | 'uninitialized' | 'frozen';
+        code: Buffer | null;
+    }>;
+    closeConnections?: () => unknown;
+}
+export declare enum SimplifiedStatuses {
+    PENDING = "PENDING",
+    FAILED = "FAILED",
+    SUCCESSFUL = "SUCCESSFUL",
+    OPERATION_ID_NOT_FOUND = "OPERATION_ID_NOT_FOUND"
+}
+export declare enum Network {
+    TESTNET = "testnet",
+    MAINNET = "mainnet"
+}
+export declare enum BlockchainType {
+    TAC = "TAC",
+    TON = "TON"
+}
+export declare enum OperationType {
+    PENDING = "PENDING",
+    TON_TAC_TON = "TON-TAC-TON",
+    ROLLBACK = "ROLLBACK",
+    TON_TAC = "TON-TAC",
+    TAC_TON = "TAC-TON",
+    UNKNOWN = "UNKNOWN"
+}
+export type TACParams = {
+    /**
+     * Provider for TAC side. Use your own provider for tests or to increase ratelimit
+     */
+    provider?: AbstractProvider;
+    /**
+     * Address of TAC settings contract. Use only for tests.
+     */
+    settingsAddress?: string | Addressable;
+    /**
+     * ABI of TAC settings contract. Use only for tests.
+     */
+    settingsABI?: Interface | InterfaceAbi;
+    /**
+     * ABI of TAC CCL contract. Use only for tests.
+     */
+    crossChainLayerABI?: Interface | InterfaceAbi;
+    /**
+     * ABI of TAC CrossChainLayerToken contract. Use only for tests.
+     */
+    crossChainLayerTokenABI?: Interface | InterfaceAbi;
+    /**
+     * bytecode of TAC CrossChainLayerToken contract. Use only for tests.
+     */
+    crossChainLayerTokenBytecode?: string;
+    /**
+     * ABI of TAC CrossChainLayerNFT contract. Use only for tests.
+     */
+    crossChainLayerNFTABI?: Interface | InterfaceAbi;
+    /**
+     * bytecode of TAC CrossChainLayerNFT contract. Use only for tests.
+     */
+    crossChainLayerNFTBytecode?: string;
+};
+export type TONParams = {
+    /**
+     * Provider for TON side. Use your own provider for tests or to increase ratelimit
+     */
+    contractOpener?: ContractOpener;
+    /**
+     * Address of TON settings contract. Use only for tests.
+     */
+    settingsAddress?: string;
+};
+export type SDKParams = {
+    /**
+     * TON CHAIN. For your network use Сustom
+     */
+    network: Network;
+    /**
+     * Delay in requests to provider
+     */
+    delay?: number;
+    /**
+     * Custom parameters for the TAC blockchain
+     */
+    TACParams?: TACParams;
+    /**
+     * Custom parameters for the TON blockchain
+     */
+    TONParams?: TONParams;
+    /**
+     * URLs of lite sequencers
+     */
+    customLiteSequencerEndpoints?: string[];
+};
+export declare enum AssetType {
+    NFT = "NFT",
+    FT = "FT"
+}
+export declare enum NFTAddressType {
+    ITEM = "ITEM",
+    COLLECTION = "COLLECTION"
+}
+export type WithAddressFT = {
+    type: AssetType.FT;
+    /**
+     * Address of TAC or TON token.
+     * Empty if sending native TON coin.
+     */
+    address?: string;
+};
+export type WithAddressNFT_Item = {
+    type: AssetType.NFT;
+    /**
+     * Address NFT item token.
+     */
+    address: string;
+};
+export type WithAddressNFT_CollectionItem = {
+    type: AssetType.NFT;
+    /**
+     * Address NFT collection.
+     */
+    collectionAddress: string;
+    /**
+     * Index of NFT item in collection.
+     */
+    itemIndex: bigint;
+};
+export type WithAddressNFT = WithAddressNFT_Item | WithAddressNFT_CollectionItem;
+export type WithAddress = WithAddressFT | WithAddressNFT;
+export type RawAssetBridgingData<NFTFormatRequired extends WithAddressNFT = WithAddressNFT_Item> = {
+    /** Raw format, e.g. 12340000000 (=12.34 tokens if decimals is 9) */
+    rawAmount: bigint;
+} & (WithAddressFT | NFTFormatRequired);
+export type UserFriendlyAssetBridgingData = {
+    /**
+     * User friendly format, e.g. 12.34 tokens
+     * Specified value will be converted automatically to raw format: 12.34 * (10^decimals).
+     * No decimals should be specified.
+     */
+    amount: number;
+    /**
+     * Decimals may be specified manually.
+     * Otherwise, SDK tries to extract them from chain.
+     */
+    decimals?: number;
+} & WithAddress;
+export type AssetBridgingData = RawAssetBridgingData | UserFriendlyAssetBridgingData;
+export type UserWalletBalanceExtended = {
+    exists: true;
+    amount: number;
+    rawAmount: bigint;
+    decimals: number;
+} | {
+    exists: false;
+};
+export type EvmProxyMsg = {
+    evmTargetAddress: string;
+    methodName?: string;
+    encodedParameters?: string;
+    gasLimit?: bigint;
+};
+export type TransactionLinker = {
+    caller: string;
+    shardCount: number;
+    shardsKey: string;
+    timestamp: number;
+    sendTransactionResult?: unknown;
+};
+export type TACSimulationRequest = {
+    tacCallParams: {
+        arguments: string;
+        methodName: string;
+        target: string;
+    };
+    evmValidExecutors: string[];
+    extraData: string;
+    feeAssetAddress: string;
+    shardsKey: string;
+    tonAssets: {
+        amount: string;
+        tokenAddress: string;
+        assetType: string;
+    }[];
+    tonCaller: string;
+};
+export declare enum StageName {
+    COLLECTED_IN_TAC = "collectedInTAC",
+    INCLUDED_IN_TAC_CONSENSUS = "includedInTACConsensus",
+    EXECUTED_IN_TAC = "executedInTAC",
+    COLLECTED_IN_TON = "collectedInTON",
+    INCLUDED_IN_TON_CONSENSUS = "includedInTONConsensus",
+    EXECUTED_IN_TON = "executedInTON"
+}
+export type TransactionData = {
+    hash: string;
+    blockchainType: BlockchainType;
+};
+export type NoteInfo = {
+    content: string;
+    errorName: string;
+    internalMsg: string;
+    internalBytesError: string;
+};
+export type StageData = {
+    success: boolean;
+    timestamp: number;
+    transactions: TransactionData[] | null;
+    note: NoteInfo | null;
+};
+export type StatusInfo = StageData & {
+    stage: StageName;
+};
+export type ProfilingStageData = {
+    exists: boolean;
+    stageData: StageData | null;
+};
+export type InitialCallerInfo = {
+    address: string;
+    blockchainType: BlockchainType;
+};
+export type ValidExecutors = {
+    tac: string[];
+    ton: string[];
+};
+export declare enum TokenSymbol {
+    TAC_SYMBOL = "TAC",
+    TON_SYMBOL = "TON"
+}
+export type GeneralFeeInfo = {
+    protocolFee: string;
+    executorFee: string;
+    tokenFeeSymbol: TokenSymbol;
+};
+export type FeeInfo = {
+    tac: GeneralFeeInfo;
+    ton: GeneralFeeInfo;
+};
+export type MetaInfo = {
+    initialCaller: InitialCallerInfo;
+    validExecutors: ValidExecutors;
+    feeInfo: FeeInfo;
+};
+export type ExecutionStages = {
+    operationType: OperationType;
+    metaInfo: MetaInfo;
+} & Record<StageName, ProfilingStageData>;
+export type ExecutionStagesByOperationId = Record<string, ExecutionStages>;
+export type StatusInfosByOperationId = Record<string, StatusInfo>;
+export type OperationIds = {
+    operationIds: string[];
+};
+export type OperationIdsByShardsKey = Record<string, OperationIds>;
+export type TACSimulationResult = {
+    estimatedGas: bigint;
+    feeParams: {
+        currentBaseFee: string;
+        isEip1559: boolean;
+        suggestedGasPrice: string;
+        suggestedGasTip: string;
+    };
+    message: string;
+    outMessages: {
+        callerAddress: string;
+        operationId: string;
+        payload: string;
+        queryId: number;
+        targetAddress: string;
+        tokensBurned: {
+            amount: string;
+            tokenAddress: string;
+        }[];
+        tokensLocked: {
+            amount: string;
+            tokenAddress: string;
+        }[];
+        nftBurned: {
+            amount: string;
+            tokenAddress: string;
+        }[];
+        nftLocked: {
+            amount: string;
+            tokenAddress: string;
+        }[];
+    }[] | null;
+    simulationError: string;
+    simulationStatus: boolean;
+    suggestedTonExecutionFee: string;
+    suggestedTacExecutionFee: string;
+    debugInfo: {
+        from: string;
+        to: string;
+        callData: string;
+        blockNumber: number;
+    };
+};
+export type FeeParams = {
+    isRoundTrip: boolean;
+    gasLimit: bigint;
+    protocolFee: bigint;
+    evmExecutorFee: bigint;
+    tvmExecutorFee: bigint;
+};
+export type CrossChainTransactionOptions = {
+    forceSend?: boolean;
+    isRoundTrip?: boolean;
+    protocolFee?: bigint;
+    evmValidExecutors?: string[];
+    evmExecutorFee?: bigint;
+    tvmValidExecutors?: string[];
+    tvmExecutorFee?: bigint;
+};
+export type ExecutionFeeEstimationResult = {
+    feeParams: FeeParams;
+    simulation: TACSimulationResult;
+};
+export type CrosschainTx = {
+    evmProxyMsg: EvmProxyMsg;
+    assets?: AssetBridgingData[];
+    options?: CrossChainTransactionOptions;
+};
+export type NFTItemData = {
+    init: boolean;
+    index: number;
+    collectionAddress: Address;
+    ownerAddress: Address | null;
+    content: Cell | null;
+};

package/dist/structs/Struct.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenSymbol = exports.StageName = exports.NFTAddressType = exports.AssetType = exports.OperationType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
+var SimplifiedStatuses;
+(function (SimplifiedStatuses) {
+    SimplifiedStatuses["PENDING"] = "PENDING";
+    SimplifiedStatuses["FAILED"] = "FAILED";
+    SimplifiedStatuses["SUCCESSFUL"] = "SUCCESSFUL";
+    SimplifiedStatuses["OPERATION_ID_NOT_FOUND"] = "OPERATION_ID_NOT_FOUND";
+})(SimplifiedStatuses || (exports.SimplifiedStatuses = SimplifiedStatuses = {}));
+var Network;
+(function (Network) {
+    Network["TESTNET"] = "testnet";
+    Network["MAINNET"] = "mainnet";
+})(Network || (exports.Network = Network = {}));
+var BlockchainType;
+(function (BlockchainType) {
+    BlockchainType["TAC"] = "TAC";
+    BlockchainType["TON"] = "TON";
+})(BlockchainType || (exports.BlockchainType = BlockchainType = {}));
+var OperationType;
+(function (OperationType) {
+    OperationType["PENDING"] = "PENDING";
+    OperationType["TON_TAC_TON"] = "TON-TAC-TON";
+    OperationType["ROLLBACK"] = "ROLLBACK";
+    OperationType["TON_TAC"] = "TON-TAC";
+    OperationType["TAC_TON"] = "TAC-TON";
+    OperationType["UNKNOWN"] = "UNKNOWN";
+})(OperationType || (exports.OperationType = OperationType = {}));
+var AssetType;
+(function (AssetType) {
+    AssetType["NFT"] = "NFT";
+    AssetType["FT"] = "FT";
+})(AssetType || (exports.AssetType = AssetType = {}));
+var NFTAddressType;
+(function (NFTAddressType) {
+    NFTAddressType["ITEM"] = "ITEM";
+    NFTAddressType["COLLECTION"] = "COLLECTION";
+})(NFTAddressType || (exports.NFTAddressType = NFTAddressType = {}));
+var StageName;
+(function (StageName) {
+    StageName["COLLECTED_IN_TAC"] = "collectedInTAC";
+    StageName["INCLUDED_IN_TAC_CONSENSUS"] = "includedInTACConsensus";
+    StageName["EXECUTED_IN_TAC"] = "executedInTAC";
+    StageName["COLLECTED_IN_TON"] = "collectedInTON";
+    StageName["INCLUDED_IN_TON_CONSENSUS"] = "includedInTONConsensus";
+    StageName["EXECUTED_IN_TON"] = "executedInTON";
+})(StageName || (exports.StageName = StageName = {}));
+var TokenSymbol;
+(function (TokenSymbol) {
+    TokenSymbol["TAC_SYMBOL"] = "TAC";
+    TokenSymbol["TON_SYMBOL"] = "TON";
+})(TokenSymbol || (exports.TokenSymbol = TokenSymbol = {}));

package/dist/wrappers/ContentUtils.d.ts

@@ -0,0 +1,25 @@
+import { Cell } from '@ton/ton';
+export declare const ONCHAIN_CONTENT_PREFIX = 0;
+export declare const OFFCHAIN_CONTENT_PREFIX = 1;
+export interface JettonMetadata {
+    uri?: string;
+    name: string;
+    description: string;
+    image?: string;
+    image_data?: string;
+    symbol: string;
+    decimals?: string;
+}
+export type JettonExtendedMetadata = {
+    persistenceType: persistenceType;
+    metadata: {
+        [s in JettonMetaDataKeys]?: string;
+    };
+    isJettonDeployerFaultyOnChainData?: boolean;
+    contentUri?: string;
+};
+export declare function buildJettonOffChainMetadata(contentUri: string): Cell;
+export type JettonMetaDataKeys = 'uri' | 'name' | 'description' | 'image' | 'symbol' | 'image_data' | 'decimals';
+export declare function buildJettonOnchainMetadata(data: JettonMetadata): Cell;
+export type persistenceType = 'none' | 'onchain' | 'offchain_private_domain' | 'offchain_ipfs';
+export declare function readJettonMetadata(contentCell: Cell): Promise<JettonExtendedMetadata>;

package/dist/wrappers/ContentUtils.js

@@ -0,0 +1,160 @@
+"use strict";
+// noinspection TypeScriptValidateTypes
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFFCHAIN_CONTENT_PREFIX = exports.ONCHAIN_CONTENT_PREFIX = void 0;
+exports.buildJettonOffChainMetadata = buildJettonOffChainMetadata;
+exports.buildJettonOnchainMetadata = buildJettonOnchainMetadata;
+exports.readJettonMetadata = readJettonMetadata;
+const sha256_js_1 = require("@aws-crypto/sha256-js");
+const ton_1 = require("@ton/ton");
+const axios_1 = __importDefault(require("axios"));
+const bn_js_1 = __importDefault(require("bn.js"));
+const errors_1 = require("../errors");
+exports.ONCHAIN_CONTENT_PREFIX = 0x00;
+exports.OFFCHAIN_CONTENT_PREFIX = 0x01;
+const SNAKE_PREFIX = 0x00;
+function buildJettonOffChainMetadata(contentUri) {
+    return (0, ton_1.beginCell)().storeInt(exports.OFFCHAIN_CONTENT_PREFIX, 8).storeBuffer(Buffer.from(contentUri, 'ascii')).endCell();
+}
+const jettonOnChainMetadataSpec = {
+    uri: 'ascii',
+    name: 'utf8',
+    description: 'utf8',
+    image: 'ascii',
+    image_data: 'ascii',
+    symbol: 'utf8',
+    decimals: 'utf8',
+};
+const sha256 = (str) => {
+    const sha = new sha256_js_1.Sha256();
+    sha.update(str);
+    return Buffer.from(sha.digestSync());
+};
+function storeSnakeContent(content, isFirst) {
+    const CELL_MAX_SIZE_BYTES = Math.floor((1023 - 8) / 8);
+    const cell = new ton_1.Builder();
+    if (isFirst) {
+        cell.storeUint(SNAKE_PREFIX, 8);
+    }
+    cell.storeBuffer(content.subarray(0, CELL_MAX_SIZE_BYTES));
+    const remainingContent = content.subarray(CELL_MAX_SIZE_BYTES);
+    if (remainingContent.length > 0) {
+        cell.storeRef(storeSnakeContent(remainingContent, false));
+    }
+    return cell.endCell();
+}
+function buildJettonOnchainMetadata(data) {
+    const dict = ton_1.Dictionary.empty();
+    Object.entries(data).forEach(([k, v]) => {
+        if (!jettonOnChainMetadataSpec[k]) {
+            throw (0, errors_1.unsupportedKeyError)(k);
+        }
+        if (!v || v == '' || v == null) {
+            return;
+        }
+        const bufferToStore = Buffer.from(v, jettonOnChainMetadataSpec[k]);
+        dict.set(sha256(k), storeSnakeContent(bufferToStore, true));
+    });
+    return (0, ton_1.beginCell)()
+        .storeInt(exports.ONCHAIN_CONTENT_PREFIX, 8)
+        .storeDict(dict, ton_1.Dictionary.Keys.Buffer(32), ton_1.Dictionary.Values.Cell())
+        .endCell();
+}
+function readSnakeContent(slice, isFirst) {
+    if (isFirst && slice.loadUint(8) !== SNAKE_PREFIX) {
+        throw errors_1.unsupportedFormatError;
+    }
+    if (slice.remainingBits % 8 !== 0) {
+        throw errors_1.notMultiplyOf8Error;
+    }
+    let remainingBytes = Buffer.from('');
+    if (slice.remainingBits != 0) {
+        remainingBytes = slice.loadBuffer(slice.remainingBits / 8);
+    }
+    if (slice.remainingRefs != 0) {
+        const newCell = slice.loadRef();
+        remainingBytes = Buffer.concat([remainingBytes, readSnakeContent(newCell.beginParse(), false)]);
+    }
+    return remainingBytes;
+}
+function parseJettonOnchainMetadata(contentSlice) {
+    // Note that this relies on what is (perhaps) an internal implementation detail:
+    // "sdk" library dict parser converts: key (provided as buffer) => BN(base10)
+    // and upon parsing, it reads it back to a BN(base10)
+    // tl;dr if we want to read the map back to a JSON with string keys, we have to convert BN(10) back to hex
+    const toKey = (str) => BigInt(new bn_js_1.default(str, 'hex').toString(10));
+    const isJettonDeployerFaultyOnChainData = false;
+    const cellDict = contentSlice.loadDict(ton_1.Dictionary.Keys.BigUint(256), ton_1.Dictionary.Values.Cell());
+    const dict = new Map();
+    cellDict.values().forEach((item, index) => {
+        dict.set(cellDict.keys()[index], readSnakeContent(item.beginParse(), true));
+    });
+    const res = {};
+    Object.keys(jettonOnChainMetadataSpec).forEach((k) => {
+        const val = dict
+            .get(toKey(sha256(k).toString('hex')))
+            ?.toString(jettonOnChainMetadataSpec[k]);
+        if (val) {
+            res[k] = val;
+        }
+    });
+    return {
+        metadata: res,
+        isJettonDeployerFaultyOnChainData,
+    };
+}
+async function parseJettonOffchainMetadata(contentSlice) {
+    const remainingBits = contentSlice.remainingBits;
+    if (remainingBits % 8 !== 0) {
+        throw errors_1.notMultiplyOf8Error;
+    }
+    const jsonURI = contentSlice
+        .loadBuffer(remainingBits / 8)
+        .toString('ascii')
+        .replace('ipfs://', 'https://ipfs.io/ipfs/');
+    let metadata = null;
+    let isIpfs = null;
+    try {
+        metadata = (await axios_1.default.get(jsonURI)).data;
+        isIpfs = /(^|\/)ipfs[.:]/.test(jsonURI);
+    }
+    catch {
+        // nothing
+    }
+    return {
+        metadata,
+        isIpfs,
+        contentUri: jsonURI,
+    };
+}
+async function readJettonMetadata(contentCell) {
+    if (contentCell.bits.length <= 0) {
+        return {
+            contentUri: undefined,
+            isJettonDeployerFaultyOnChainData: false,
+            metadata: {},
+            persistenceType: 'none',
+        };
+    }
+    const contentSlice = contentCell.beginParse();
+    switch (contentSlice.loadUint(8)) {
+        case exports.ONCHAIN_CONTENT_PREFIX:
+            return {
+                persistenceType: 'onchain',
+                ...parseJettonOnchainMetadata(contentSlice),
+            };
+        case exports.OFFCHAIN_CONTENT_PREFIX: {
+            const { metadata, isIpfs, contentUri } = await parseJettonOffchainMetadata(contentSlice);
+            return {
+                persistenceType: isIpfs ? 'offchain_ipfs' : 'offchain_private_domain',
+                contentUri,
+                metadata,
+            };
+        }
+        default:
+            throw errors_1.prefixError;
+    }
+}

package/dist/wrappers/HighloadQueryId.d.ts

@@ -0,0 +1,17 @@
+export declare class HighloadQueryId {
+    private shift;
+    private bitnumber;
+    constructor();
+    static fromShiftAndBitNumber(shift: bigint, bitnumber: bigint): HighloadQueryId;
+    getNext(): HighloadQueryId;
+    hasNext(): boolean;
+    getShift(): bigint;
+    getBitNumber(): bigint;
+    getQueryId(): bigint;
+    static fromQueryId(queryId: bigint): HighloadQueryId;
+    static fromSeqno(i: bigint): HighloadQueryId;
+    /**
+     * @return {bigint} [0 .. 8380415]
+     */
+    toSeqno(): bigint;
+}

package/dist/wrappers/HighloadQueryId.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HighloadQueryId = void 0;
+const BIT_NUMBER_SIZE = 10n; // 10 bit
+const SHIFT_SIZE = 13n; // 13 bit
+const MAX_BIT_NUMBER = 1022n;
+const MAX_SHIFT = 8191n; // 2^13 = 8192
+class HighloadQueryId {
+    constructor() {
+        this.shift = 0n;
+        this.bitnumber = 0n;
+    }
+    static fromShiftAndBitNumber(shift, bitnumber) {
+        const q = new HighloadQueryId();
+        q.shift = shift;
+        if (q.shift < 0)
+            throw new Error('invalid shift');
+        if (q.shift > MAX_SHIFT)
+            throw new Error('invalid shift');
+        q.bitnumber = bitnumber;
+        if (q.bitnumber < 0)
+            throw new Error('invalid bitnumber');
+        if (q.bitnumber > MAX_BIT_NUMBER)
+            throw new Error('invalid bitnumber');
+        return q;
+    }
+    getNext() {
+        let newBitnumber = this.bitnumber + 1n;
+        let newShift = this.shift;
+        if (newShift === MAX_SHIFT && newBitnumber > MAX_BIT_NUMBER - 1n) {
+            throw new Error('Overload'); // NOTE: we left one queryId for emergency withdraw
+        }
+        if (newBitnumber > MAX_BIT_NUMBER) {
+            newBitnumber = 0n;
+            newShift += 1n;
+            if (newShift > MAX_SHIFT) {
+                throw new Error('Overload');
+            }
+        }
+        return HighloadQueryId.fromShiftAndBitNumber(newShift, newBitnumber);
+    }
+    hasNext() {
+        const isEnd = this.bitnumber >= MAX_BIT_NUMBER - 1n && this.shift === MAX_SHIFT; // NOTE: we left one queryId for emergency withdraw;
+        return !isEnd;
+    }
+    getShift() {
+        return this.shift;
+    }
+    getBitNumber() {
+        return this.bitnumber;
+    }
+    getQueryId() {
+        return (this.shift << BIT_NUMBER_SIZE) + this.bitnumber;
+    }
+    static fromQueryId(queryId) {
+        const shift = queryId >> BIT_NUMBER_SIZE;
+        const bitnumber = queryId & 1023n;
+        return this.fromShiftAndBitNumber(shift, bitnumber);
+    }
+    static fromSeqno(i) {
+        const shift = i / 1023n;
+        const bitnumber = i % 1023n;
+        return this.fromShiftAndBitNumber(shift, bitnumber);
+    }
+    /**
+     * @return {bigint} [0 .. 8380415]
+     */
+    toSeqno() {
+        return this.bitnumber + this.shift * 1023n;
+    }
+}
+exports.HighloadQueryId = HighloadQueryId;