@atomiqlabs/chain-starknet 4.0.0-dev.2 → 4.0.0-dev.22

package/dist/starknet/chain/StarknetAction.js

@@ -1,73 +1,73 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetAction = void 0;
-const StarknetFees_1 = require("./modules/StarknetFees");
-class StarknetAction {
-    constructor(mainSigner, root, instructions = [], gasLimit, feeRate) {
-        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;
-    }
-    estimateFeeRate() {
-        return this.root.Fees.getFeeRate();
-    }
-    addIx(instruction, gasLimit) {
-        this.instructions.push(instruction);
-        this.gas = (0, StarknetFees_1.starknetGasAdd)(this.gas, gasLimit);
-    }
-    add(action) {
-        return this.addAction(action);
-    }
-    addAction(action, index = this.instructions.length) {
-        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;
-    }
-    async tx(feeRate) {
-        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
-            }
-        };
-    }
-    async addToTxs(txs, feeRate) {
-        txs.push(await this.tx(feeRate));
-    }
-    ixsLength() {
-        return this.instructions.length;
-    }
-}
-exports.StarknetAction = StarknetAction;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetAction = void 0;
+const StarknetFees_1 = require("./modules/StarknetFees");
+class StarknetAction {
+    constructor(mainSigner, root, instructions = [], gasLimit, feeRate) {
+        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;
+    }
+    estimateFeeRate() {
+        return this.root.Fees.getFeeRate();
+    }
+    addIx(instruction, gasLimit) {
+        this.instructions.push(instruction);
+        this.gas = (0, StarknetFees_1.starknetGasAdd)(this.gas, gasLimit);
+    }
+    add(action) {
+        return this.addAction(action);
+    }
+    addAction(action, index = this.instructions.length) {
+        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;
+    }
+    async tx(feeRate) {
+        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
+            }
+        };
+    }
+    async addToTxs(txs, feeRate) {
+        txs.push(await this.tx(feeRate));
+    }
+    ixsLength() {
+        return this.instructions.length;
+    }
+}
+exports.StarknetAction = StarknetAction;

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

@@ -1,52 +1,59 @@
-import { Provider, constants } from "starknet";
-import { StarknetTransactions, StarknetTx } from "./modules/StarknetTransactions";
-import { StarknetFees } from "./modules/StarknetFees";
-import { StarknetTokens } from "./modules/StarknetTokens";
-import { StarknetEvents } from "./modules/StarknetEvents";
-import { StarknetSignatures } from "./modules/StarknetSignatures";
-import { StarknetAccounts } from "./modules/StarknetAccounts";
-import { StarknetBlocks } from "./modules/StarknetBlocks";
-import { ChainInterface, TransactionConfirmationOptions } from "@atomiqlabs/base";
-import { StarknetSigner } from "../wallet/StarknetSigner";
-export type StarknetRetryPolicy = {
-    maxRetries?: number;
-    delay?: number;
-    exponential?: boolean;
-};
-export declare class StarknetChainInterface implements ChainInterface {
-    readonly chainId = "STARKNET";
-    readonly provider: Provider;
-    readonly retryPolicy: StarknetRetryPolicy;
-    readonly starknetChainId: constants.StarknetChainId;
-    Fees: StarknetFees;
-    readonly Tokens: StarknetTokens;
-    readonly Transactions: StarknetTransactions;
-    readonly Signatures: StarknetSignatures;
-    readonly Events: StarknetEvents;
-    readonly Accounts: StarknetAccounts;
-    readonly Blocks: StarknetBlocks;
-    protected readonly logger: {
-        debug: (msg: any, ...args: any[]) => void;
-        info: (msg: any, ...args: any[]) => void;
-        warn: (msg: any, ...args: any[]) => void;
-        error: (msg: any, ...args: any[]) => void;
-    };
-    constructor(chainId: constants.StarknetChainId, provider: Provider, retryPolicy?: StarknetRetryPolicy, solanaFeeEstimator?: StarknetFees);
-    getBalance(signer: string, tokenAddress: string): Promise<bigint>;
-    getNativeCurrencyAddress(): string;
-    isValidToken(tokenIdentifier: string): boolean;
-    isValidAddress(address: string): boolean;
-    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
-    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
-    onBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): void;
-    offBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): boolean;
-    randomAddress(): string;
-    randomSigner(): StarknetSigner;
-    sendAndConfirm(signer: StarknetSigner, txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
-    serializeTx(tx: StarknetTx): Promise<string>;
-    deserializeTx(txData: string): Promise<StarknetTx>;
-    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
-    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
-    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<StarknetTx[]>;
-    transfer(signer: StarknetSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
-}
+import { Provider, constants } from "starknet";
+import { StarknetTransactions, StarknetTx } from "./modules/StarknetTransactions";
+import { StarknetFees } from "./modules/StarknetFees";
+import { StarknetTokens } from "./modules/StarknetTokens";
+import { StarknetEvents } from "./modules/StarknetEvents";
+import { StarknetSignatures } from "./modules/StarknetSignatures";
+import { StarknetAccounts } from "./modules/StarknetAccounts";
+import { StarknetBlocks } from "./modules/StarknetBlocks";
+import { ChainInterface, TransactionConfirmationOptions } from "@atomiqlabs/base";
+import { StarknetSigner } from "../wallet/StarknetSigner";
+export type StarknetRetryPolicy = {
+    maxRetries?: number;
+    delay?: number;
+    exponential?: boolean;
+};
+export type StarknetConfig = {
+    getLogChunkSize?: number;
+    getLogForwardBlockRange?: number;
+    maxGetLogKeys?: number;
+    maxParallelCalls?: number;
+};
+export declare class StarknetChainInterface implements ChainInterface {
+    readonly chainId = "STARKNET";
+    readonly provider: Provider;
+    readonly retryPolicy: StarknetRetryPolicy;
+    readonly starknetChainId: constants.StarknetChainId;
+    Fees: StarknetFees;
+    readonly Tokens: StarknetTokens;
+    readonly Transactions: StarknetTransactions;
+    readonly Signatures: StarknetSignatures;
+    readonly Events: StarknetEvents;
+    readonly Accounts: StarknetAccounts;
+    readonly Blocks: StarknetBlocks;
+    protected readonly logger: {
+        debug: (msg: any, ...args: any[]) => void;
+        info: (msg: any, ...args: any[]) => void;
+        warn: (msg: any, ...args: any[]) => void;
+        error: (msg: any, ...args: any[]) => void;
+    };
+    readonly config: StarknetConfig;
+    constructor(chainId: constants.StarknetChainId, provider: Provider, retryPolicy?: StarknetRetryPolicy, feeEstimator?: StarknetFees, options?: StarknetConfig);
+    getBalance(signer: string, tokenAddress: string): Promise<bigint>;
+    getNativeCurrencyAddress(): string;
+    isValidToken(tokenIdentifier: string): boolean;
+    isValidAddress(address: string): boolean;
+    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
+    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
+    onBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): void;
+    offBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): boolean;
+    randomAddress(): string;
+    randomSigner(): StarknetSigner;
+    sendAndConfirm(signer: StarknetSigner, txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    serializeTx(tx: StarknetTx): Promise<string>;
+    deserializeTx(txData: string): Promise<StarknetTx>;
+    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<StarknetTx[]>;
+    transfer(signer: StarknetSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
+}

package/dist/starknet/chain/StarknetChainInterface.js

@@ -1,91 +1,97 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetChainInterface = void 0;
-const starknet_1 = require("starknet");
-const Utils_1 = require("../../utils/Utils");
-const StarknetTransactions_1 = require("./modules/StarknetTransactions");
-const StarknetFees_1 = require("./modules/StarknetFees");
-const StarknetAddresses_1 = require("./modules/StarknetAddresses");
-const StarknetTokens_1 = require("./modules/StarknetTokens");
-const StarknetEvents_1 = require("./modules/StarknetEvents");
-const StarknetSignatures_1 = require("./modules/StarknetSignatures");
-const StarknetAccounts_1 = require("./modules/StarknetAccounts");
-const StarknetBlocks_1 = require("./modules/StarknetBlocks");
-const StarknetSigner_1 = require("../wallet/StarknetSigner");
-const buffer_1 = require("buffer");
-const StarknetKeypairWallet_1 = require("../wallet/StarknetKeypairWallet");
-class StarknetChainInterface {
-    constructor(chainId, provider, retryPolicy, solanaFeeEstimator = new StarknetFees_1.StarknetFees(provider)) {
-        this.chainId = "STARKNET";
-        this.logger = (0, Utils_1.getLogger)("StarknetChainInterface: ");
-        this.starknetChainId = chainId;
-        this.provider = provider;
-        this.retryPolicy = retryPolicy;
-        this.Fees = solanaFeeEstimator;
-        this.Tokens = new StarknetTokens_1.StarknetTokens(this);
-        this.Transactions = new StarknetTransactions_1.StarknetTransactions(this);
-        this.Signatures = new StarknetSignatures_1.StarknetSignatures(this);
-        this.Events = new StarknetEvents_1.StarknetEvents(this);
-        this.Accounts = new StarknetAccounts_1.StarknetAccounts(this);
-        this.Blocks = new StarknetBlocks_1.StarknetBlocks(this);
-    }
-    async getBalance(signer, tokenAddress) {
-        //TODO: For native token we should discount the cost of deploying an account if it is not deployed yet
-        return await this.Tokens.getTokenBalance(signer, tokenAddress);
-    }
-    getNativeCurrencyAddress() {
-        return this.Tokens.getNativeCurrencyAddress();
-    }
-    isValidToken(tokenIdentifier) {
-        return this.Tokens.isValidToken(tokenIdentifier);
-    }
-    isValidAddress(address) {
-        return StarknetAddresses_1.StarknetAddresses.isValidAddress(address);
-    }
-    ///////////////////////////////////
-    //// Callbacks & handlers
-    offBeforeTxReplace(callback) {
-        return true;
-    }
-    onBeforeTxReplace(callback) { }
-    onBeforeTxSigned(callback) {
-        this.Transactions.onBeforeTxSigned(callback);
-    }
-    offBeforeTxSigned(callback) {
-        return this.Transactions.offBeforeTxSigned(callback);
-    }
-    randomAddress() {
-        return (0, Utils_1.toHex)(starknet_1.stark.randomAddress());
-    }
-    randomSigner() {
-        const privateKey = "0x" + buffer_1.Buffer.from(starknet_1.ec.starkCurve.utils.randomPrivateKey()).toString("hex");
-        const wallet = new StarknetKeypairWallet_1.StarknetKeypairWallet(this.provider, privateKey);
-        return new StarknetSigner_1.StarknetSigner(wallet);
-    }
-    ////////////////////////////////////////////
-    //// Transactions
-    sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
-        return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
-    }
-    serializeTx(tx) {
-        return this.Transactions.serializeTx(tx);
-    }
-    deserializeTx(txData) {
-        return this.Transactions.deserializeTx(txData);
-    }
-    getTxIdStatus(txId) {
-        return this.Transactions.getTxIdStatus(txId);
-    }
-    getTxStatus(tx) {
-        return this.Transactions.getTxStatus(tx);
-    }
-    txsTransfer(signer, token, amount, dstAddress, feeRate) {
-        return this.Tokens.txsTransfer(signer, token, amount, dstAddress, feeRate);
-    }
-    async transfer(signer, token, amount, dstAddress, txOptions) {
-        const txs = await this.Tokens.txsTransfer(signer.getAddress(), token, amount, dstAddress, txOptions?.feeRate);
-        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
-        return txId;
-    }
-}
-exports.StarknetChainInterface = StarknetChainInterface;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetChainInterface = void 0;
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../utils/Utils");
+const StarknetTransactions_1 = require("./modules/StarknetTransactions");
+const StarknetFees_1 = require("./modules/StarknetFees");
+const StarknetAddresses_1 = require("./modules/StarknetAddresses");
+const StarknetTokens_1 = require("./modules/StarknetTokens");
+const StarknetEvents_1 = require("./modules/StarknetEvents");
+const StarknetSignatures_1 = require("./modules/StarknetSignatures");
+const StarknetAccounts_1 = require("./modules/StarknetAccounts");
+const StarknetBlocks_1 = require("./modules/StarknetBlocks");
+const StarknetSigner_1 = require("../wallet/StarknetSigner");
+const buffer_1 = require("buffer");
+const StarknetKeypairWallet_1 = require("../wallet/StarknetKeypairWallet");
+class StarknetChainInterface {
+    constructor(chainId, provider, retryPolicy, feeEstimator = new StarknetFees_1.StarknetFees(provider), options) {
+        var _a, _b, _c, _d;
+        this.chainId = "STARKNET";
+        this.logger = (0, Utils_1.getLogger)("StarknetChainInterface: ");
+        this.starknetChainId = chainId;
+        this.provider = provider;
+        this.retryPolicy = retryPolicy;
+        this.config = options ?? {};
+        (_a = this.config).getLogForwardBlockRange ?? (_a.getLogForwardBlockRange = 2000);
+        (_b = this.config).getLogChunkSize ?? (_b.getLogChunkSize = 100);
+        (_c = this.config).maxGetLogKeys ?? (_c.maxGetLogKeys = 64);
+        (_d = this.config).maxParallelCalls ?? (_d.maxParallelCalls = 10);
+        this.Fees = feeEstimator;
+        this.Tokens = new StarknetTokens_1.StarknetTokens(this);
+        this.Transactions = new StarknetTransactions_1.StarknetTransactions(this);
+        this.Signatures = new StarknetSignatures_1.StarknetSignatures(this);
+        this.Events = new StarknetEvents_1.StarknetEvents(this);
+        this.Accounts = new StarknetAccounts_1.StarknetAccounts(this);
+        this.Blocks = new StarknetBlocks_1.StarknetBlocks(this);
+    }
+    async getBalance(signer, tokenAddress) {
+        //TODO: For native token we should discount the cost of deploying an account if it is not deployed yet
+        return await this.Tokens.getTokenBalance(signer, tokenAddress);
+    }
+    getNativeCurrencyAddress() {
+        return this.Tokens.getNativeCurrencyAddress();
+    }
+    isValidToken(tokenIdentifier) {
+        return this.Tokens.isValidToken(tokenIdentifier);
+    }
+    isValidAddress(address) {
+        return StarknetAddresses_1.StarknetAddresses.isValidAddress(address);
+    }
+    ///////////////////////////////////
+    //// Callbacks & handlers
+    offBeforeTxReplace(callback) {
+        return true;
+    }
+    onBeforeTxReplace(callback) { }
+    onBeforeTxSigned(callback) {
+        this.Transactions.onBeforeTxSigned(callback);
+    }
+    offBeforeTxSigned(callback) {
+        return this.Transactions.offBeforeTxSigned(callback);
+    }
+    randomAddress() {
+        return (0, Utils_1.toHex)(starknet_1.stark.randomAddress());
+    }
+    randomSigner() {
+        const privateKey = "0x" + buffer_1.Buffer.from(starknet_1.ec.starkCurve.utils.randomPrivateKey()).toString("hex");
+        const wallet = new StarknetKeypairWallet_1.StarknetKeypairWallet(this.provider, privateKey);
+        return new StarknetSigner_1.StarknetSigner(wallet);
+    }
+    ////////////////////////////////////////////
+    //// Transactions
+    sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
+        return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
+    }
+    serializeTx(tx) {
+        return this.Transactions.serializeTx(tx);
+    }
+    deserializeTx(txData) {
+        return this.Transactions.deserializeTx(txData);
+    }
+    getTxIdStatus(txId) {
+        return this.Transactions.getTxIdStatus(txId);
+    }
+    getTxStatus(tx) {
+        return this.Transactions.getTxStatus(tx);
+    }
+    txsTransfer(signer, token, amount, dstAddress, feeRate) {
+        return this.Tokens.txsTransfer(signer, token, amount, dstAddress, feeRate);
+    }
+    async transfer(signer, token, amount, dstAddress, txOptions) {
+        const txs = await this.Tokens.txsTransfer(signer.getAddress(), token, amount, dstAddress, txOptions?.feeRate);
+        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
+        return txId;
+    }
+}
+exports.StarknetChainInterface = StarknetChainInterface;

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

@@ -1,14 +1,14 @@
-import { Provider } from "starknet";
-import { StarknetChainInterface, StarknetRetryPolicy } from "./StarknetChainInterface";
-export declare class StarknetModule {
-    protected readonly provider: Provider;
-    protected readonly retryPolicy: StarknetRetryPolicy;
-    protected readonly root: StarknetChainInterface;
-    protected readonly logger: {
-        debug: (msg: any, ...args: any[]) => void;
-        info: (msg: any, ...args: any[]) => void;
-        warn: (msg: any, ...args: any[]) => void;
-        error: (msg: any, ...args: any[]) => void;
-    };
-    constructor(root: StarknetChainInterface);
-}
+import { Provider } from "starknet";
+import { StarknetChainInterface, StarknetRetryPolicy } from "./StarknetChainInterface";
+export declare class StarknetModule {
+    protected readonly provider: Provider;
+    protected readonly retryPolicy: StarknetRetryPolicy;
+    protected readonly root: StarknetChainInterface;
+    protected readonly logger: {
+        debug: (msg: any, ...args: any[]) => void;
+        info: (msg: any, ...args: any[]) => void;
+        warn: (msg: any, ...args: any[]) => void;
+        error: (msg: any, ...args: any[]) => void;
+    };
+    constructor(root: StarknetChainInterface);
+}

package/dist/starknet/chain/StarknetModule.js

@@ -1,13 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetModule = void 0;
-const Utils_1 = require("../../utils/Utils");
-class StarknetModule {
-    constructor(root) {
-        this.logger = (0, Utils_1.getLogger)(this.constructor.name + ": ");
-        this.provider = root.provider;
-        this.retryPolicy = root.retryPolicy;
-        this.root = root;
-    }
-}
-exports.StarknetModule = StarknetModule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetModule = void 0;
+const Utils_1 = require("../../utils/Utils");
+class StarknetModule {
+    constructor(root) {
+        this.logger = (0, Utils_1.getLogger)(this.constructor.name + ": ");
+        this.provider = root.provider;
+        this.retryPolicy = root.retryPolicy;
+        this.root = root;
+    }
+}
+exports.StarknetModule = StarknetModule;