@atomiqlabs/chain-starknet 8.1.11 → 8.2.2

package/README.md

@@ -0,0 +1,74 @@
+# @atomiqlabs/chain-starknet
+
+`@atomiqlabs/chain-starknet` is the Starknet integration package for the Atomiq protocol.
+
+Within the Atomiq stack, this library provides the Starknet-side building blocks used for Bitcoin-aware swaps and SPV-backed vault flows on Starknet. It includes:
+
+- the `StarknetInitializer` used to register Starknet support in the Atomiq SDK
+- the `StarknetChainInterface` used to talk to Starknet RPCs
+- Starknet BTC relay, escrow swap, and SPV vault contract wrappers
+- signer helpers for browser and programmatic Starknet integrations
+- retrying RPC and websocket helpers for chain access and realtime events
+
+This package is intended for direct protocol integrations and for higher-level Atomiq SDK layers that need Starknet chain support.
+
+## Installation
+
+Install the package with its `starknet` peer dependency:
+
+```bash
+npm install @atomiqlabs/chain-starknet starknet
+```
+
+## Node-only Helpers
+
+The default package entrypoint stays browser-safe and does not export classes that depend on Node's `fs` module.
+
+Import backend-only utilities from the dedicated `node` subpath:
+
+```ts
+import {StarknetChainEvents, StarknetPersistentSigner} from "@atomiqlabs/chain-starknet/node";
+```
+
+## Supported Chains
+
+This package exports a single Starknet initializer:
+
+- Starknet via `StarknetInitializer`
+
+Canonical deployments currently defined in this package:
+
+| Chain | Canonical deployments included |
+|-------|--------------------------------|
+| Starknet     | `MAINNET`, `TESTNET`, `TESTNET4`      |
+
+By default, `StarknetInitializer` selects `SN_MAIN` Starknet network when `bitcoinNetwork` is `BitcoinNetwork.MAINNET`, and `SN_SEPOLIA` otherwise. That means both `BitcoinNetwork.TESTNET` and `BitcoinNetwork.TESTNET4` use Starknet Sepolia by default, while the BTC relay contract switches to the matching Bitcoin-network-specific deployment.
+
+If you need a non-canonical deployment, pass explicit, `swapContract`, `spvVaultContract`, `btcRelayContract`, or handler contract overrides in the initializer options.
+
+## SDK Example
+
+Initialize the Atomiq SDK with Starknet network support:
+
+```ts
+import {StarknetInitializer} from "@atomiqlabs/chain-starknet";
+import {BitcoinNetwork, SwapperFactory, TypedSwapper} from "@atomiqlabs/sdk";
+
+// Define chains that you want to support here
+const chains = [StarknetInitializer] as const;
+type SupportedChains = typeof chains;
+
+const Factory = new SwapperFactory<SupportedChains>(chains);
+
+const swapper: TypedSwapper<SupportedChains> = Factory.newSwapper({
+  chains: {
+    STARKNET: {
+      rpcUrl: starknetRpc,
+      wsUrl: starknetWs // Optional, but recommended for realtime event subscriptions
+    }
+  },
+  bitcoinNetwork: BitcoinNetwork.MAINNET // or BitcoinNetwork.TESTNET / BitcoinNetwork.TESTNET4
+});
+```
+
+If you use the lower-level initializer directly, you can also override the default Starknet chain ID and canonical contract addresses independently when you need custom deployments.

package/dist/index.d.ts

@@ -2,8 +2,7 @@ export { StarknetBtcStoredHeader } from "./starknet/btcrelay/headers/StarknetBtc
 export { StarknetBtcHeader } from "./starknet/btcrelay/headers/StarknetBtcHeader";
 export * from "./starknet/btcrelay/StarknetBtcRelay";
 export * from "./starknet/chain/modules/StarknetFees";
-export { StarknetTx, SignedStarknetTx } from "./starknet/chain/modules/StarknetTransactions";
-export { StarknetAction } from "./starknet/chain/StarknetAction";
+export { StarknetTx, SignedStarknetTx, StarknetTxInvoke, StarknetTxDeployAccount, isStarknetTxDeployAccount, isStarknetTxInvoke } from "./starknet/chain/modules/StarknetTransactions";
 export * from "./starknet/chain/StarknetChainInterface";
 export * from "./starknet/events/StarknetChainEventsBrowser";
 export * from "./starknet/provider/RpcProviderWithRetries";

package/dist/index.js

@@ -14,7 +14,75 @@ 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 });
-exports.StarknetSwapData = exports.StarknetSpvVaultData = exports.StarknetAction = exports.StarknetBtcHeader = exports.StarknetBtcStoredHeader = void 0;
+exports.StarknetSwapData = exports.StarknetSpvVaultData = exports.isStarknetTxInvoke = exports.isStarknetTxDeployAccount = exports.StarknetBtcHeader = exports.StarknetBtcStoredHeader = void 0;
+/**
+ * # @atomiqlabs/chain-starknet
+ *
+ * `@atomiqlabs/chain-starknet` is the Starknet integration package for the Atomiq protocol.
+ *
+ * Within the Atomiq stack, this library provides the Starknet-side building blocks used for Bitcoin-aware swaps and SPV-backed vault flows on Starknet. It includes:
+ *
+ * - the `StarknetInitializer` used to register Starknet support in the Atomiq SDK
+ * - the `StarknetChainInterface` used to talk to Starknet RPCs
+ * - Starknet BTC relay, escrow swap, and SPV vault contract wrappers
+ * - signer helpers for browser and programmatic Starknet integrations
+ * - retrying RPC and websocket helpers for chain access and realtime events
+ *
+ * This package is intended for direct protocol integrations and for higher-level Atomiq SDK layers that need Starknet chain support.
+ *
+ * ## Installation
+ *
+ * Install the package with its `starknet` peer dependency:
+ *
+ * ```bash
+ * npm install @atomiqlabs/chain-starknet starknet
+ * ```
+ *
+ * ## Supported Chains
+ *
+ * This package exports a single Starknet initializer:
+ *
+ * - Starknet via `StarknetInitializer`
+ *
+ * Canonical deployments currently defined in this package:
+ *
+ * | Chain | Canonical deployments included |
+ * |-------|--------------------------------|
+ * | Starknet     | `MAINNET`, `TESTNET`, `TESTNET4`      |
+ *
+ * By default, `StarknetInitializer` selects `SN_MAIN` Starknet network when `bitcoinNetwork` is `BitcoinNetwork.MAINNET`, and `SN_SEPOLIA` otherwise. That means both `BitcoinNetwork.TESTNET` and `BitcoinNetwork.TESTNET4` use Starknet Sepolia by default, while the BTC relay contract switches to the matching Bitcoin-network-specific deployment.
+ *
+ * If you need a non-canonical deployment, pass explicit, `swapContract`, `spvVaultContract`, `btcRelayContract`, or handler contract overrides in the initializer options.
+ *
+ * ## SDK Example
+ *
+ * Initialize the Atomiq SDK with Starknet network support:
+ *
+ * ```ts
+ * import {StarknetInitializer} from "@atomiqlabs/chain-starknet";
+ * import {BitcoinNetwork, SwapperFactory, TypedSwapper} from "@atomiqlabs/sdk";
+ *
+ * // Define chains that you want to support here
+ * const chains = [StarknetInitializer] as const;
+ * type SupportedChains = typeof chains;
+ *
+ * const Factory = new SwapperFactory<SupportedChains>(chains);
+ *
+ * const swapper: TypedSwapper<SupportedChains> = Factory.newSwapper({
+ *   chains: {
+ *     STARKNET: {
+ *       rpcUrl: starknetRpc,
+ *       wsUrl: starknetWs // Optional, but recommended for realtime event subscriptions
+ *     }
+ *   },
+ *   bitcoinNetwork: BitcoinNetwork.MAINNET // or BitcoinNetwork.TESTNET / BitcoinNetwork.TESTNET4
+ * });
+ * ```
+ *
+ * If you use the lower-level initializer directly, you can also override the default Starknet chain ID and canonical contract addresses independently when you need custom deployments.
+ *
+ * @packageDocumentation
+ */
 const WebSocket = require("ws");
 if (global.window == null)
     global.WebSocket = WebSocket;
@@ -24,8 +92,9 @@ var StarknetBtcHeader_1 = require("./starknet/btcrelay/headers/StarknetBtcHeader
 Object.defineProperty(exports, "StarknetBtcHeader", { enumerable: true, get: function () { return StarknetBtcHeader_1.StarknetBtcHeader; } });
 __exportStar(require("./starknet/btcrelay/StarknetBtcRelay"), exports);
 __exportStar(require("./starknet/chain/modules/StarknetFees"), exports);
-var StarknetAction_1 = require("./starknet/chain/StarknetAction");
-Object.defineProperty(exports, "StarknetAction", { enumerable: true, get: function () { return StarknetAction_1.StarknetAction; } });
+var StarknetTransactions_1 = require("./starknet/chain/modules/StarknetTransactions");
+Object.defineProperty(exports, "isStarknetTxDeployAccount", { enumerable: true, get: function () { return StarknetTransactions_1.isStarknetTxDeployAccount; } });
+Object.defineProperty(exports, "isStarknetTxInvoke", { enumerable: true, get: function () { return StarknetTransactions_1.isStarknetTxInvoke; } });
 __exportStar(require("./starknet/chain/StarknetChainInterface"), exports);
 __exportStar(require("./starknet/events/StarknetChainEventsBrowser"), exports);
 __exportStar(require("./starknet/provider/RpcProviderWithRetries"), exports);

package/dist/node/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Node.js-only entrypoint for filesystem-backed Starknet helpers.
+ *
+ * Import from `@atomiqlabs/chain-starknet/node` when you need runtime features
+ * that depend on Node's `fs` module.
+ *
+ * @packageDocumentation
+ */
+export { StarknetChainEvents } from "../starknet/events/StarknetChainEvents";
+export { StarknetPersistentSigner } from "../starknet/wallet/StarknetPersistentSigner";

package/dist/node/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetPersistentSigner = exports.StarknetChainEvents = void 0;
+/**
+ * Node.js-only entrypoint for filesystem-backed Starknet helpers.
+ *
+ * Import from `@atomiqlabs/chain-starknet/node` when you need runtime features
+ * that depend on Node's `fs` module.
+ *
+ * @packageDocumentation
+ */
+var StarknetChainEvents_1 = require("../starknet/events/StarknetChainEvents");
+Object.defineProperty(exports, "StarknetChainEvents", { enumerable: true, get: function () { return StarknetChainEvents_1.StarknetChainEvents; } });
+var StarknetPersistentSigner_1 = require("../starknet/wallet/StarknetPersistentSigner");
+Object.defineProperty(exports, "StarknetPersistentSigner", { enumerable: true, get: function () { return StarknetPersistentSigner_1.StarknetPersistentSigner; } });

package/dist/starknet/StarknetInitializer.d.ts

@@ -9,32 +9,59 @@ import { StarknetChainType } from "./StarknetChainType";
  * @category Chain Interface
  */
 export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK" | "WBTC" | "TBTC" | "USDC" | "USDT" | "_TESTNET_WBTC_VESU">;
-/**
- * Default Starknet token assets configuration
- *
- * @category Chain Interface
- */
-export declare const StarknetAssets: StarknetAssetsType;
 /**
  * Configuration options for initializing Starknet chain
  *
  * @category Chain Interface
  */
 export type StarknetOptions = {
+    /**
+     * Starknet RPC URL or {@link Provider} object to use for Starknet network access
+     */
     rpcUrl: string | Provider;
+    /**
+     * Optional WebSocket URL or {@link WebSocketChannel} object to use for realtime events subscriptions
+     */
     wsUrl?: string | WebSocketChannel;
+    /**
+     * Retry policy for the RPC calls
+     */
     retryPolicy?: {
         maxRetries?: number;
         delay?: number;
         exponential?: boolean;
     };
+    /**
+     * Starknet chain ID: mainnet or sepolia
+     */
     chainId?: constants.StarknetChainId;
+    /**
+     * Contract address of the Escrow Manager contract, uses canonical deployment by default
+     */
     swapContract?: string;
+    /**
+     * Optional Escrow Manager contract deployment height, which acts as genesis when querying events
+     */
     swapContractDeploymentHeight?: number;
+    /**
+     * Contract address of the BTC Relay contract, uses canonical deployment by default
+     */
     btcRelayContract?: string;
+    /**
+     * Optional BTC Relay contract deployment height, which acts as genesis when querying events
+     */
     btcRelayContractDeploymentHeight?: number;
+    /**
+     * Contract address of the UTXO-controlled vault (SPV Vault manager) contract, uses canonical deployment by default
+     */
     spvVaultContract?: string;
+    /**
+     * Optional UTXO-controlled vault (SPV Vault manager) contract deployment height, which acts as genesis when querying events
+     */
     spvVaultContractDeploymentHeight?: number;
+    /**
+     * Contract addresses of the refund and claim handlers, uses canonical deployment by default
+     */
     handlerContracts?: {
         refund?: {
             timelock?: string;
@@ -43,7 +70,13 @@ export type StarknetOptions = {
             [type in ChainSwapType]?: string;
         };
     };
+    /**
+     * Starknet network fee API
+     */
     fees?: StarknetFees;
+    /**
+     * Starknet configuration
+     */
     starknetConfig?: StarknetConfig;
 };
 /**

package/dist/starknet/StarknetInitializer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetInitializer = exports.initializeStarknet = exports.StarknetAssets = void 0;
+exports.StarknetInitializer = exports.initializeStarknet = void 0;
 const starknet_1 = require("starknet");
 const StarknetFees_1 = require("./chain/modules/StarknetFees");
 const StarknetChainInterface_1 = require("./chain/StarknetChainInterface");
@@ -19,7 +19,7 @@ const WebSocketChannelWithRetries_1 = require("./provider/WebSocketChannelWithRe
  *
  * @category Chain Interface
  */
-exports.StarknetAssets = {
+const StarknetAssets = {
     ETH: {
         address: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
         decimals: 18,
@@ -96,6 +96,6 @@ exports.StarknetInitializer = {
     chainId: "STARKNET",
     chainType: null,
     initializer: initializeStarknet,
-    tokens: exports.StarknetAssets,
+    tokens: StarknetAssets,
     options: null
 };

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

@@ -1,5 +1,4 @@
 import { Buffer } from "buffer";
-import { StarknetBtcHeader } from "./headers/StarknetBtcHeader";
 import { BitcoinNetwork, BitcoinRpc, BtcBlock, BtcRelay, RelaySynchronizer } from "@atomiqlabs/base";
 import { StarknetContractBase } from "../contract/StarknetContractBase";
 import { StarknetBtcStoredHeader } from "./headers/StarknetBtcStoredHeader";
@@ -7,7 +6,6 @@ import { StarknetTx } from "../chain/modules/StarknetTransactions";
 import { StarknetSigner } from "../wallet/StarknetSigner";
 import { BtcRelayAbi } from "./BtcRelayAbi";
 import { StarknetChainInterface } from "../chain/StarknetChainInterface";
-import { StarknetAction } from "../chain/StarknetAction";
 /**
  * Starknet BTC Relay bitcoin light client contract representation
  *
@@ -21,7 +19,7 @@ export declare class StarknetBtcRelay<B extends BtcBlock> extends StarknetContra
      * @param mainHeaders New bitcoin blockheaders to submit
      * @param storedHeader Current latest committed and stored bitcoin blockheader in the light client
      */
-    SaveMainHeaders(signer: string, mainHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction;
+    private SaveMainHeaders;
     /**
      * Returns a {@link StarknetAction} for submitting a short fork bitcoin blockheaders to the light client,
      *  forking the chain from the provided `storedHeader` param's blockheight. For a successful fork the
@@ -31,7 +29,7 @@ export declare class StarknetBtcRelay<B extends BtcBlock> extends StarknetContra
      * @param forkHeaders Fork bitcoin blockheaders to submit
      * @param storedHeader Committed and stored bitcoin blockheader from which to fork the light client
      */
-    SaveShortForkHeaders(signer: string, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction;
+    private SaveShortForkHeaders;
     /**
      * Returns a {@link StarknetAction} for submitting a long fork of bitcoin blockheaders to the light client.
      *
@@ -42,8 +40,11 @@ export declare class StarknetBtcRelay<B extends BtcBlock> extends StarknetContra
      *  creating the fork), or the tip of the fork (when adding more blockheaders to the fork)
      * @param totalForkHeaders Total blockheaders in the fork - used to estimate the gas usage when re-org happens
      */
-    SaveLongForkHeaders(signer: string, forkId: number, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader, totalForkHeaders?: number): StarknetAction;
-    bitcoinRpc: BitcoinRpc<B>;
+    private SaveLongForkHeaders;
+    /**
+     * @internal
+     */
+    readonly _bitcoinRpc: BitcoinRpc<B>;
     readonly maxHeadersPerTx: number;
     readonly maxForkHeadersPerTx: number;
     readonly maxShortForkHeadersPerTx: number;

package/dist/starknet/btcrelay/StarknetBtcRelay.js

@@ -61,7 +61,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
             contractAddress: this.contract.address,
             entrypoint: "submit_main_blockheaders",
             calldata: serializeCalldata(mainHeaders, storedHeader, [])
-        }, (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, mainHeaders.length));
+        }, StarknetFees_1.StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER, mainHeaders.length));
     }
     /**
      * Returns a {@link StarknetAction} for submitting a short fork bitcoin blockheaders to the light client,
@@ -77,7 +77,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
             contractAddress: this.contract.address,
             entrypoint: "submit_short_fork_blockheaders",
             calldata: serializeCalldata(forkHeaders, storedHeader, [])
-        }, (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, forkHeaders.length));
+        }, StarknetFees_1.StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length));
     }
     /**
      * Returns a {@link StarknetAction} for submitting a long fork of bitcoin blockheaders to the light client.
@@ -94,7 +94,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
             contractAddress: this.contract.address,
             entrypoint: "submit_fork_blockheaders",
             calldata: serializeCalldata(forkHeaders, storedHeader, [(0, Utils_1.toHex)(forkId)])
-        }, (0, StarknetFees_1.starknetGasAdd)((0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, forkHeaders.length), (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)));
+        }, StarknetFees_1.StarknetFees.starknetGasAdd(StarknetFees_1.StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length), StarknetFees_1.StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)));
     }
     constructor(chainInterface, bitcoinRpc, bitcoinNetwork, contractAddress = btcRelayAddreses[bitcoinNetwork], contractDeploymentHeight) {
         if (contractAddress == null)
@@ -106,7 +106,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
         this.maxHeadersPerTx = 40;
         this.maxForkHeadersPerTx = 30;
         this.maxShortForkHeadersPerTx = 40;
-        this.bitcoinRpc = bitcoinRpc;
+        this._bitcoinRpc = bitcoinRpc;
     }
     /**
      * Computes subsequent commited headers as they will appear on the blockchain when transactions
@@ -170,7 +170,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
             const starknetBlockHash = starknet_1.hash.computePoseidonHashOnElements((0, Utils_1.bufferToU32Array)(buffer_1.Buffer.from([...blockHash]).reverse()));
             keys.push(starknetBlockHash);
         }
-        return this.Events.findInContractEvents(["btc_relay::events::StoreHeader", "btc_relay::events::StoreForkHeader"], keys, (event) => {
+        return this._Events.findInContractEvents(["btc_relay::events::StoreHeader", "btc_relay::events::StoreForkHeader"], keys, (event) => {
             return Promise.resolve([StarknetBtcStoredHeader_1.StarknetBtcStoredHeader.fromSerializedFeltArray(event.data), BigInt(event.params.commit_hash)]);
         });
     }
@@ -241,19 +241,19 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
      * @inheritDoc
      */
     async retrieveLatestKnownBlockLog() {
-        const data = await this.Events.findInContractEvents(["btc_relay::events::StoreHeader", "btc_relay::events::StoreForkHeader"], null, async (event) => {
+        const data = await this._Events.findInContractEvents(["btc_relay::events::StoreHeader", "btc_relay::events::StoreForkHeader"], null, async (event) => {
             const storedHeader = StarknetBtcStoredHeader_1.StarknetBtcStoredHeader.fromSerializedFeltArray(event.data);
             const blockHashHex = storedHeader.getBlockHash().toString("hex");
             const commitHash = event.params.commit_hash;
             const [isInBtcMainChain, btcRelayCommitHash] = await Promise.all([
-                this.bitcoinRpc.isInMainChain(blockHashHex).catch(() => false),
+                this._bitcoinRpc.isInMainChain(blockHashHex).catch(() => false),
                 this.contract.get_commit_hash(storedHeader.getBlockheight())
             ]);
             if (!isInBtcMainChain)
                 return null;
             if (BigInt(commitHash) !== BigInt(btcRelayCommitHash))
                 return null;
-            const bitcoinBlockHeader = await this.bitcoinRpc.getBlockHeader(blockHashHex);
+            const bitcoinBlockHeader = await this._bitcoinRpc.getBlockHeader(blockHashHex);
             if (bitcoinBlockHeader == null)
                 return null;
             return {

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

@@ -27,6 +27,8 @@ export declare class StarknetBtcHeader implements BtcHeader {
      * Constructs the bitcoin blockheader from a struct as returned by the starknet.js lib
      *
      * @param obj Struct as returned by the starknet.js lib
+     *
+     * @internal
      */
     constructor(obj: StarknetBtcHeaderType);
     /**

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

@@ -14,6 +14,8 @@ class StarknetBtcHeader {
      * Constructs the bitcoin blockheader from a struct as returned by the starknet.js lib
      *
      * @param obj Struct as returned by the starknet.js lib
+     *
+     * @internal
      */
     constructor(obj) {
         this.reversed_version = Number(obj.reversed_version);

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

@@ -26,7 +26,9 @@ export declare class StarknetBtcStoredHeader implements BtcStoredHeader<Starknet
     /**
      * Constructs the bitcoin stored blockheader from a struct as returned by the starknet.js lib
      *
-     * @param obj Struct as returned by the starknet.js lib
+     * @param obj Struct as returned by the starknet.js
+     *
+     * @internal
      */
     constructor(obj: StarknetBtcStoredHeaderType);
     /**

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

@@ -16,7 +16,9 @@ class StarknetBtcStoredHeader {
     /**
      * Constructs the bitcoin stored blockheader from a struct as returned by the starknet.js lib
      *
-     * @param obj Struct as returned by the starknet.js lib
+     * @param obj Struct as returned by the starknet.js
+     *
+     * @internal
      */
     constructor(obj) {
         this.blockheader = obj.blockheader instanceof StarknetBtcHeader_1.StarknetBtcHeader ? obj.blockheader : new StarknetBtcHeader_1.StarknetBtcHeader(obj.blockheader);

package/dist/starknet/chain/StarknetAction.js

@@ -32,7 +32,7 @@ class StarknetAction {
     addIx(instruction, gasLimit) {
         this.instructions.push(instruction);
         if (gasLimit != null)
-            this.gas = (0, StarknetFees_1.starknetGasAdd)(this.gas, gasLimit);
+            this.gas = StarknetFees_1.StarknetFees.starknetGasAdd(this.gas, gasLimit);
     }
     /**
      * Adds contract calls from another starknet action to this action, while also adding its gas limits

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

@@ -14,9 +14,28 @@ import { StarknetSigner } from "../wallet/StarknetSigner";
  * @category Chain Interface
  */
 export type StarknetConfig = {
+    /**
+     * Limit of the number of events retrieved by a single `starknet_getEvents` RPC call.
+     *
+     * Defaults to 100 events
+     */
     getLogChunkSize?: number;
+    /**
+     * When fetching events in the forward direction, sets the limit on the number of blocks
+     *  to fetch in a single `starknet_getEvents` RPC call.
+     *
+     * Defaults to 2000 blocks
+     */
     getLogForwardBlockRange?: number;
+    /**
+     * Maximum numbers of keys allowed to be specified in a single `starknet_getEvents` RPC call
+     *
+     * Defaults to 64 keys
+     */
     maxGetLogKeys?: number;
+    /**
+     * Maximum number of parallel contract calls to execute in batch functions
+     */
     maxParallelCalls?: number;
 };
 /**
@@ -29,10 +48,12 @@ export declare class StarknetChainInterface implements ChainInterface<StarknetTx
     readonly starknetChainId: constants.StarknetChainId;
     /**
      * Optional websocket channel for instant notifications
+     * @internal
      */
     readonly wsChannel?: WebSocketChannel;
     /**
      * Underlying starknet.js provider
+     * @internal
      */
     readonly provider: Provider;
     Fees: StarknetFees;
@@ -96,6 +117,10 @@ export declare class StarknetChainInterface implements ChainInterface<StarknetTx
      * @inheritDoc
      */
     sendSignedAndConfirm(signedTxs: SignedStarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * @inheritDoc
+     */
+    prepareTxs(txs: StarknetTx[]): Promise<StarknetTx[]>;
     /**
      * @inheritDoc
      */

package/dist/starknet/chain/StarknetChainInterface.js

@@ -123,6 +123,13 @@ class StarknetChainInterface {
     sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
         return this.Transactions.sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
     }
+    /**
+     * @inheritDoc
+     */
+    async prepareTxs(txs) {
+        await this.Transactions.prepareTransactions(txs);
+        return txs;
+    }
     /**
      * @inheritDoc
      */

package/dist/starknet/chain/modules/StarknetFees.d.ts

@@ -19,30 +19,26 @@ export type StarknetGas = {
     l2Gas: number;
     l1DataGas: number;
 };
-/**
- * Multiplies all the gas parameters by a specific scalar
- *
- * @param gas
- * @param scalar
- *
- * @category Chain Interface
- */
-export declare function starknetGasMul(gas: StarknetGas, scalar: number): StarknetGas;
-/**
- * Sums up all the gas parameters
- *
- * @param a
- * @param b
- *
- * @category Chain Interface
- */
-export declare function starknetGasAdd(a: StarknetGas, b?: StarknetGas): StarknetGas;
 /**
  * A module for starknet fee estimation
  *
  * @category Chain Interface
  */
 export declare class StarknetFees {
+    /**
+     * Multiplies all the gas parameters by a specific scalar
+     *
+     * @param gas
+     * @param scalar
+     */
+    static starknetGasMul(gas: StarknetGas, scalar: number): StarknetGas;
+    /**
+     * Sums up all the gas parameters
+     *
+     * @param a
+     * @param b
+     */
+    static starknetGasAdd(a: StarknetGas, b?: StarknetGas): StarknetGas;
     private readonly logger;
     private readonly feeDA;
     private readonly nonceDA;
@@ -54,7 +50,7 @@ export declare class StarknetFees {
      * Constructs a new Starknet fee module
      *
      * @param provider A starknet.js provider to use for fee estimation
-     * @param maxFeeRate Fee rate limits in base units
+     * @param maxFeeRate Fee rate limits in base units, defaults to L1: 20 PFri, L2: 4 PFri, L1 data: 10 PFri
      * @param feeMultiplier A multiplier to use for the returned fee rates
      * @param da Data-availability mode - currently just L1
      */