@atomiqlabs/chain-starknet 4.0.0-dev.4 → 4.0.0-dev.40

package/dist/starknet/btcrelay/headers/StarknetBtcHeader.d.ts

@@ -1,31 +1,31 @@
-import { BtcHeader } from "@atomiqlabs/base";
-import { Buffer } from "buffer";
-import { BigNumberish } from "starknet";
-export type StarknetBtcHeaderType = {
-    reversed_version: BigNumberish;
-    previous_blockhash: BigNumberish[];
-    merkle_root: BigNumberish[];
-    reversed_timestamp: BigNumberish;
-    nbits: BigNumberish;
-    nonce: BigNumberish;
-    hash?: Buffer;
-};
-export declare class StarknetBtcHeader implements BtcHeader {
-    reversed_version: number;
-    previous_blockhash: number[];
-    merkle_root: number[];
-    reversed_timestamp: number;
-    nbits: number;
-    nonce: number;
-    hash?: Buffer;
-    constructor(obj: StarknetBtcHeaderType);
-    getMerkleRoot(): Buffer;
-    getNbits(): number;
-    getNonce(): number;
-    getReversedPrevBlockhash(): Buffer;
-    getTimestamp(): number;
-    getVersion(): number;
-    getHash(): Buffer;
-    serialize(): BigNumberish[];
-    static fromSerializedFeltArray(span: BigNumberish[]): StarknetBtcHeader;
-}
+import { BtcHeader } from "@atomiqlabs/base";
+import { Buffer } from "buffer";
+import { BigNumberish } from "starknet";
+export type StarknetBtcHeaderType = {
+    reversed_version: BigNumberish;
+    previous_blockhash: BigNumberish[];
+    merkle_root: BigNumberish[];
+    reversed_timestamp: BigNumberish;
+    nbits: BigNumberish;
+    nonce: BigNumberish;
+    hash?: Buffer;
+};
+export declare class StarknetBtcHeader implements BtcHeader {
+    reversed_version: number;
+    previous_blockhash: number[];
+    merkle_root: number[];
+    reversed_timestamp: number;
+    nbits: number;
+    nonce: number;
+    hash?: Buffer;
+    constructor(obj: StarknetBtcHeaderType);
+    getMerkleRoot(): Buffer;
+    getNbits(): number;
+    getNonce(): number;
+    getReversedPrevBlockhash(): Buffer;
+    getTimestamp(): number;
+    getVersion(): number;
+    getHash(): Buffer;
+    serialize(): BigNumberish[];
+    static fromSerializedFeltArray(span: BigNumberish[]): StarknetBtcHeader;
+}

package/dist/starknet/btcrelay/headers/StarknetBtcHeader.js

@@ -1,74 +1,74 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetBtcHeader = void 0;
-const buffer_1 = require("buffer");
-const Utils_1 = require("../../../utils/Utils");
-const sha2_1 = require("@noble/hashes/sha2");
-class StarknetBtcHeader {
-    constructor(obj) {
-        this.reversed_version = Number(obj.reversed_version);
-        this.previous_blockhash = obj.previous_blockhash.map(val => Number(val));
-        this.merkle_root = obj.merkle_root.map(val => Number(val));
-        this.reversed_timestamp = Number(obj.reversed_timestamp);
-        this.nbits = Number(obj.nbits);
-        this.nonce = Number(obj.nonce);
-        this.hash = obj.hash;
-    }
-    getMerkleRoot() {
-        return (0, Utils_1.u32ArrayToBuffer)(this.merkle_root);
-    }
-    getNbits() {
-        return (0, Utils_1.u32ReverseEndianness)(this.nbits);
-    }
-    getNonce() {
-        return (0, Utils_1.u32ReverseEndianness)(this.nonce);
-    }
-    getReversedPrevBlockhash() {
-        return (0, Utils_1.u32ArrayToBuffer)(this.previous_blockhash);
-    }
-    getTimestamp() {
-        return (0, Utils_1.u32ReverseEndianness)(this.reversed_timestamp);
-    }
-    getVersion() {
-        return (0, Utils_1.u32ReverseEndianness)(this.reversed_version);
-    }
-    getHash() {
-        if (this.hash != null)
-            return this.hash;
-        const buffer = buffer_1.Buffer.alloc(80);
-        buffer.writeUInt32BE(this.reversed_version, 0);
-        (0, Utils_1.u32ArrayToBuffer)(this.previous_blockhash).copy(buffer, 4);
-        (0, Utils_1.u32ArrayToBuffer)(this.merkle_root).copy(buffer, 36);
-        buffer.writeUInt32BE(this.reversed_timestamp, 68);
-        buffer.writeUInt32BE(this.nbits, 72);
-        buffer.writeUInt32BE(this.nonce, 76);
-        return buffer_1.Buffer.from((0, sha2_1.sha256)((0, sha2_1.sha256)(buffer)));
-    }
-    serialize() {
-        return [
-            this.reversed_version,
-            ...this.previous_blockhash,
-            ...this.merkle_root,
-            this.reversed_timestamp,
-            this.nbits,
-            this.nonce
-        ];
-    }
-    static fromSerializedFeltArray(span) {
-        const reversed_version = (0, Utils_1.toHex)(span.shift());
-        const previous_blockhash = span.splice(0, 8).map(Utils_1.toHex);
-        const merkle_root = span.splice(0, 8).map(Utils_1.toHex);
-        const reversed_timestamp = (0, Utils_1.toHex)(span.shift());
-        const nbits = (0, Utils_1.toHex)(span.shift());
-        const nonce = (0, Utils_1.toHex)(span.shift());
-        return new StarknetBtcHeader({
-            reversed_version,
-            previous_blockhash,
-            merkle_root,
-            reversed_timestamp,
-            nbits,
-            nonce
-        });
-    }
-}
-exports.StarknetBtcHeader = StarknetBtcHeader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetBtcHeader = void 0;
+const buffer_1 = require("buffer");
+const Utils_1 = require("../../../utils/Utils");
+const sha2_1 = require("@noble/hashes/sha2");
+class StarknetBtcHeader {
+    constructor(obj) {
+        this.reversed_version = Number(obj.reversed_version);
+        this.previous_blockhash = obj.previous_blockhash.map(val => Number(val));
+        this.merkle_root = obj.merkle_root.map(val => Number(val));
+        this.reversed_timestamp = Number(obj.reversed_timestamp);
+        this.nbits = Number(obj.nbits);
+        this.nonce = Number(obj.nonce);
+        this.hash = obj.hash;
+    }
+    getMerkleRoot() {
+        return (0, Utils_1.u32ArrayToBuffer)(this.merkle_root);
+    }
+    getNbits() {
+        return (0, Utils_1.u32ReverseEndianness)(this.nbits);
+    }
+    getNonce() {
+        return (0, Utils_1.u32ReverseEndianness)(this.nonce);
+    }
+    getReversedPrevBlockhash() {
+        return (0, Utils_1.u32ArrayToBuffer)(this.previous_blockhash);
+    }
+    getTimestamp() {
+        return (0, Utils_1.u32ReverseEndianness)(this.reversed_timestamp);
+    }
+    getVersion() {
+        return (0, Utils_1.u32ReverseEndianness)(this.reversed_version);
+    }
+    getHash() {
+        if (this.hash != null)
+            return this.hash;
+        const buffer = buffer_1.Buffer.alloc(80);
+        buffer.writeUInt32BE(this.reversed_version, 0);
+        (0, Utils_1.u32ArrayToBuffer)(this.previous_blockhash).copy(buffer, 4);
+        (0, Utils_1.u32ArrayToBuffer)(this.merkle_root).copy(buffer, 36);
+        buffer.writeUInt32BE(this.reversed_timestamp, 68);
+        buffer.writeUInt32BE(this.nbits, 72);
+        buffer.writeUInt32BE(this.nonce, 76);
+        return buffer_1.Buffer.from((0, sha2_1.sha256)((0, sha2_1.sha256)(buffer)));
+    }
+    serialize() {
+        return [
+            this.reversed_version,
+            ...this.previous_blockhash,
+            ...this.merkle_root,
+            this.reversed_timestamp,
+            this.nbits,
+            this.nonce
+        ];
+    }
+    static fromSerializedFeltArray(span) {
+        const reversed_version = (0, Utils_1.toHex)(span.shift());
+        const previous_blockhash = span.splice(0, 8).map(Utils_1.toHex);
+        const merkle_root = span.splice(0, 8).map(Utils_1.toHex);
+        const reversed_timestamp = (0, Utils_1.toHex)(span.shift());
+        const nbits = (0, Utils_1.toHex)(span.shift());
+        const nonce = (0, Utils_1.toHex)(span.shift());
+        return new StarknetBtcHeader({
+            reversed_version,
+            previous_blockhash,
+            merkle_root,
+            reversed_timestamp,
+            nbits,
+            nonce
+        });
+    }
+}
+exports.StarknetBtcHeader = StarknetBtcHeader;

package/dist/starknet/btcrelay/headers/StarknetBtcStoredHeader.d.ts

@@ -1,51 +1,51 @@
-import { BtcStoredHeader } from "@atomiqlabs/base";
-import { StarknetBtcHeader, StarknetBtcHeaderType } from "./StarknetBtcHeader";
-import { Buffer } from "buffer";
-import { BigNumberish, Uint256 } from "starknet";
-export type StarknetBtcStoredHeaderType = {
-    blockheader: StarknetBtcHeader | StarknetBtcHeaderType;
-    block_hash: BigNumberish[];
-    chain_work: BigNumberish | Uint256;
-    block_height: BigNumberish;
-    last_diff_adjustment: BigNumberish;
-    prev_block_timestamps: BigNumberish[];
-};
-export declare class StarknetBtcStoredHeader implements BtcStoredHeader<StarknetBtcHeader> {
-    blockheader: StarknetBtcHeader;
-    block_hash: number[];
-    chain_work: Uint256;
-    block_height: number;
-    last_diff_adjustment: number;
-    prev_block_timestamps: number[];
-    constructor(obj: StarknetBtcStoredHeaderType);
-    getBlockheight(): number;
-    getChainWork(): Buffer;
-    getHeader(): StarknetBtcHeader;
-    getLastDiffAdjustment(): number;
-    getPrevBlockTimestamps(): number[];
-    getBlockHash(): Buffer;
-    /**
-     * Computes prevBlockTimestamps for a next block, shifting the old block timestamps to the left & appending
-     *  this block's timestamp to the end
-     *
-     * @private
-     */
-    private computeNextBlockTimestamps;
-    /**
-     * Computes total chain work after a new header with "nbits" is added to the chain
-     *
-     * @param nbits
-     * @private
-     */
-    private computeNextChainWork;
-    /**
-     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
-     *
-     * @param headerTimestamp
-     * @private
-     */
-    private computeNextLastDiffAdjustment;
-    computeNext(header: StarknetBtcHeader): StarknetBtcStoredHeader;
-    serialize(): BigNumberish[];
-    static fromSerializedFeltArray(span: BigNumberish[]): StarknetBtcStoredHeader;
-}
+import { BtcStoredHeader } from "@atomiqlabs/base";
+import { StarknetBtcHeader, StarknetBtcHeaderType } from "./StarknetBtcHeader";
+import { Buffer } from "buffer";
+import { BigNumberish, Uint256 } from "starknet";
+export type StarknetBtcStoredHeaderType = {
+    blockheader: StarknetBtcHeader | StarknetBtcHeaderType;
+    block_hash: BigNumberish[];
+    chain_work: BigNumberish | Uint256;
+    block_height: BigNumberish;
+    last_diff_adjustment: BigNumberish;
+    prev_block_timestamps: BigNumberish[];
+};
+export declare class StarknetBtcStoredHeader implements BtcStoredHeader<StarknetBtcHeader> {
+    blockheader: StarknetBtcHeader;
+    block_hash: number[];
+    chain_work: Uint256;
+    block_height: number;
+    last_diff_adjustment: number;
+    prev_block_timestamps: number[];
+    constructor(obj: StarknetBtcStoredHeaderType);
+    getBlockheight(): number;
+    getChainWork(): Buffer;
+    getHeader(): StarknetBtcHeader;
+    getLastDiffAdjustment(): number;
+    getPrevBlockTimestamps(): number[];
+    getBlockHash(): Buffer;
+    /**
+     * Computes prevBlockTimestamps for a next block, shifting the old block timestamps to the left & appending
+     *  this block's timestamp to the end
+     *
+     * @private
+     */
+    private computeNextBlockTimestamps;
+    /**
+     * Computes total chain work after a new header with "nbits" is added to the chain
+     *
+     * @param nbits
+     * @private
+     */
+    private computeNextChainWork;
+    /**
+     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
+     *
+     * @param headerTimestamp
+     * @private
+     */
+    private computeNextLastDiffAdjustment;
+    computeNext(header: StarknetBtcHeader): StarknetBtcStoredHeader;
+    serialize(): BigNumberish[];
+    static fromSerializedFeltArray(span: BigNumberish[]): StarknetBtcStoredHeader;
+}

package/dist/starknet/btcrelay/headers/StarknetBtcStoredHeader.js

@@ -1,113 +1,113 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetBtcStoredHeader = void 0;
-const base_1 = require("@atomiqlabs/base");
-const StarknetBtcHeader_1 = require("./StarknetBtcHeader");
-const buffer_1 = require("buffer");
-const starknet_1 = require("starknet");
-const Utils_1 = require("../../../utils/Utils");
-class StarknetBtcStoredHeader {
-    constructor(obj) {
-        this.blockheader = obj.blockheader instanceof StarknetBtcHeader_1.StarknetBtcHeader ? obj.blockheader : new StarknetBtcHeader_1.StarknetBtcHeader(obj.blockheader);
-        this.block_hash = obj.block_hash.map(val => Number(val));
-        this.chain_work = (0, Utils_1.isUint256)(obj.chain_work) ? obj.chain_work : starknet_1.cairo.uint256(obj.chain_work);
-        this.block_height = Number(obj.block_height);
-        this.last_diff_adjustment = Number(obj.last_diff_adjustment);
-        this.prev_block_timestamps = obj.prev_block_timestamps.map(val => Number(val));
-    }
-    getBlockheight() {
-        return this.block_height;
-    }
-    getChainWork() {
-        return (0, Utils_1.bigNumberishToBuffer)(this.chain_work, 32);
-    }
-    getHeader() {
-        return this.blockheader;
-    }
-    getLastDiffAdjustment() {
-        return this.last_diff_adjustment;
-    }
-    getPrevBlockTimestamps() {
-        return this.prev_block_timestamps;
-    }
-    getBlockHash() {
-        return (0, Utils_1.u32ArrayToBuffer)(this.block_hash).reverse();
-    }
-    /**
-     * Computes prevBlockTimestamps for a next block, shifting the old block timestamps to the left & appending
-     *  this block's timestamp to the end
-     *
-     * @private
-     */
-    computeNextBlockTimestamps() {
-        const prevBlockTimestamps = [...this.prev_block_timestamps];
-        for (let i = 1; i < 10; i++) {
-            prevBlockTimestamps[i - 1] = prevBlockTimestamps[i];
-        }
-        prevBlockTimestamps[9] = this.blockheader.getTimestamp();
-        return prevBlockTimestamps;
-    }
-    /**
-     * Computes total chain work after a new header with "nbits" is added to the chain
-     *
-     * @param nbits
-     * @private
-     */
-    computeNextChainWork(nbits) {
-        const chainWork = [...this.getChainWork()];
-        base_1.StatePredictorUtils.addInPlace(chainWork, [...base_1.StatePredictorUtils.getChainwork(nbits)]);
-        return buffer_1.Buffer.from(chainWork);
-    }
-    /**
-     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
-     *
-     * @param headerTimestamp
-     * @private
-     */
-    computeNextLastDiffAdjustment(headerTimestamp) {
-        const blockheight = this.block_height + 1;
-        let lastDiffAdjustment = this.last_diff_adjustment;
-        if (blockheight % base_1.StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD === 0) {
-            lastDiffAdjustment = headerTimestamp;
-        }
-        return lastDiffAdjustment;
-    }
-    computeNext(header) {
-        return new StarknetBtcStoredHeader({
-            chain_work: "0x" + this.computeNextChainWork(header.getNbits()).toString("hex"),
-            prev_block_timestamps: this.computeNextBlockTimestamps(),
-            block_height: this.block_height + 1,
-            last_diff_adjustment: this.computeNextLastDiffAdjustment(header.getTimestamp()),
-            block_hash: (0, Utils_1.bufferToU32Array)(header.getHash()),
-            blockheader: header
-        });
-    }
-    serialize() {
-        return [
-            ...this.blockheader.serialize(),
-            ...this.block_hash,
-            this.chain_work.low,
-            this.chain_work.high,
-            this.block_height,
-            this.last_diff_adjustment,
-            ...this.prev_block_timestamps
-        ];
-    }
-    static fromSerializedFeltArray(span) {
-        const blockheader = StarknetBtcHeader_1.StarknetBtcHeader.fromSerializedFeltArray(span);
-        const block_hash = span.splice(0, 8).map(Utils_1.toHex);
-        const chain_work = { low: span.shift(), high: span.shift() };
-        const block_height = (0, Utils_1.toHex)(span.shift());
-        const last_diff_adjustment = (0, Utils_1.toHex)(span.shift());
-        const prev_block_timestamps = span.splice(0, 10).map(Utils_1.toHex);
-        return new StarknetBtcStoredHeader({
-            blockheader,
-            block_hash,
-            chain_work,
-            block_height,
-            last_diff_adjustment,
-            prev_block_timestamps
-        });
-    }
-}
-exports.StarknetBtcStoredHeader = StarknetBtcStoredHeader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetBtcStoredHeader = void 0;
+const base_1 = require("@atomiqlabs/base");
+const StarknetBtcHeader_1 = require("./StarknetBtcHeader");
+const buffer_1 = require("buffer");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../utils/Utils");
+class StarknetBtcStoredHeader {
+    constructor(obj) {
+        this.blockheader = obj.blockheader instanceof StarknetBtcHeader_1.StarknetBtcHeader ? obj.blockheader : new StarknetBtcHeader_1.StarknetBtcHeader(obj.blockheader);
+        this.block_hash = obj.block_hash.map(val => Number(val));
+        this.chain_work = (0, Utils_1.isUint256)(obj.chain_work) ? obj.chain_work : starknet_1.cairo.uint256(obj.chain_work);
+        this.block_height = Number(obj.block_height);
+        this.last_diff_adjustment = Number(obj.last_diff_adjustment);
+        this.prev_block_timestamps = obj.prev_block_timestamps.map(val => Number(val));
+    }
+    getBlockheight() {
+        return this.block_height;
+    }
+    getChainWork() {
+        return (0, Utils_1.bigNumberishToBuffer)(this.chain_work, 32);
+    }
+    getHeader() {
+        return this.blockheader;
+    }
+    getLastDiffAdjustment() {
+        return this.last_diff_adjustment;
+    }
+    getPrevBlockTimestamps() {
+        return this.prev_block_timestamps;
+    }
+    getBlockHash() {
+        return (0, Utils_1.u32ArrayToBuffer)(this.block_hash).reverse();
+    }
+    /**
+     * Computes prevBlockTimestamps for a next block, shifting the old block timestamps to the left & appending
+     *  this block's timestamp to the end
+     *
+     * @private
+     */
+    computeNextBlockTimestamps() {
+        const prevBlockTimestamps = [...this.prev_block_timestamps];
+        for (let i = 1; i < 10; i++) {
+            prevBlockTimestamps[i - 1] = prevBlockTimestamps[i];
+        }
+        prevBlockTimestamps[9] = this.blockheader.getTimestamp();
+        return prevBlockTimestamps;
+    }
+    /**
+     * Computes total chain work after a new header with "nbits" is added to the chain
+     *
+     * @param nbits
+     * @private
+     */
+    computeNextChainWork(nbits) {
+        const chainWork = [...this.getChainWork()];
+        base_1.StatePredictorUtils.addInPlace(chainWork, [...base_1.StatePredictorUtils.getChainwork(nbits)]);
+        return buffer_1.Buffer.from(chainWork);
+    }
+    /**
+     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
+     *
+     * @param headerTimestamp
+     * @private
+     */
+    computeNextLastDiffAdjustment(headerTimestamp) {
+        const blockheight = this.block_height + 1;
+        let lastDiffAdjustment = this.last_diff_adjustment;
+        if (blockheight % base_1.StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD === 0) {
+            lastDiffAdjustment = headerTimestamp;
+        }
+        return lastDiffAdjustment;
+    }
+    computeNext(header) {
+        return new StarknetBtcStoredHeader({
+            chain_work: "0x" + this.computeNextChainWork(header.getNbits()).toString("hex"),
+            prev_block_timestamps: this.computeNextBlockTimestamps(),
+            block_height: this.block_height + 1,
+            last_diff_adjustment: this.computeNextLastDiffAdjustment(header.getTimestamp()),
+            block_hash: (0, Utils_1.bufferToU32Array)(header.getHash()),
+            blockheader: header
+        });
+    }
+    serialize() {
+        return [
+            ...this.blockheader.serialize(),
+            ...this.block_hash,
+            this.chain_work.low,
+            this.chain_work.high,
+            this.block_height,
+            this.last_diff_adjustment,
+            ...this.prev_block_timestamps
+        ];
+    }
+    static fromSerializedFeltArray(span) {
+        const blockheader = StarknetBtcHeader_1.StarknetBtcHeader.fromSerializedFeltArray(span);
+        const block_hash = span.splice(0, 8).map(Utils_1.toHex);
+        const chain_work = { low: span.shift(), high: span.shift() };
+        const block_height = (0, Utils_1.toHex)(span.shift());
+        const last_diff_adjustment = (0, Utils_1.toHex)(span.shift());
+        const prev_block_timestamps = span.splice(0, 10).map(Utils_1.toHex);
+        return new StarknetBtcStoredHeader({
+            blockheader,
+            block_hash,
+            chain_work,
+            block_height,
+            last_diff_adjustment,
+            prev_block_timestamps
+        });
+    }
+}
+exports.StarknetBtcStoredHeader = StarknetBtcStoredHeader;

package/dist/starknet/chain/StarknetAction.d.ts

@@ -1,19 +1,19 @@
-import { Call } from "starknet";
-import { StarknetChainInterface } from "./StarknetChainInterface";
-import { StarknetTx } from "./modules/StarknetTransactions";
-import { StarknetGas } from "./modules/StarknetFees";
-export declare class StarknetAction {
-    gas: StarknetGas;
-    readonly mainSigner: string;
-    private readonly root;
-    private readonly instructions;
-    private feeRate;
-    constructor(mainSigner: string, root: StarknetChainInterface, instructions?: Call[] | Call, gasLimit?: StarknetGas, feeRate?: string);
-    private estimateFeeRate;
-    addIx(instruction: Call, gasLimit?: StarknetGas): void;
-    add(action: StarknetAction): this;
-    addAction(action: StarknetAction, index?: number): this;
-    tx(feeRate?: string): Promise<StarknetTx>;
-    addToTxs(txs: StarknetTx[], feeRate?: string): Promise<void>;
-    ixsLength(): number;
-}
+import { Call } from "starknet";
+import { StarknetChainInterface } from "./StarknetChainInterface";
+import { StarknetTx } from "./modules/StarknetTransactions";
+import { StarknetGas } from "./modules/StarknetFees";
+export declare class StarknetAction {
+    gas: StarknetGas;
+    readonly mainSigner: string;
+    private readonly root;
+    private readonly instructions;
+    private feeRate;
+    constructor(mainSigner: string, root: StarknetChainInterface, instructions?: Call[] | Call, gasLimit?: StarknetGas, feeRate?: string);
+    private estimateFeeRate;
+    addIx(instruction: Call, gasLimit?: StarknetGas): void;
+    add(action: StarknetAction): this;
+    addAction(action: StarknetAction, index?: number): this;
+    tx(feeRate?: string): Promise<StarknetTx>;
+    addToTxs(txs: StarknetTx[], feeRate?: string): Promise<void>;
+    ixsLength(): number;
+}