@atomiqlabs/chain-starknet 1.0.8 → 2.0.0-beta.0

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-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/chain/StarknetAction";
+export * from "./starknet/chain/StarknetChainInterface";
+export * from "./starknet/chain/StarknetModule";
+export * from "./starknet/chain/modules/StarknetFees";
+export * from "./starknet/chain/modules/StarknetEvents";
+export * from "./starknet/chain/modules/StarknetTokens";
+export * from "./starknet/chain/modules/StarknetAddresses";
+export * from "./starknet/chain/modules/StarknetTransactions";
+export * from "./starknet/chain/modules/StarknetSignatures";
 export * from "./starknet/btcrelay/headers/StarknetBtcStoredHeader";
 export * from "./starknet/btcrelay/headers/StarknetBtcHeader";
 export * from "./starknet/btcrelay/StarknetBtcRelay";
@@ -32,3 +32,7 @@ export * from "./starknet/wallet/StarknetSigner";
 export * from "./starknet/wallet/StarknetKeypairWallet";
 export * from "./starknet/StarknetChainType";
 export * from "./starknet/StarknetInitializer";
+export * from "./starknet/spv_swap/StarknetSpvVaultContract";
+export * from "./starknet/spv_swap/StarknetSpvVaultData";
+export * from "./starknet/spv_swap/StarknetSpvWithdrawalData";
+export * from "./starknet/provider/RpcProviderWithRetries";

package/dist/index.js

@@ -14,15 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./starknet/base/StarknetAction"), exports);
-__exportStar(require("./starknet/base/StarknetBase"), exports);
-__exportStar(require("./starknet/base/StarknetModule"), exports);
-__exportStar(require("./starknet/base/modules/StarknetFees"), exports);
-__exportStar(require("./starknet/base/modules/StarknetEvents"), exports);
-__exportStar(require("./starknet/base/modules/StarknetTokens"), exports);
-__exportStar(require("./starknet/base/modules/StarknetAddresses"), exports);
-__exportStar(require("./starknet/base/modules/StarknetTransactions"), exports);
-__exportStar(require("./starknet/base/modules/StarknetSignatures"), exports);
+__exportStar(require("./starknet/chain/StarknetAction"), exports);
+__exportStar(require("./starknet/chain/StarknetChainInterface"), exports);
+__exportStar(require("./starknet/chain/StarknetModule"), exports);
+__exportStar(require("./starknet/chain/modules/StarknetFees"), exports);
+__exportStar(require("./starknet/chain/modules/StarknetEvents"), exports);
+__exportStar(require("./starknet/chain/modules/StarknetTokens"), exports);
+__exportStar(require("./starknet/chain/modules/StarknetAddresses"), exports);
+__exportStar(require("./starknet/chain/modules/StarknetTransactions"), exports);
+__exportStar(require("./starknet/chain/modules/StarknetSignatures"), exports);
 __exportStar(require("./starknet/btcrelay/headers/StarknetBtcStoredHeader"), exports);
 __exportStar(require("./starknet/btcrelay/headers/StarknetBtcHeader"), exports);
 __exportStar(require("./starknet/btcrelay/StarknetBtcRelay"), exports);
@@ -48,3 +48,7 @@ __exportStar(require("./starknet/wallet/StarknetSigner"), exports);
 __exportStar(require("./starknet/wallet/StarknetKeypairWallet"), exports);
 __exportStar(require("./starknet/StarknetChainType"), exports);
 __exportStar(require("./starknet/StarknetInitializer"), exports);
+__exportStar(require("./starknet/spv_swap/StarknetSpvVaultContract"), exports);
+__exportStar(require("./starknet/spv_swap/StarknetSpvVaultData"), exports);
+__exportStar(require("./starknet/spv_swap/StarknetSpvWithdrawalData"), exports);
+__exportStar(require("./starknet/provider/RpcProviderWithRetries"), exports);

package/dist/starknet/StarknetChainType.d.ts

@@ -1,9 +1,13 @@
 import { ChainType } from "@atomiqlabs/base";
-import { StarknetTx } from "./base/modules/StarknetTransactions";
+import { StarknetTx } from "./chain/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>>;
+import { StarknetChainInterface } from "./chain/StarknetChainInterface";
+import { StarknetSpvVaultData } from "./spv_swap/StarknetSpvVaultData";
+import { StarknetSpvWithdrawalData } from "./spv_swap/StarknetSpvWithdrawalData";
+import { StarknetSpvVaultContract } from "./spv_swap/StarknetSpvVaultContract";
+export type StarknetChainType = ChainType<"STARKNET", never, StarknetPreFetchVerification, StarknetTx, StarknetSigner, StarknetSwapData, StarknetSwapContract, StarknetChainInterface, StarknetChainEventsBrowser, StarknetBtcRelay<any>, StarknetSpvVaultData, StarknetSpvWithdrawalData, StarknetSpvVaultContract>;

package/dist/starknet/StarknetInitializer.d.ts

@@ -1,6 +1,6 @@
 import { constants, Provider } from "starknet";
-import { StarknetFees } from "./base/modules/StarknetFees";
-import { StarknetRetryPolicy } from "./base/StarknetBase";
+import { StarknetFees } from "./chain/modules/StarknetFees";
+import { StarknetRetryPolicy } from "./chain/StarknetChainInterface";
 import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer } from "@atomiqlabs/base";
 import { StarknetChainType } from "./StarknetChainType";
 export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK" | "WBTC">;
@@ -11,6 +11,7 @@ export type StarknetOptions = {
     chainId?: constants.StarknetChainId;
     swapContract?: string;
     btcRelayContract?: string;
+    spvVaultContract?: string;
     fees?: StarknetFees;
 };
 export declare function initializeStarknet(options: StarknetOptions, bitcoinRpc: BitcoinRpc<any>, network: BitcoinNetwork): ChainData<StarknetChainType>;

package/dist/starknet/StarknetInitializer.js

@@ -2,12 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetInitializer = exports.initializeStarknet = exports.StarknetAssets = void 0;
 const starknet_1 = require("starknet");
-const StarknetFees_1 = require("./base/modules/StarknetFees");
+const StarknetFees_1 = require("./chain/modules/StarknetFees");
+const StarknetChainInterface_1 = require("./chain/StarknetChainInterface");
 const StarknetBtcRelay_1 = require("./btcrelay/StarknetBtcRelay");
 const StarknetSwapContract_1 = require("./swaps/StarknetSwapContract");
 const StarknetChainEventsBrowser_1 = require("./events/StarknetChainEventsBrowser");
 const base_1 = require("@atomiqlabs/base");
 const StarknetSwapData_1 = require("./swaps/StarknetSwapData");
+const StarknetSpvVaultContract_1 = require("./spv_swap/StarknetSpvVaultContract");
+const StarknetSpvVaultData_1 = require("./spv_swap/StarknetSpvVaultData");
+const StarknetSpvWithdrawalData_1 = require("./spv_swap/StarknetSpvWithdrawalData");
+const RpcProviderWithRetries_1 = require("./provider/RpcProviderWithRetries");
 exports.StarknetAssets = {
     ETH: {
         address: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
@@ -26,20 +31,26 @@ exports.StarknetAssets = {
 };
 function initializeStarknet(options, bitcoinRpc, network) {
     const provider = typeof (options.rpcUrl) === "string" ?
-        new starknet_1.RpcProvider({ nodeUrl: options.rpcUrl }) :
+        new RpcProviderWithRetries_1.RpcProviderWithRetries({ nodeUrl: options.rpcUrl }) :
         options.rpcUrl;
     const Fees = options.fees ?? new StarknetFees_1.StarknetFees(provider, "ETH");
     const chainId = options.chainId ??
         (network === base_1.BitcoinNetwork.MAINNET ? starknet_1.constants.StarknetChainId.SN_MAIN : starknet_1.constants.StarknetChainId.SN_SEPOLIA);
-    const btcRelay = new StarknetBtcRelay_1.StarknetBtcRelay(chainId, provider, bitcoinRpc, options.btcRelayContract, options.retryPolicy, Fees);
-    const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainId, provider, btcRelay, options.swapContract, options.retryPolicy, Fees);
-    const chainEvents = new StarknetChainEventsBrowser_1.StarknetChainEventsBrowser(swapContract);
+    const chainInterface = new StarknetChainInterface_1.StarknetChainInterface(chainId, provider, options.retryPolicy, Fees);
+    const btcRelay = new StarknetBtcRelay_1.StarknetBtcRelay(chainInterface, bitcoinRpc, options.btcRelayContract);
+    const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainInterface, btcRelay, options.swapContract);
+    const spvVaultContract = new StarknetSpvVaultContract_1.StarknetSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract);
+    const chainEvents = new StarknetChainEventsBrowser_1.StarknetChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
     return {
         chainId: "STARKNET",
         btcRelay,
+        chainInterface,
         swapContract,
         chainEvents,
-        swapDataConstructor: StarknetSwapData_1.StarknetSwapData
+        swapDataConstructor: StarknetSwapData_1.StarknetSwapData,
+        spvVaultContract,
+        spvVaultDataConstructor: StarknetSpvVaultData_1.StarknetSpvVaultData,
+        spvVaultWithdrawalDataConstructor: StarknetSpvWithdrawalData_1.StarknetSpvWithdrawalData
     };
 }
 exports.initializeStarknet = initializeStarknet;

package/dist/starknet/btcrelay/StarknetBtcRelay.d.ts

@@ -1,15 +1,13 @@
 import { Buffer } from "buffer";
 import { StarknetBtcHeader } from "./headers/StarknetBtcHeader";
-import { BitcoinRpc, BtcBlock, BtcRelay } from "@atomiqlabs/base";
+import { BitcoinRpc, BtcBlock, BtcRelay, RelaySynchronizer } from "@atomiqlabs/base";
 import { StarknetContractBase } from "../contract/StarknetContractBase";
 import { StarknetBtcStoredHeader } from "./headers/StarknetBtcStoredHeader";
-import { StarknetTx } from "../base/modules/StarknetTransactions";
+import { StarknetTx } from "../chain/modules/StarknetTransactions";
 import { StarknetSigner } from "../wallet/StarknetSigner";
 import { BtcRelayAbi } from "./BtcRelayAbi";
-import { constants, Provider } from "starknet";
-import { StarknetFees } from "../base/modules/StarknetFees";
-import { StarknetRetryPolicy } from "../base/StarknetBase";
-import { StarknetAction } from "../base/StarknetAction";
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
+import { StarknetAction } from "../chain/StarknetAction";
 export declare class StarknetBtcRelay<B extends BtcBlock> extends StarknetContractBase<typeof BtcRelayAbi> implements BtcRelay<StarknetBtcStoredHeader, StarknetTx, B, StarknetSigner> {
     SaveMainHeaders(signer: string, mainHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction;
     SaveShortForkHeaders(signer: string, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction;
@@ -18,7 +16,7 @@ export declare class StarknetBtcRelay<B extends BtcBlock> extends StarknetContra
     readonly maxHeadersPerTx: number;
     readonly maxForkHeadersPerTx: number;
     readonly maxShortForkHeadersPerTx: number;
-    constructor(chainId: constants.StarknetChainId, provider: Provider, bitcoinRpc: BitcoinRpc<B>, contractAddress?: string, retryPolicy?: StarknetRetryPolicy, solanaFeeEstimator?: StarknetFees);
+    constructor(chainInterface: StarknetChainInterface, bitcoinRpc: BitcoinRpc<B>, contractAddress?: string);
     /**
      * Computes subsequent commited headers as they will appear on the blockchain when transactions
      *  are submitted & confirmed
@@ -162,4 +160,27 @@ export declare class StarknetBtcRelay<B extends BtcBlock> extends StarknetContra
      */
     getForkFeeRate(signer: string, forkId: number): Promise<string>;
     saveInitialHeader(signer: string, header: B, epochStart: number, pastBlocksTimestamps: number[], feeRate?: string): Promise<StarknetTx>;
+    /**
+     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
+     *  requiredConfirmations
+     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
+     *  current chain tip & adds them to the txs array
+     *
+     * @param signer
+     * @param btcRelay
+     * @param btcTxs
+     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
+     *  txns are added here
+     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
+     *  to the required blockheight
+     * @param feeRate Fee rate to use for synchronization transactions
+     * @private
+     */
+    static getCommitedHeadersAndSynchronize(signer: string, btcRelay: StarknetBtcRelay<any>, btcTxs: {
+        blockheight: number;
+        requiredConfirmations: number;
+        blockhash: string;
+    }[], txs: StarknetTx[], synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, feeRate?: string): Promise<{
+        [blockhash: string]: StarknetBtcStoredHeader;
+    }>;
 }

package/dist/starknet/btcrelay/StarknetBtcRelay.js

@@ -9,8 +9,8 @@ const StarknetContractBase_1 = require("../contract/StarknetContractBase");
 const StarknetBtcStoredHeader_1 = require("./headers/StarknetBtcStoredHeader");
 const BtcRelayAbi_1 = require("./BtcRelayAbi");
 const starknet_1 = require("starknet");
-const StarknetFees_1 = require("../base/modules/StarknetFees");
-const StarknetAction_1 = require("../base/StarknetAction");
+const StarknetFees_1 = require("../chain/modules/StarknetFees");
+const StarknetAction_1 = require("../chain/StarknetAction");
 function serializeBlockHeader(e) {
     return new StarknetBtcHeader_1.StarknetBtcHeader({
         reversed_version: (0, Utils_1.u32ReverseEndianness)(e.getVersion()),
@@ -22,8 +22,8 @@ function serializeBlockHeader(e) {
         hash: buffer_1.Buffer.from(e.getHash(), "hex").reverse()
     });
 }
-const GAS_PER_BLOCKHEADER = 750;
-const GAS_PER_BLOCKHEADER_FORK = 750;
+const GAS_PER_BLOCKHEADER = 850;
+const GAS_PER_BLOCKHEADER_FORK = 1000;
 const btcRelayAddreses = {
     [starknet_1.constants.StarknetChainId.SN_SEPOLIA]: "0x068601c79da2231d21e015ccfd59c243861156fa523a12c9f987ec28eb8dbc8c",
     [starknet_1.constants.StarknetChainId.SN_MAIN]: "0x057b14a4231b82f1e525ff35a722d893ca3dd2bde0baa6cee97937c5be861dbc"
@@ -36,30 +36,31 @@ function serializeCalldata(headers, storedHeader, span) {
     span.push(...storedHeader.serialize());
     return span;
 }
+const logger = (0, Utils_1.getLogger)("StarknetBtcRelay: ");
 class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
     SaveMainHeaders(signer, mainHeaders, storedHeader) {
-        return new StarknetAction_1.StarknetAction(signer, this, {
+        return new StarknetAction_1.StarknetAction(signer, this.Chain, {
             contractAddress: this.contract.address,
             entrypoint: "submit_main_blockheaders",
             calldata: serializeCalldata(mainHeaders, storedHeader, [])
         }, { l1: GAS_PER_BLOCKHEADER * mainHeaders.length, l2: 0 });
     }
     SaveShortForkHeaders(signer, forkHeaders, storedHeader) {
-        return new StarknetAction_1.StarknetAction(signer, this, {
+        return new StarknetAction_1.StarknetAction(signer, this.Chain, {
             contractAddress: this.contract.address,
             entrypoint: "submit_short_fork_blockheaders",
             calldata: serializeCalldata(forkHeaders, storedHeader, [])
         }, { l1: GAS_PER_BLOCKHEADER * forkHeaders.length, l2: 0 });
     }
     SaveLongForkHeaders(signer, forkId, forkHeaders, storedHeader, totalForkHeaders = 100) {
-        return new StarknetAction_1.StarknetAction(signer, this, {
+        return new StarknetAction_1.StarknetAction(signer, this.Chain, {
             contractAddress: this.contract.address,
             entrypoint: "submit_fork_blockheaders",
             calldata: serializeCalldata(forkHeaders, storedHeader, [(0, Utils_1.toHex)(forkId)])
         }, { l1: (GAS_PER_BLOCKHEADER * forkHeaders.length) + (GAS_PER_BLOCKHEADER_FORK * totalForkHeaders), l2: 0 });
     }
-    constructor(chainId, provider, bitcoinRpc, contractAddress = btcRelayAddreses[chainId], retryPolicy, solanaFeeEstimator = new StarknetFees_1.StarknetFees(provider)) {
-        super(chainId, provider, contractAddress, BtcRelayAbi_1.BtcRelayAbi, retryPolicy, solanaFeeEstimator);
+    constructor(chainInterface, bitcoinRpc, contractAddress = btcRelayAddreses[chainInterface.starknetChainId]) {
+        super(chainInterface, contractAddress, BtcRelayAbi_1.BtcRelayAbi);
         this.maxHeadersPerTx = 100;
         this.maxForkHeadersPerTx = 100;
         this.maxShortForkHeadersPerTx = 100;
@@ -171,7 +172,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
         const chainCommitment = await this.contract.get_commit_hash(storedBlockHeader.block_height);
         if (BigInt(chainCommitment) !== BigInt(commitHash))
             return null;
-        this.logger.debug("retrieveLogAndBlockheight(): block found," +
+        logger.debug("retrieveLogAndBlockheight(): block found," +
             " commit hash: " + (0, Utils_1.toHex)(commitHash) + " blockhash: " + blockData.blockhash + " current btc relay height: " + blockHeight);
         return { header: storedBlockHeader, height: blockHeight };
     }
@@ -190,7 +191,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
         const chainCommitment = await this.contract.get_commit_hash(storedBlockHeader.block_height);
         if (BigInt(chainCommitment) !== BigInt(commitHash))
             return null;
-        this.logger.debug("retrieveLogByCommitHash(): block found," +
+        logger.debug("retrieveLogByCommitHash(): block found," +
             " commit hash: " + commitmentHashStr + " blockhash: " + blockData.blockhash + " height: " + storedBlockHeader.block_height);
         return storedBlockHeader;
     }
@@ -217,7 +218,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
             };
         });
         if (data != null)
-            this.logger.debug("retrieveLatestKnownBlockLog(): block found," +
+            logger.debug("retrieveLatestKnownBlockLog(): block found," +
                 " commit hash: " + (0, Utils_1.toHex)(data.commitHash) + " blockhash: " + data.resultBitcoinHeader.getHash() +
                 " height: " + data.resultStoredHeader.getBlockheight());
         return data;
@@ -231,7 +232,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
      * @param feeRate
      */
     saveMainHeaders(signer, mainHeaders, storedHeader, feeRate) {
-        this.logger.debug("saveMainHeaders(): submitting main blockheaders, count: " + mainHeaders.length);
+        logger.debug("saveMainHeaders(): submitting main blockheaders, count: " + mainHeaders.length);
         return this._saveHeaders(signer, mainHeaders, storedHeader, null, 0, feeRate);
     }
     /**
@@ -245,7 +246,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
      */
     async saveNewForkHeaders(signer, forkHeaders, storedHeader, tipWork, feeRate) {
         let forkId = Math.floor(Math.random() * 0xFFFFFFFFFFFF);
-        this.logger.debug("saveNewForkHeaders(): submitting new fork & blockheaders," +
+        logger.debug("saveNewForkHeaders(): submitting new fork & blockheaders," +
             " count: " + forkHeaders.length + " forkId: 0x" + forkId.toString(16));
         return await this._saveHeaders(signer, forkHeaders, storedHeader, tipWork, forkId, feeRate);
     }
@@ -260,7 +261,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
      * @param feeRate
      */
     saveForkHeaders(signer, forkHeaders, storedHeader, forkId, tipWork, feeRate) {
-        this.logger.debug("saveForkHeaders(): submitting blockheaders to existing fork," +
+        logger.debug("saveForkHeaders(): submitting blockheaders to existing fork," +
             " count: " + forkHeaders.length + " forkId: 0x" + forkId.toString(16));
         return this._saveHeaders(signer, forkHeaders, storedHeader, tipWork, forkId, feeRate);
     }
@@ -274,7 +275,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
      * @param feeRate
      */
     saveShortForkHeaders(signer, forkHeaders, storedHeader, tipWork, feeRate) {
-        this.logger.debug("saveShortForkHeaders(): submitting short fork blockheaders," +
+        logger.debug("saveShortForkHeaders(): submitting short fork blockheaders," +
             " count: " + forkHeaders.length);
         return this._saveHeaders(signer, forkHeaders, storedHeader, tipWork, -1, feeRate);
     }
@@ -291,7 +292,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
         if (blockheightDelta <= 0)
             return 0n;
         const synchronizationFee = BigInt(blockheightDelta) * await this.getFeePerBlock(feeRate);
-        this.logger.debug("estimateSynchronizeFee(): required blockheight: " + requiredBlockheight +
+        logger.debug("estimateSynchronizeFee(): required blockheight: " + requiredBlockheight +
             " blockheight delta: " + blockheightDelta + " fee: " + synchronizationFee.toString(10));
         return synchronizationFee;
     }
@@ -301,23 +302,77 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
      * @param feeRate
      */
     async getFeePerBlock(feeRate) {
-        feeRate ?? (feeRate = await this.Fees.getFeeRate());
+        feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
         return StarknetFees_1.StarknetFees.getGasFee(GAS_PER_BLOCKHEADER, feeRate);
     }
     /**
      * Gets fee rate required for submitting blockheaders to the main chain
      */
     getMainFeeRate(signer) {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
     /**
      * Gets fee rate required for submitting blockheaders to the specific fork
      */
     getForkFeeRate(signer, forkId) {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
     saveInitialHeader(signer, header, epochStart, pastBlocksTimestamps, feeRate) {
         throw new Error("Not supported, starknet contract is initialized with constructor!");
     }
+    /**
+     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
+     *  requiredConfirmations
+     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
+     *  current chain tip & adds them to the txs array
+     *
+     * @param signer
+     * @param btcRelay
+     * @param btcTxs
+     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
+     *  txns are added here
+     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
+     *  to the required blockheight
+     * @param feeRate Fee rate to use for synchronization transactions
+     * @private
+     */
+    static async getCommitedHeadersAndSynchronize(signer, btcRelay, btcTxs, txs, synchronizer, feeRate) {
+        const leavesTxs = [];
+        const blockheaders = {};
+        for (let btcTx of btcTxs) {
+            const requiredBlockheight = btcTx.blockheight + btcTx.requiredConfirmations - 1;
+            const result = await (0, Utils_1.tryWithRetries)(() => btcRelay.retrieveLogAndBlockheight({
+                blockhash: btcTx.blockhash
+            }, requiredBlockheight));
+            if (result != null) {
+                blockheaders[result.header.getBlockHash().toString("hex")] = result.header;
+            }
+            else {
+                leavesTxs.push(btcTx);
+            }
+        }
+        if (leavesTxs.length === 0)
+            return blockheaders;
+        //Need to synchronize
+        if (synchronizer == null)
+            return null;
+        //TODO: We don't have to synchronize to tip, only to our required blockheight
+        const resp = await synchronizer.syncToLatestTxs(signer.toString(), feeRate);
+        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay not synchronized to required blockheight, " +
+            "synchronizing ourselves in " + resp.txs.length + " txs");
+        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay computed header map: ", resp.computedHeaderMap);
+        txs.push(...resp.txs);
+        for (let key in resp.computedHeaderMap) {
+            const header = resp.computedHeaderMap[key];
+            blockheaders[header.getBlockHash().toString("hex")] = header;
+        }
+        //Check that blockhashes of all the rest txs are included
+        for (let btcTx of leavesTxs) {
+            if (blockheaders[btcTx.blockhash] == null)
+                return null;
+        }
+        //Retrieve computed headers
+        return blockheaders;
+    }
 }
 exports.StarknetBtcRelay = StarknetBtcRelay;

package/dist/starknet/{base → chain}/StarknetAction.d.ts

@@ -1,5 +1,5 @@
 import { Call } from "starknet";
-import { StarknetBase } from "./StarknetBase";
+import { StarknetChainInterface } from "./StarknetChainInterface";
 import { StarknetTx } from "./modules/StarknetTransactions";
 export type StarknetGas = {
     l1?: number;
@@ -16,7 +16,7 @@ export declare class StarknetAction {
     private readonly root;
     private readonly instructions;
     private feeRate;
-    constructor(mainSigner: string, root: StarknetBase, instructions?: Call[] | Call, gasLimit?: StarknetGas, feeRate?: string);
+    constructor(mainSigner: string, root: StarknetChainInterface, instructions?: Call[] | Call, gasLimit?: StarknetGas, feeRate?: string);
     private estimateFeeRate;
     addIx(instruction: Call, gasLimit?: StarknetGas): void;
     add(action: StarknetAction): this;

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

@@ -0,0 +1,52 @@
+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>;
+}

package/dist/starknet/chain/StarknetChainInterface.js

@@ -0,0 +1,91 @@
+"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;

package/dist/starknet/{base → chain}/StarknetModule.d.ts

@@ -1,14 +1,14 @@
 import { Provider } from "starknet";
-import { StarknetBase, StarknetRetryPolicy } from "./StarknetBase";
+import { StarknetChainInterface, StarknetRetryPolicy } from "./StarknetChainInterface";
 export declare class StarknetModule {
     protected readonly provider: Provider;
     protected readonly retryPolicy: StarknetRetryPolicy;
-    protected readonly root: StarknetBase;
+    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: StarknetBase);
+    constructor(root: StarknetChainInterface);
 }

package/dist/starknet/{base → chain}/modules/StarknetAddresses.d.ts

@@ -5,5 +5,5 @@ export declare class StarknetAddresses extends StarknetModule {
      *
      * @param value
      */
-    isValidAddress(value: string): boolean;
+    static isValidAddress(value: string): boolean;
 }

package/dist/starknet/{base → chain}/modules/StarknetAddresses.js

@@ -11,7 +11,7 @@ class StarknetAddresses extends StarknetModule_1.StarknetModule {
      *
      * @param value
      */
-    isValidAddress(value) {
+    static isValidAddress(value) {
         if (value.length !== 66)
             return false;
         try {

package/dist/starknet/{base → chain}/modules/StarknetSignatures.d.ts

@@ -2,10 +2,10 @@ import { Buffer } from "buffer";
 import { StarknetModule } from "../StarknetModule";
 import { StarknetSigner } from "../../wallet/StarknetSigner";
 import { StarknetType, TypedData } from "starknet";
-import { StarknetBase } from "../StarknetBase";
+import { StarknetChainInterface } from "../StarknetChainInterface";
 export declare class StarknetSignatures extends StarknetModule {
     private readonly domain;
-    constructor(root: StarknetBase, domainName?: string);
+    constructor(root: StarknetChainInterface, domainName?: string);
     getTypedMessage(type: StarknetType[], typeName: string, message: object): TypedData;
     signTypedMessage(signer: StarknetSigner, type: StarknetType[], typeName: string, message: object): Promise<string>;
     isValidSignature(signature: string, address: string, type: StarknetType[], typeName: string, message: object): Promise<boolean>;