@atomiqlabs/chain-starknet 1.0.0-beta.0

package/dist/utils/Utils.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLastIndex = exports.parseInitFunctionCalldata = exports.poseidonHashRange = exports.bufferToByteArray = exports.bufferToBytes31Span = exports.bytes31SpanToBuffer = exports.toBigInt = exports.bigNumberishToBuffer = exports.u32ReverseEndianness = exports.bufferToU32Array = exports.u32ArrayToBuffer = exports.calculateHash = exports.toHex = exports.tryWithRetries = exports.getLogger = exports.onceAsync = exports.timeoutPromise = exports.isUint256 = void 0;
+const starknet_types_07_1 = require("starknet-types-07");
+const starknet_1 = require("starknet");
+const buffer_1 = require("buffer");
+const StarknetSwapData_1 = require("../starknet/swaps/StarknetSwapData");
+function isUint256(val) {
+    return val.low != null && val.high != null;
+}
+exports.isUint256 = isUint256;
+function timeoutPromise(timeoutMillis, abortSignal) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(resolve, timeoutMillis);
+        if (abortSignal != null)
+            abortSignal.addEventListener("abort", () => {
+                clearTimeout(timeout);
+                reject(new Error("Aborted"));
+            });
+    });
+}
+exports.timeoutPromise = timeoutPromise;
+function onceAsync(executor) {
+    let promise;
+    return () => {
+        if (promise == null) {
+            promise = executor();
+            return promise;
+        }
+        else {
+            return promise.catch(() => promise = executor());
+        }
+    };
+}
+exports.onceAsync = onceAsync;
+function getLogger(prefix) {
+    return {
+        debug: (msg, ...args) => console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => console.error(prefix + msg, ...args)
+    };
+}
+exports.getLogger = getLogger;
+const logger = getLogger("Utils: ");
+async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
+    retryPolicy = retryPolicy || {};
+    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
+    retryPolicy.delay = retryPolicy.delay || 500;
+    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
+    let err = null;
+    for (let i = 0; i < retryPolicy.maxRetries; i++) {
+        try {
+            const resp = await func();
+            return resp;
+        }
+        catch (e) {
+            if (errorAllowed != null && errorAllowed(e))
+                throw e;
+            err = e;
+            logger.error("tryWithRetries(): error on try number: " + i, e);
+        }
+        if (abortSignal != null && abortSignal.aborted)
+            throw new Error("Aborted");
+        if (i !== retryPolicy.maxRetries - 1) {
+            await timeoutPromise(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
+        }
+    }
+    throw err;
+}
+exports.tryWithRetries = tryWithRetries;
+function toHex(value, length = 64) {
+    if (value == null)
+        return null;
+    switch (typeof (value)) {
+        case "string":
+            if (value.startsWith("0x")) {
+                return "0x" + value.slice(2).padStart(length, "0");
+            }
+            else {
+                return "0x" + BigInt(value).toString(16).padStart(length, "0");
+            }
+        case "number":
+        case "bigint":
+            return "0x" + value.toString(16).padStart(length, "0");
+    }
+    return "0x" + value.toString("hex").padStart(length, "0");
+}
+exports.toHex = toHex;
+function calculateHash(tx) {
+    const commonData = {
+        version: tx.details.version,
+        maxFee: tx.details.maxFee,
+        chainId: tx.details.chainId,
+        nonce: tx.details.nonce,
+        accountDeploymentData: tx.details.version === "0x3" ? tx.details.accountDeploymentData : null,
+        nonceDataAvailabilityMode: tx.details.version === "0x3" ? starknet_types_07_1.EDAMode[tx.details.nonceDataAvailabilityMode] : null,
+        feeDataAvailabilityMode: tx.details.version === "0x3" ? starknet_types_07_1.EDAMode[tx.details.feeDataAvailabilityMode] : null,
+        resourceBounds: tx.details.version === "0x3" ? tx.details.resourceBounds : null,
+        tip: tx.details.version === "0x3" ? tx.details.tip : null,
+        paymasterData: tx.details.version === "0x3" ? tx.details.paymasterData : null
+    };
+    switch (tx.type) {
+        case "INVOKE":
+            const invokeData = starknet_1.CallData.compile(tx.signed.calldata);
+            return tx.txId = starknet_1.hash.calculateInvokeTransactionHash({
+                senderAddress: tx.details.walletAddress,
+                compiledCalldata: invokeData,
+                ...commonData
+            });
+        case "DEPLOY_ACCOUNT":
+            const deployAccountData = starknet_1.CallData.compile(tx.signed.constructorCalldata);
+            return tx.txId = starknet_1.hash.calculateDeployAccountTransactionHash({
+                contractAddress: tx.tx.contractAddress,
+                classHash: tx.signed.classHash,
+                constructorCalldata: deployAccountData,
+                compiledConstructorCalldata: deployAccountData,
+                salt: tx.signed.addressSalt,
+                ...commonData
+            });
+        default:
+            throw new Error("Unsupported tx type!");
+    }
+}
+exports.calculateHash = calculateHash;
+function u32ArrayToBuffer(arr) {
+    const buffer = buffer_1.Buffer.alloc(4 * arr.length);
+    for (let i = 0; i < arr.length; i++) {
+        buffer.writeUInt32BE(Number(arr[i]), i * 4);
+    }
+    return buffer;
+}
+exports.u32ArrayToBuffer = u32ArrayToBuffer;
+function bufferToU32Array(buffer) {
+    const result = [];
+    for (let i = 0; i < buffer.length; i += 4) {
+        result.push(buffer.readUInt32BE(i));
+    }
+    return result;
+}
+exports.bufferToU32Array = bufferToU32Array;
+function u32ReverseEndianness(value) {
+    const valueBN = BigInt(value);
+    return Number(((valueBN & 0xffn) << 24n) |
+        ((valueBN & 0xff00n) << 8n) |
+        ((valueBN >> 8n) & 0xff00n) |
+        ((valueBN >> 24n) & 0xffn));
+}
+exports.u32ReverseEndianness = u32ReverseEndianness;
+function bigNumberishToBuffer(value, length) {
+    if (isUint256(value)) {
+        return buffer_1.Buffer.concat([bigNumberishToBuffer(value.high, 16), bigNumberishToBuffer(value.low, 16)]);
+    }
+    if (typeof (value) === "string") {
+        if (value.startsWith("0x")) {
+            value = value.slice(2);
+        }
+        else {
+            value = BigInt(value).toString(16);
+        }
+    }
+    else {
+        value = value.toString(16);
+    }
+    const buff = buffer_1.Buffer.from(value.padStart(length * 2, "0"), "hex");
+    if (buff.length > length)
+        return buff.subarray(buff.length - length);
+    return buff;
+}
+exports.bigNumberishToBuffer = bigNumberishToBuffer;
+function toBigInt(value) {
+    if (value == null)
+        return null;
+    if (isUint256(value)) {
+        return (toBigInt(value.high) << 128n) | toBigInt(value.low);
+    }
+    if (typeof (value) === "string") {
+        if (!value.startsWith("0x"))
+            value = "0x" + value;
+        return BigInt(value);
+    }
+    if (typeof (value) === "bigint") {
+        return value;
+    }
+    return BigInt(value);
+}
+exports.toBigInt = toBigInt;
+function bytes31SpanToBuffer(span, length) {
+    const buffers = [];
+    const numFullBytes31 = Math.floor(length / 31);
+    const additionalBytes = length - (numFullBytes31 * 31);
+    const requiredSpanLength = numFullBytes31 + (additionalBytes === 0 ? 0 : 1);
+    if (span.length < requiredSpanLength)
+        throw new Error("Not enough bytes in the felt array!");
+    let i = 0;
+    for (; i < numFullBytes31; i++) {
+        buffers.push(bigNumberishToBuffer(span[i], 31));
+    }
+    if (additionalBytes !== 0)
+        buffers.push(bigNumberishToBuffer(span[i], additionalBytes));
+    return buffer_1.Buffer.concat(buffers);
+}
+exports.bytes31SpanToBuffer = bytes31SpanToBuffer;
+function bufferToBytes31Span(buffer, startIndex = 0, endIndex = buffer.length) {
+    const values = [];
+    for (let i = startIndex + 31; i < endIndex; i += 31) {
+        values.push(BigInt("0x" + buffer.subarray(i - 31, i).toString("hex")));
+    }
+    if (endIndex > startIndex + (values.length * 31))
+        values.push(BigInt("0x" + buffer.subarray(startIndex + (values.length * 31), endIndex).toString("hex")));
+    return values;
+}
+exports.bufferToBytes31Span = bufferToBytes31Span;
+function bufferToByteArray(buffer, startIndex = 0, endIndex = buffer.length) {
+    const values = [];
+    for (let i = startIndex + 31; i < endIndex; i += 31) {
+        values.push(BigInt("0x" + buffer.subarray(i - 31, i).toString("hex")));
+    }
+    let pendingWord = BigInt(0);
+    let pendingWordLen = BigInt(endIndex - (startIndex + (values.length * 31)));
+    if (pendingWordLen !== BigInt(0)) {
+        pendingWord = BigInt("0x" + buffer.subarray(startIndex + (values.length * 31), endIndex).toString("hex"));
+    }
+    return [
+        BigInt(values.length),
+        ...values,
+        pendingWord,
+        pendingWordLen
+    ];
+}
+exports.bufferToByteArray = bufferToByteArray;
+function poseidonHashRange(buffer, startIndex = 0, endIndex = buffer.length) {
+    return starknet_1.hash.computePoseidonHashOnElements(bufferToBytes31Span(buffer, startIndex, endIndex));
+}
+exports.poseidonHashRange = poseidonHashRange;
+function parseInitFunctionCalldata(calldata, claimHandler) {
+    const escrow = StarknetSwapData_1.StarknetSwapData.fromSerializedFeltArray(calldata, claimHandler);
+    const signatureLen = Number(toBigInt(calldata.shift()));
+    const signature = calldata.splice(0, signatureLen);
+    const timeout = toBigInt(calldata.shift());
+    const extraDataLen = Number(toBigInt(calldata.shift()));
+    const extraData = calldata.splice(0, extraDataLen);
+    if (calldata.length !== 0)
+        throw new Error("Calldata not read fully!");
+    return { escrow, signature, timeout, extraData };
+}
+exports.parseInitFunctionCalldata = parseInitFunctionCalldata;
+function findLastIndex(array, callback) {
+    for (let i = array.length - 1; i >= 0; i--) {
+        if (callback(array[i], i))
+            return i;
+    }
+    return -1;
+}
+exports.findLastIndex = findLastIndex;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@atomiqlabs/chain-starknet",
+  "version": "1.0.0-beta.0",
+  "description": "Starknet specific base implementation",
+  "main": "./dist/index.js",
+  "types:": "./dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "/dist",
+    "/src"
+  ],
+  "keywords": [
+    "Starknet",
+    "Bitcoin",
+    "Cross-chain",
+    "Cryptocurrency",
+    "Bridge",
+    "Trustless"
+  ],
+  "author": "adambor",
+  "license": "ISC",
+  "dependencies": {
+    "@atomiqlabs/base": "8.0.0-beta.0",
+    "@scure/btc-signer": "1.6.0",
+    "abi-wan-kanabi": "2.2.4",
+    "buffer": "6.0.3",
+    "create-hash": "1.2.0",
+    "randombytes": "2.1.0"
+  },
+  "peerDependencies": {
+    "starknet": "^6.11.0"
+  },
+  "devDependencies": {
+    "@types/create-hash": "1.2.6",
+    "typescript": "4.9.5"
+  }
+}

package/src/index.ts

@@ -0,0 +1,41 @@
+export * from "./starknet/base/StarknetAction";
+export * from "./starknet/base/StarknetBase";
+export * from "./starknet/base/StarknetModule";
+
+export * from "./starknet/base/modules/StarknetFees";
+export * from "./starknet/base/modules/StarknetEvents";
+export * from "./starknet/base/modules/StarknetTokens";
+export * from "./starknet/base/modules/StarknetAddresses";
+export * from "./starknet/base/modules/StarknetTransactions";
+export * from "./starknet/base/modules/StarknetSignatures";
+
+export * from "./starknet/btcrelay/headers/StarknetBtcStoredHeader";
+export * from "./starknet/btcrelay/headers/StarknetBtcHeader";
+export * from "./starknet/btcrelay/StarknetBtcRelay";
+
+export * from "./starknet/contract/modules/StarknetContractEvents";
+export * from "./starknet/contract/StarknetContractBase";
+
+export * from "./starknet/swaps/StarknetSwapContract";
+export * from "./starknet/swaps/StarknetSwapData";
+export * from "./starknet/swaps/StarknetSwapModule";
+export * from "./starknet/swaps/modules/StarknetLpVault";
+export * from "./starknet/swaps/modules/StarknetSwapClaim";
+export * from "./starknet/swaps/modules/StarknetSwapInit";
+export * from "./starknet/swaps/modules/StarknetSwapRefund";
+export * from "./starknet/swaps/handlers/IHandler";
+export * from "./starknet/swaps/handlers/refund/TimelockRefundHandler";
+export * from "./starknet/swaps/handlers/claim/ClaimHandlers";
+export * from "./starknet/swaps/handlers/claim/HashlockClaimHandler";
+export * from "./starknet/swaps/handlers/claim/btc/IBitcoinClaimHandler";
+export * from "./starknet/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler";
+export * from "./starknet/swaps/handlers/claim/btc/BitcoinOutputClaimHandler";
+export * from "./starknet/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler";
+
+export * from "./starknet/events/StarknetChainEventsBrowser";
+
+export * from "./starknet/wallet/StarknetSigner";
+export * from "./starknet/wallet/StarknetKeypairWallet";
+
+export * from "./starknet/StarknetChainType";
+export * from "./starknet/StarknetInitializer";

package/src/starknet/StarknetChainType.ts

@@ -0,0 +1,20 @@
+import {ChainType} from "@atomiqlabs/base";
+import {StarknetTx} from "./base/modules/StarknetTransactions";
+import {StarknetSigner} from "./wallet/StarknetSigner";
+import {StarknetSwapData} from "./swaps/StarknetSwapData";
+import {StarknetSwapContract} from "./swaps/StarknetSwapContract";
+import {StarknetChainEventsBrowser} from "./events/StarknetChainEventsBrowser";
+import {StarknetBtcRelay} from "./btcrelay/StarknetBtcRelay";
+import {StarknetPreFetchVerification} from "./swaps/modules/StarknetSwapInit";
+
+export type StarknetChainType = ChainType<
+    "STARKNET",
+    never,
+    StarknetPreFetchVerification,
+    StarknetTx,
+    StarknetSigner,
+    StarknetSwapData,
+    StarknetSwapContract,
+    StarknetChainEventsBrowser,
+    StarknetBtcRelay<any>
+>;

package/src/starknet/StarknetInitializer.ts

@@ -0,0 +1,75 @@
+import {constants, Provider, RpcProvider} from "starknet";
+import {StarknetFees} from "./base/modules/StarknetFees";
+import {StarknetRetryPolicy} from "./base/StarknetBase";
+import {StarknetBtcRelay} from "./btcrelay/StarknetBtcRelay";
+import {StarknetSwapContract} from "./swaps/StarknetSwapContract";
+import {StarknetChainEventsBrowser} from "./events/StarknetChainEventsBrowser";
+import {BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer} from "@atomiqlabs/base";
+import {StarknetChainType} from "./StarknetChainType";
+import {StarknetSwapData} from "./swaps/StarknetSwapData";
+
+export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK">;
+export const StarknetAssets: StarknetAssetsType = {
+    ETH: {
+        address: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
+        decimals: 18,
+        displayDecimals: 9
+    },
+    STRK: {
+        address: "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
+        decimals: 18,
+        displayDecimals: 9
+    }
+} as const;
+
+export type StarknetOptions = {
+    rpcUrl: string | Provider,
+    retryPolicy?: StarknetRetryPolicy,
+    chainId?: constants.StarknetChainId,
+
+    swapContract?: string,
+    btcRelayContract?: string,
+
+    fees?: StarknetFees
+}
+
+export function initializeStarknet(
+    options: StarknetOptions,
+    bitcoinRpc: BitcoinRpc<any>,
+    network: BitcoinNetwork
+): ChainData<StarknetChainType> {
+    const provider = typeof(options.rpcUrl)==="string" ?
+        new RpcProvider({nodeUrl: options.rpcUrl}) :
+        options.rpcUrl;
+
+    const Fees = options.fees ?? new StarknetFees(provider, "ETH");
+
+    const chainId = options.chainId ??
+        (network===BitcoinNetwork.MAINNET ? constants.StarknetChainId.SN_MAIN : constants.StarknetChainId.SN_SEPOLIA);
+
+    const btcRelay = new StarknetBtcRelay(
+        chainId, provider, bitcoinRpc, options.btcRelayContract, options.retryPolicy, Fees
+    );
+
+    const swapContract = new StarknetSwapContract(
+        chainId, provider, btcRelay, options.swapContract, options.retryPolicy, Fees
+    );
+    const chainEvents = new StarknetChainEventsBrowser(swapContract);
+
+    return {
+        chainId: "STARKNET",
+        btcRelay,
+        swapContract,
+        chainEvents,
+        swapDataConstructor: StarknetSwapData
+    }
+};
+
+export type StarknetInitializerType = ChainInitializer<StarknetOptions, StarknetChainType, StarknetAssetsType>;
+export const StarknetInitializer: StarknetInitializerType = {
+    chainId: "STARKNET",
+    chainType: null as StarknetChainType,
+    initializer: initializeStarknet,
+    tokens: StarknetAssets,
+    options: null as StarknetOptions
+} as const;

package/src/starknet/base/StarknetAction.ts

@@ -0,0 +1,90 @@
+import {Call} from "starknet";
+import {StarknetBase} from "./StarknetBase";
+import {StarknetTx} from "./modules/StarknetTransactions";
+
+export type StarknetGas = {l1?: number, l2?: number};
+
+export function sumStarknetGas(a: StarknetGas, b: StarknetGas) {
+    return {
+        l1: (a?.l1 ?? 0) + (b?.l1 ?? 0),
+        l2: (a?.l2 ?? 0) + (b?.l2 ?? 0)
+    }
+}
+
+export class StarknetAction {
+
+    L1GasLimit: number;
+    L2GasLimit: number;
+    readonly mainSigner: string;
+    private readonly root: StarknetBase;
+    private readonly instructions: Call[];
+    private feeRate: string;
+
+    constructor(
+        mainSigner: string,
+        root: StarknetBase,
+        instructions: Call[] | Call = [],
+        gasLimit?: StarknetGas,
+        feeRate?: string
+    ) {
+        this.mainSigner = mainSigner;
+        this.root = root;
+        this.instructions = Array.isArray(instructions) ? instructions : [instructions];
+        this.L1GasLimit = gasLimit?.l1 ?? 0;
+        this.L2GasLimit = gasLimit?.l2 ?? 0;
+        this.feeRate = feeRate;
+    }
+
+    private estimateFeeRate(): Promise<string> {
+        return this.root.Fees.getFeeRate();
+    }
+
+    public addIx(instruction: Call, gasLimit?: StarknetGas) {
+        this.instructions.push(instruction);
+        this.L1GasLimit += gasLimit?.l1 ?? 0;
+        this.L2GasLimit += gasLimit?.l2 ?? 0;
+    }
+
+    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.L1GasLimit==null && action.L1GasLimit!=null) this.L1GasLimit = action.L1GasLimit;
+        if(this.L2GasLimit==null && action.L2GasLimit!=null) this.L2GasLimit = action.L2GasLimit;
+        if(this.L1GasLimit!=null && action.L1GasLimit!=null) this.L1GasLimit += action.L1GasLimit;
+        if(this.L2GasLimit!=null && action.L2GasLimit!=null) this.L2GasLimit += action.L2GasLimit;
+        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.L1GasLimit, this.L2GasLimit, 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;
+    }
+
+}

package/src/starknet/base/StarknetBase.ts

@@ -0,0 +1,56 @@
+import {Provider, constants} from "starknet";
+import {getLogger} from "../../utils/Utils";
+import {StarknetTransactions} from "./modules/StarknetTransactions";
+import {StarknetFees} from "./modules/StarknetFees";
+import {StarknetAddresses} from "./modules/StarknetAddresses";
+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";
+
+export type StarknetRetryPolicy = {
+    maxRetries?: number,
+    delay?: number,
+    exponential?: boolean
+}
+
+export class StarknetBase {
+
+    readonly provider: Provider;
+    readonly retryPolicy: StarknetRetryPolicy;
+
+    public readonly starknetChainId: constants.StarknetChainId;
+
+    public Fees: StarknetFees;
+    public readonly Tokens: StarknetTokens;
+    public readonly Transactions: StarknetTransactions;
+    public readonly Addresses: StarknetAddresses;
+    public readonly Signatures: StarknetSignatures;
+    public readonly Events: StarknetEvents;
+    public readonly Accounts: StarknetAccounts;
+    public readonly Blocks: StarknetBlocks;
+
+    protected readonly logger = getLogger(this.constructor.name+": ");
+
+    constructor(
+        chainId: constants.StarknetChainId,
+        provider: Provider,
+        retryPolicy?: StarknetRetryPolicy,
+        solanaFeeEstimator: StarknetFees = new StarknetFees(provider)
+    ) {
+        this.starknetChainId = chainId;
+        this.provider = provider;
+        this.retryPolicy = retryPolicy;
+
+        this.Fees = solanaFeeEstimator;
+        this.Tokens = new StarknetTokens(this);
+        this.Transactions = new StarknetTransactions(this);
+        this.Addresses = new StarknetAddresses(this);
+        this.Signatures = new StarknetSignatures(this);
+        this.Events = new StarknetEvents(this);
+        this.Accounts = new StarknetAccounts(this);
+        this.Blocks = new StarknetBlocks(this);
+    }
+
+}

package/src/starknet/base/StarknetModule.ts

@@ -0,0 +1,20 @@
+import {Provider} from "starknet";
+import {StarknetBase, StarknetRetryPolicy} from "./StarknetBase";
+import {getLogger} from "../../utils/Utils";
+
+export class StarknetModule {
+    protected readonly provider: Provider;
+    protected readonly retryPolicy: StarknetRetryPolicy;
+    protected readonly root: StarknetBase;
+
+    protected readonly logger = getLogger(this.constructor.name+": ");
+
+    constructor(
+        root: StarknetBase
+    ) {
+        this.provider = root.provider;
+        this.retryPolicy = root.retryPolicy;
+        this.root = root;
+    }
+
+}