@atomiqlabs/chain-starknet 4.0.0-dev.12 → 4.0.0-dev.13

package/src/starknet/btcrelay/headers/StarknetBtcHeader.ts

@@ -1,101 +1,101 @@
-import {BtcHeader} from "@atomiqlabs/base";
-import {Buffer} from "buffer";
-import {BigNumberish} from "starknet";
-import {toHex, u32ArrayToBuffer, u32ReverseEndianness} from "../../../utils/Utils";
-import {sha256} from "@noble/hashes/sha2";
-
-export type StarknetBtcHeaderType = {
-    reversed_version: BigNumberish;
-    previous_blockhash: BigNumberish[];
-    merkle_root: BigNumberish[];
-    reversed_timestamp: BigNumberish;
-    nbits: BigNumberish;
-    nonce: BigNumberish;
-    hash?: Buffer
-}
-
-export 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) {
-        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(): Buffer {
-        return u32ArrayToBuffer(this.merkle_root);
-    }
-
-    getNbits(): number {
-        return u32ReverseEndianness(this.nbits);
-    }
-
-    getNonce(): number {
-        return u32ReverseEndianness(this.nonce);
-    }
-
-    getReversedPrevBlockhash(): Buffer {
-        return u32ArrayToBuffer(this.previous_blockhash);
-    }
-
-    getTimestamp(): number {
-        return u32ReverseEndianness(this.reversed_timestamp);
-    }
-
-    getVersion(): number {
-        return u32ReverseEndianness(this.reversed_version);
-    }
-
-    getHash(): Buffer {
-        if(this.hash!=null) return this.hash;
-        const buffer = Buffer.alloc(80);
-        buffer.writeUInt32BE(this.reversed_version, 0);
-        u32ArrayToBuffer(this.previous_blockhash).copy(buffer, 4);
-        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.from(sha256(sha256(buffer)));
-    }
-
-    serialize(): BigNumberish[] {
-        return [
-            this.reversed_version,
-            ...this.previous_blockhash,
-            ...this.merkle_root,
-            this.reversed_timestamp,
-            this.nbits,
-            this.nonce
-        ];
-    }
-
-    static fromSerializedFeltArray(span: BigNumberish[]): StarknetBtcHeader {
-        const reversed_version = toHex(span.shift());
-        const previous_blockhash = span.splice(0, 8).map(toHex);
-        const merkle_root = span.splice(0, 8).map(toHex);
-        const reversed_timestamp = toHex(span.shift());
-        const nbits = toHex(span.shift());
-        const nonce = toHex(span.shift());
-        return new StarknetBtcHeader({
-            reversed_version,
-            previous_blockhash,
-            merkle_root,
-            reversed_timestamp,
-            nbits,
-            nonce
-        });
-    }
-
+import {BtcHeader} from "@atomiqlabs/base";
+import {Buffer} from "buffer";
+import {BigNumberish} from "starknet";
+import {toHex, u32ArrayToBuffer, u32ReverseEndianness} from "../../../utils/Utils";
+import {sha256} from "@noble/hashes/sha2";
+
+export type StarknetBtcHeaderType = {
+    reversed_version: BigNumberish;
+    previous_blockhash: BigNumberish[];
+    merkle_root: BigNumberish[];
+    reversed_timestamp: BigNumberish;
+    nbits: BigNumberish;
+    nonce: BigNumberish;
+    hash?: Buffer
+}
+
+export 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) {
+        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(): Buffer {
+        return u32ArrayToBuffer(this.merkle_root);
+    }
+
+    getNbits(): number {
+        return u32ReverseEndianness(this.nbits);
+    }
+
+    getNonce(): number {
+        return u32ReverseEndianness(this.nonce);
+    }
+
+    getReversedPrevBlockhash(): Buffer {
+        return u32ArrayToBuffer(this.previous_blockhash);
+    }
+
+    getTimestamp(): number {
+        return u32ReverseEndianness(this.reversed_timestamp);
+    }
+
+    getVersion(): number {
+        return u32ReverseEndianness(this.reversed_version);
+    }
+
+    getHash(): Buffer {
+        if(this.hash!=null) return this.hash;
+        const buffer = Buffer.alloc(80);
+        buffer.writeUInt32BE(this.reversed_version, 0);
+        u32ArrayToBuffer(this.previous_blockhash).copy(buffer, 4);
+        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.from(sha256(sha256(buffer)));
+    }
+
+    serialize(): BigNumberish[] {
+        return [
+            this.reversed_version,
+            ...this.previous_blockhash,
+            ...this.merkle_root,
+            this.reversed_timestamp,
+            this.nbits,
+            this.nonce
+        ];
+    }
+
+    static fromSerializedFeltArray(span: BigNumberish[]): StarknetBtcHeader {
+        const reversed_version = toHex(span.shift());
+        const previous_blockhash = span.splice(0, 8).map(toHex);
+        const merkle_root = span.splice(0, 8).map(toHex);
+        const reversed_timestamp = toHex(span.shift());
+        const nbits = toHex(span.shift());
+        const nonce = toHex(span.shift());
+        return new StarknetBtcHeader({
+            reversed_version,
+            previous_blockhash,
+            merkle_root,
+            reversed_timestamp,
+            nbits,
+            nonce
+        });
+    }
+
 }

package/src/starknet/btcrelay/headers/StarknetBtcStoredHeader.ts

@@ -1,142 +1,142 @@
-import {BtcStoredHeader, StatePredictorUtils} from "@atomiqlabs/base";
-import {StarknetBtcHeader, StarknetBtcHeaderType} from "./StarknetBtcHeader";
-import {Buffer} from "buffer";
-import {BigNumberish, cairo, Uint256} from "starknet";
-import {bigNumberishToBuffer, bufferToU32Array, u32ArrayToBuffer, isUint256, toHex} from "../../../utils/Utils";
-
-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 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) {
-        this.blockheader = obj.blockheader instanceof StarknetBtcHeader ? obj.blockheader : new StarknetBtcHeader(obj.blockheader);
-        this.block_hash = obj.block_hash.map(val => Number(val));
-        this.chain_work = isUint256(obj.chain_work) ? obj.chain_work : 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(): number {
-        return this.block_height;
-    }
-
-    getChainWork(): Buffer {
-        return bigNumberishToBuffer(this.chain_work, 32);
-    }
-
-    getHeader(): StarknetBtcHeader {
-        return this.blockheader;
-    }
-
-    getLastDiffAdjustment(): number {
-        return this.last_diff_adjustment;
-    }
-
-    getPrevBlockTimestamps(): number[] {
-        return this.prev_block_timestamps;
-    }
-
-    getBlockHash(): Buffer {
-        return 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
-     */
-    private computeNextBlockTimestamps(): number[] {
-        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
-     */
-    private computeNextChainWork(nbits: number): Buffer {
-        const chainWork = [...this.getChainWork()];
-        StatePredictorUtils.addInPlace(chainWork, [...StatePredictorUtils.getChainwork(nbits)]);
-        return Buffer.from(chainWork);
-    }
-
-    /**
-     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
-     *
-     * @param headerTimestamp
-     * @private
-     */
-    private computeNextLastDiffAdjustment(headerTimestamp: number) {
-        const blockheight = this.block_height+1;
-
-        let lastDiffAdjustment = this.last_diff_adjustment;
-        if(blockheight % StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD === 0) {
-            lastDiffAdjustment = headerTimestamp;
-        }
-
-        return lastDiffAdjustment;
-    }
-
-    computeNext(header: StarknetBtcHeader): StarknetBtcStoredHeader {
-        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: bufferToU32Array(header.getHash()),
-            blockheader: header
-        });
-    }
-
-    serialize(): BigNumberish[] {
-        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: BigNumberish[]): StarknetBtcStoredHeader {
-        const blockheader = StarknetBtcHeader.fromSerializedFeltArray(span);
-        const block_hash = span.splice(0, 8).map(toHex);
-        const chain_work = {low: span.shift(), high: span.shift()};
-        const block_height = toHex(span.shift());
-        const last_diff_adjustment = toHex(span.shift());
-        const prev_block_timestamps = span.splice(0, 10).map(toHex);
-        return new StarknetBtcStoredHeader({
-            blockheader,
-            block_hash,
-            chain_work,
-            block_height,
-            last_diff_adjustment,
-            prev_block_timestamps
-        });
-    }
-
+import {BtcStoredHeader, StatePredictorUtils} from "@atomiqlabs/base";
+import {StarknetBtcHeader, StarknetBtcHeaderType} from "./StarknetBtcHeader";
+import {Buffer} from "buffer";
+import {BigNumberish, cairo, Uint256} from "starknet";
+import {bigNumberishToBuffer, bufferToU32Array, u32ArrayToBuffer, isUint256, toHex} from "../../../utils/Utils";
+
+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 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) {
+        this.blockheader = obj.blockheader instanceof StarknetBtcHeader ? obj.blockheader : new StarknetBtcHeader(obj.blockheader);
+        this.block_hash = obj.block_hash.map(val => Number(val));
+        this.chain_work = isUint256(obj.chain_work) ? obj.chain_work : 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(): number {
+        return this.block_height;
+    }
+
+    getChainWork(): Buffer {
+        return bigNumberishToBuffer(this.chain_work, 32);
+    }
+
+    getHeader(): StarknetBtcHeader {
+        return this.blockheader;
+    }
+
+    getLastDiffAdjustment(): number {
+        return this.last_diff_adjustment;
+    }
+
+    getPrevBlockTimestamps(): number[] {
+        return this.prev_block_timestamps;
+    }
+
+    getBlockHash(): Buffer {
+        return 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
+     */
+    private computeNextBlockTimestamps(): number[] {
+        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
+     */
+    private computeNextChainWork(nbits: number): Buffer {
+        const chainWork = [...this.getChainWork()];
+        StatePredictorUtils.addInPlace(chainWork, [...StatePredictorUtils.getChainwork(nbits)]);
+        return Buffer.from(chainWork);
+    }
+
+    /**
+     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
+     *
+     * @param headerTimestamp
+     * @private
+     */
+    private computeNextLastDiffAdjustment(headerTimestamp: number) {
+        const blockheight = this.block_height+1;
+
+        let lastDiffAdjustment = this.last_diff_adjustment;
+        if(blockheight % StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD === 0) {
+            lastDiffAdjustment = headerTimestamp;
+        }
+
+        return lastDiffAdjustment;
+    }
+
+    computeNext(header: StarknetBtcHeader): StarknetBtcStoredHeader {
+        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: bufferToU32Array(header.getHash()),
+            blockheader: header
+        });
+    }
+
+    serialize(): BigNumberish[] {
+        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: BigNumberish[]): StarknetBtcStoredHeader {
+        const blockheader = StarknetBtcHeader.fromSerializedFeltArray(span);
+        const block_hash = span.splice(0, 8).map(toHex);
+        const chain_work = {low: span.shift(), high: span.shift()};
+        const block_height = toHex(span.shift());
+        const last_diff_adjustment = toHex(span.shift());
+        const prev_block_timestamps = span.splice(0, 10).map(toHex);
+        return new StarknetBtcStoredHeader({
+            blockheader,
+            block_hash,
+            chain_work,
+            block_height,
+            last_diff_adjustment,
+            prev_block_timestamps
+        });
+    }
+
 }

package/src/starknet/chain/StarknetAction.ts

@@ -1,85 +1,85 @@
-import {Call} from "starknet";
-import {StarknetChainInterface} from "./StarknetChainInterface";
-import {StarknetTx} from "./modules/StarknetTransactions";
-import {StarknetGas, starknetGasAdd} from "./modules/StarknetFees";
-
-export class StarknetAction {
-
-    gas: StarknetGas;
-    readonly mainSigner: string;
-    private readonly root: StarknetChainInterface;
-    private readonly instructions: Call[];
-    private feeRate: string;
-
-    constructor(
-        mainSigner: string,
-        root: StarknetChainInterface,
-        instructions: Call[] | Call = [],
-        gasLimit?: StarknetGas,
-        feeRate?: string
-    ) {
-        this.mainSigner = mainSigner;
-        this.root = root;
-        this.instructions = Array.isArray(instructions) ? instructions : [instructions];
-        this.gas = {
-            l1Gas: gasLimit?.l1Gas ?? 0,
-            l2Gas: gasLimit?.l2Gas ?? 0,
-            l1DataGas: gasLimit?.l1DataGas ?? 0,
-        };
-        this.feeRate = feeRate;
-    }
-
-    private estimateFeeRate(): Promise<string> {
-        return this.root.Fees.getFeeRate();
-    }
-
-    public addIx(instruction: Call, gasLimit?: StarknetGas) {
-        this.instructions.push(instruction);
-        this.gas = starknetGasAdd(this.gas, gasLimit);
-    }
-
-    public add(action: StarknetAction): this {
-        return this.addAction(action);
-    }
-
-    public addAction(action: StarknetAction, index: number = this.instructions.length): this {
-        if(action.mainSigner!==this.mainSigner) throw new Error("Actions need to have the same signer!");
-        if(this.gas.l1Gas==null && action.gas.l1Gas!=null) this.gas.l1Gas = action.gas.l1Gas;
-        if(this.gas.l2Gas==null && action.gas.l2Gas!=null) this.gas.l2Gas = action.gas.l2Gas;
-        if(this.gas.l1DataGas==null && action.gas.l1DataGas!=null) this.gas.l1DataGas = action.gas.l1DataGas;
-        if(this.gas.l1Gas!=null && action.gas.l1Gas!=null) this.gas.l1Gas += action.gas.l1Gas;
-        if(this.gas.l2Gas!=null && action.gas.l2Gas!=null) this.gas.l2Gas += action.gas.l2Gas;
-        if(this.gas.l1DataGas!=null && action.gas.l1DataGas!=null) this.gas.l1DataGas += action.gas.l1DataGas;
-        this.instructions.splice(index, 0, ...action.instructions);
-        if(this.feeRate==null) this.feeRate = action.feeRate;
-        return this;
-    }
-
-    public async tx(feeRate?: string): Promise<StarknetTx> {
-        if(feeRate==null) feeRate = this.feeRate;
-        if(feeRate==null) feeRate = await this.estimateFeeRate();
-
-        return {
-            type: "INVOKE",
-            tx: this.instructions,
-            details: {
-                ...this.root.Fees.getFeeDetails(this.gas, feeRate),
-                walletAddress: this.mainSigner,
-                cairoVersion: "1",
-                chainId: this.root.starknetChainId,
-                nonce: null,
-                accountDeploymentData: [],
-                skipValidate: false
-            }
-        };
-    }
-
-    public async addToTxs(txs: StarknetTx[], feeRate?: string): Promise<void> {
-        txs.push(await this.tx(feeRate));
-    }
-
-    public ixsLength(): number {
-        return this.instructions.length;
-    }
-
-}
+import {Call} from "starknet";
+import {StarknetChainInterface} from "./StarknetChainInterface";
+import {StarknetTx} from "./modules/StarknetTransactions";
+import {StarknetGas, starknetGasAdd} from "./modules/StarknetFees";
+
+export class StarknetAction {
+
+    gas: StarknetGas;
+    readonly mainSigner: string;
+    private readonly root: StarknetChainInterface;
+    private readonly instructions: Call[];
+    private feeRate: string;
+
+    constructor(
+        mainSigner: string,
+        root: StarknetChainInterface,
+        instructions: Call[] | Call = [],
+        gasLimit?: StarknetGas,
+        feeRate?: string
+    ) {
+        this.mainSigner = mainSigner;
+        this.root = root;
+        this.instructions = Array.isArray(instructions) ? instructions : [instructions];
+        this.gas = {
+            l1Gas: gasLimit?.l1Gas ?? 0,
+            l2Gas: gasLimit?.l2Gas ?? 0,
+            l1DataGas: gasLimit?.l1DataGas ?? 0,
+        };
+        this.feeRate = feeRate;
+    }
+
+    private estimateFeeRate(): Promise<string> {
+        return this.root.Fees.getFeeRate();
+    }
+
+    public addIx(instruction: Call, gasLimit?: StarknetGas) {
+        this.instructions.push(instruction);
+        this.gas = starknetGasAdd(this.gas, gasLimit);
+    }
+
+    public add(action: StarknetAction): this {
+        return this.addAction(action);
+    }
+
+    public addAction(action: StarknetAction, index: number = this.instructions.length): this {
+        if(action.mainSigner!==this.mainSigner) throw new Error("Actions need to have the same signer!");
+        if(this.gas.l1Gas==null && action.gas.l1Gas!=null) this.gas.l1Gas = action.gas.l1Gas;
+        if(this.gas.l2Gas==null && action.gas.l2Gas!=null) this.gas.l2Gas = action.gas.l2Gas;
+        if(this.gas.l1DataGas==null && action.gas.l1DataGas!=null) this.gas.l1DataGas = action.gas.l1DataGas;
+        if(this.gas.l1Gas!=null && action.gas.l1Gas!=null) this.gas.l1Gas += action.gas.l1Gas;
+        if(this.gas.l2Gas!=null && action.gas.l2Gas!=null) this.gas.l2Gas += action.gas.l2Gas;
+        if(this.gas.l1DataGas!=null && action.gas.l1DataGas!=null) this.gas.l1DataGas += action.gas.l1DataGas;
+        this.instructions.splice(index, 0, ...action.instructions);
+        if(this.feeRate==null) this.feeRate = action.feeRate;
+        return this;
+    }
+
+    public async tx(feeRate?: string): Promise<StarknetTx> {
+        if(feeRate==null) feeRate = this.feeRate;
+        if(feeRate==null) feeRate = await this.estimateFeeRate();
+
+        return {
+            type: "INVOKE",
+            tx: this.instructions,
+            details: {
+                ...this.root.Fees.getFeeDetails(this.gas, feeRate),
+                walletAddress: this.mainSigner,
+                cairoVersion: "1",
+                chainId: this.root.starknetChainId,
+                nonce: null,
+                accountDeploymentData: [],
+                skipValidate: false
+            }
+        };
+    }
+
+    public async addToTxs(txs: StarknetTx[], feeRate?: string): Promise<void> {
+        txs.push(await this.tx(feeRate));
+    }
+
+    public ixsLength(): number {
+        return this.instructions.length;
+    }
+
+}