@tonappchain/sdk 0.5.0

package/dist/sender/SenderFactory.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderFactory = exports.wallets = void 0;
+const ton_1 = require("@ton/ton");
+const ton_crypto_1 = require("ton-crypto");
+const RawSender_1 = require("./RawSender");
+const TonConnectSender_1 = require("./TonConnectSender");
+const errors_1 = require("../errors");
+const Struct_1 = require("../structs/Struct");
+const HighloadWalletV3_1 = require("../wrappers/HighloadWalletV3");
+exports.wallets = {
+    v2r1: ton_1.WalletContractV2R1,
+    v2r2: ton_1.WalletContractV2R2,
+    v3r1: ton_1.WalletContractV3R1,
+    v3r2: ton_1.WalletContractV3R2,
+    v4: ton_1.WalletContractV4,
+    v5r1: ton_1.WalletContractV5R1,
+    highloadV3: HighloadWalletV3_1.HighloadWalletV3,
+};
+class SenderFactory {
+    static async getSender(params) {
+        if ('tonConnect' in params) {
+            return new TonConnectSender_1.TonConnectSender(params.tonConnect);
+        }
+        if (!(params.version in exports.wallets)) {
+            throw (0, errors_1.unknownWalletError)(params.version);
+        }
+        const keypair = await (0, ton_crypto_1.mnemonicToWalletKey)(params.mnemonic.split(' '));
+        const config = {
+            workchain: 0,
+            publicKey: keypair.publicKey,
+            walletId: undefined, // for w5
+            subwalletId: undefined, // for highload v3
+            timeout: undefined, // for highload v3
+        };
+        if (params.version === 'v5r1') {
+            // manual setup of wallet id required to support wallet w5 both on mainnet and testnet
+            config.walletId = {
+                networkGlobalId: params.network === Struct_1.Network.Testnet ? -3 : -239,
+                context: { walletVersion: 'v5r1', workchain: 0, subwalletNumber: params.options?.v5r1?.subwalletNumber ?? 0 },
+            };
+        }
+        if (params.version === 'highloadV3') {
+            config.subwalletId = params.options?.highloadV3?.subwalletId ?? HighloadWalletV3_1.DEFAULT_SUBWALLET_ID;
+            config.timeout = params.options?.highloadV3?.timeout ?? HighloadWalletV3_1.DEFAULT_TIMEOUT;
+        }
+        const wallet = exports.wallets[params.version].create(config);
+        return new RawSender_1.RawSender(wallet, keypair.secretKey);
+    }
+}
+exports.SenderFactory = SenderFactory;

package/dist/sender/TonConnectSender.d.ts

@@ -0,0 +1,10 @@
+import { TonConnectUI } from '@tonconnect/ui';
+import type { ShardTransaction } from '../structs/InternalStruct';
+import { Network } from '../structs/Struct';
+import { SenderAbstraction } from './SenderAbstraction';
+export declare class TonConnectSender implements SenderAbstraction {
+    readonly tonConnect: TonConnectUI;
+    constructor(tonConnect: TonConnectUI);
+    getSenderAddress(): string;
+    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, chain: Network): Promise<void>;
+}

package/dist/sender/TonConnectSender.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonConnectSender = void 0;
+const protocol_1 = require("@tonconnect/protocol");
+const ui_1 = require("@tonconnect/ui");
+const Struct_1 = require("../structs/Struct");
+const SenderAbstraction_1 = require("./SenderAbstraction");
+class TonConnectSender {
+    constructor(tonConnect) {
+        this.tonConnect = tonConnect;
+    }
+    getSenderAddress() {
+        return this.tonConnect.account?.address?.toString() || '';
+    }
+    async sendShardTransaction(shardTransaction, delay, chain) {
+        const messages = [];
+        for (const message of shardTransaction.messages) {
+            messages.push({
+                address: message.address,
+                amount: message.value.toString(),
+                payload: protocol_1.Base64.encode(message.payload.toBoc()).toString(),
+            });
+        }
+        const transaction = {
+            validUntil: shardTransaction.validUntil,
+            messages,
+            network: chain == Struct_1.Network.Testnet ? ui_1.CHAIN.TESTNET : ui_1.CHAIN.MAINNET,
+        };
+        await (0, SenderAbstraction_1.sleep)(delay * 1000);
+        await this.tonConnect.sendTransaction(transaction);
+    }
+}
+exports.TonConnectSender = TonConnectSender;

package/dist/sender/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SenderAbstraction';
+export * from './SenderFactory';

package/dist/sender/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SenderAbstraction"), exports);
+__exportStar(require("./SenderFactory"), exports);

package/dist/structs/InternalStruct.d.ts

@@ -0,0 +1,52 @@
+import { Cell } from '@ton/ton';
+import { ContractOpener, EVMSimulationResults, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, RawAssetBridgingData, StatusInfosByOperationId } from './Struct';
+import { AbstractProvider, ethers, Interface, InterfaceAbi } from 'ethers';
+export type ShardMessage = {
+    address: string;
+    value: bigint;
+    payload: Cell;
+};
+export type ShardTransaction = {
+    validUntil: number;
+    messages: ShardMessage[];
+    network: Network;
+};
+export declare enum AssetOpType {
+    JettonBurn = "JettonBurn",
+    JettonTransfer = "JettonTransfer"
+}
+export type RandomNumberByTimestamp = {
+    timestamp: number;
+    randomNumber: number;
+};
+export type JettonBridgingData = RawAssetBridgingData & {
+    address: string;
+};
+export type JettonTransferData = JettonBridgingData;
+export type JettonBurnData = JettonBridgingData & {
+    notificationReceiverAddress: string;
+};
+export type InternalTONParams = {
+    contractOpener: ContractOpener;
+    jettonProxyAddress: string;
+    crossChainLayerAddress: string;
+    jettonMinterCode: Cell;
+    jettonWalletCode: Cell;
+};
+export type InternalTACParams = {
+    provider: AbstractProvider;
+    settingsAddress: string;
+    tokenUtilsAddress: string;
+    abiCoder: ethers.AbiCoder;
+    crossChainLayerABI: Interface | InterfaceAbi;
+    crossChainLayerAddress: string;
+    crossChainLayerTokenABI: Interface | InterfaceAbi;
+    crossChainLayerTokenBytecode: string;
+};
+export type ResponseBase<T> = {
+    response: T;
+};
+export type StatusesResponse = ResponseBase<StatusInfosByOperationId>;
+export type OperationIdsByShardsKeyResponse = ResponseBase<OperationIdsByShardsKey>;
+export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
+export type EVMSimulationResponse = ResponseBase<EVMSimulationResults>;

package/dist/structs/InternalStruct.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetOpType = void 0;
+var AssetOpType;
+(function (AssetOpType) {
+    AssetOpType["JettonBurn"] = "JettonBurn";
+    AssetOpType["JettonTransfer"] = "JettonTransfer";
+})(AssetOpType || (exports.AssetOpType = AssetOpType = {}));

package/dist/structs/Struct.d.ts

@@ -0,0 +1,210 @@
+import { SandboxContract } from '@ton/sandbox';
+import type { Address, 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 = 0,
+    Failed = 1,
+    Successful = 2,
+    OperationIdNotFound = 3
+}
+export declare enum Network {
+    Testnet = "testnet",
+    Mainnet = "mainnet"
+}
+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;
+};
+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 type WithAddress = {
+    /**
+     * Address of TAC or TON token.
+     * Empty if sending native TON coin.
+     */
+    address?: string;
+};
+export type RawAssetBridgingData = {
+    /** Raw format, e.g. 12340000000 (=12.34 tokens if decimals is 9) */
+    rawAmount: bigint;
+} & WithAddress;
+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 EVMSimulationRequest = {
+    evmCallParams: {
+        arguments: string;
+        methodName: string;
+        target: string;
+    };
+    extraData: string;
+    feeAssetAddress: string;
+    shardsKey: number;
+    tvmAssets: {
+        amount: string;
+        tokenAddress: string;
+    }[];
+    tvmCaller: string;
+};
+export type TransactionData = {
+    hash: string;
+};
+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: string;
+};
+export type ProfilingStageData = {
+    exists: boolean;
+    stageData: StageData | null;
+};
+export type ExecutionStages = {
+    evmMerkleMsgCollected: ProfilingStageData;
+    evmMerkleRootSet: ProfilingStageData;
+    evmMerkleMsgExecuted: ProfilingStageData;
+    tvmMerkleMsgCollected: ProfilingStageData;
+    tvmMerkleMsgExecuted: 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 EVMSimulationResults = {
+    estimatedGas: bigint;
+    estimatedJettonFeeAmount: string;
+    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;
+        }[];
+    }[] | null;
+    simulationError: string;
+    simulationStatus: boolean;
+    debugInfo: {
+        from: string;
+        to: string;
+        callData: string;
+        blockNumber: number;
+    };
+};

package/dist/structs/Struct.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Network = exports.SimplifiedStatuses = void 0;
+var SimplifiedStatuses;
+(function (SimplifiedStatuses) {
+    SimplifiedStatuses[SimplifiedStatuses["Pending"] = 0] = "Pending";
+    SimplifiedStatuses[SimplifiedStatuses["Failed"] = 1] = "Failed";
+    SimplifiedStatuses[SimplifiedStatuses["Successful"] = 2] = "Successful";
+    SimplifiedStatuses[SimplifiedStatuses["OperationIdNotFound"] = 3] = "OperationIdNotFound";
+})(SimplifiedStatuses || (exports.SimplifiedStatuses = SimplifiedStatuses = {}));
+var Network;
+(function (Network) {
+    Network["Testnet"] = "testnet";
+    Network["Mainnet"] = "mainnet";
+})(Network || (exports.Network = Network = {}));

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;