@atomiqlabs/chain-starknet 8.1.11 → 8.2.2

package/dist/starknet/wallet/StarknetBrowserSigner.d.ts

@@ -7,5 +7,13 @@ import { Account } from "starknet";
  * @category Wallets
  */
 export declare class StarknetBrowserSigner extends StarknetSigner {
-    constructor(account: Account);
+    private usesECDSADN?;
+    getReproducibleEntropy?: (appName: string) => Promise<Buffer>;
+    /**
+     * @param account Signer account to request signatures and send transaction through
+     * @param usesECDSADN Optional flag indicating whether the signer supports signing using ECDSA-DN (deterministic
+     *  nonce) algorithm, this allows the wallet to produce reproducible entropy. Only pass `true` here if you are
+     *  100% sure that the signer supports this!
+     */
+    constructor(account: Account, usesECDSADN?: boolean);
 }

package/dist/starknet/wallet/StarknetBrowserSigner.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetBrowserSigner = void 0;
 const StarknetSigner_1 = require("./StarknetSigner");
+const Utils_1 = require("../../utils/Utils");
 /**
  * Browser-based Starknet signer, use with browser based signer accounts, this ensures that
  *  no signTransaction calls are made and only sendTransaction is supported!
@@ -9,9 +10,38 @@ const StarknetSigner_1 = require("./StarknetSigner");
  * @category Wallets
  */
 class StarknetBrowserSigner extends StarknetSigner_1.StarknetSigner {
-    constructor(account) {
+    /**
+     * @param account Signer account to request signatures and send transaction through
+     * @param usesECDSADN Optional flag indicating whether the signer supports signing using ECDSA-DN (deterministic
+     *  nonce) algorithm, this allows the wallet to produce reproducible entropy. Only pass `true` here if you are
+     *  100% sure that the signer supports this!
+     */
+    constructor(account, usesECDSADN) {
         super(account, false);
+        this.usesECDSADN = usesECDSADN;
         this.signTransaction = undefined;
+        if (this.usesECDSADN !== false) {
+            this.getReproducibleEntropy = async (appName) => {
+                if (this.usesECDSADN === false)
+                    throw new Error("This wallet doesn't support generating recoverable entropy!");
+                const typedData = StarknetSigner_1.StarknetSigner.getReproducibleEntropyMessage(await account.getChainId(), appName);
+                const signature = await account.signMessage(typedData);
+                const serializedSignature = (0, Utils_1.serializeSignature)(signature);
+                if (this.usesECDSADN !== true) {
+                    const secondSignature = (0, Utils_1.serializeSignature)(await account.signMessage(typedData));
+                    if (serializedSignature.length === secondSignature.length &&
+                        serializedSignature.every((value, index) => secondSignature[index] === value)) {
+                        this.usesECDSADN = true;
+                    }
+                    else {
+                        this.usesECDSADN = false;
+                        this.getReproducibleEntropy = undefined;
+                        throw new Error("This wallet doesn't support generating recoverable entropy!");
+                    }
+                }
+                return Buffer.concat(serializedSignature.map((value) => (0, Utils_1.bigNumberishToBuffer)(value, 32)));
+            };
+        }
     }
 }
 exports.StarknetBrowserSigner = StarknetBrowserSigner;

package/dist/starknet/wallet/StarknetSigner.d.ts

@@ -1,5 +1,5 @@
 import { AbstractSigner } from "@atomiqlabs/base";
-import { Account, DeployAccountContractPayload, Invocation, DeployAccountContractTransaction } from "starknet";
+import { Account, DeployAccountContractPayload, Invocation, DeployAccountContractTransaction, constants } from "starknet";
 import { StarknetTx, StarknetTxDeployAccount, StarknetTxInvoke } from "../chain/modules/StarknetTransactions";
 /**
  * Starknet signer implementation wrapping a starknet.js {@link Account}, for browser
@@ -8,6 +8,48 @@ import { StarknetTx, StarknetTxDeployAccount, StarknetTxInvoke } from "../chain/
  * @category Wallets
  */
 export declare class StarknetSigner implements AbstractSigner {
+    /**
+     * A static message (text message part), which should be signed by the Starknet wallets to generate reproducible entropy. Works when
+     *  wallets use signing with deterministic nonce, such that signature over the same message always yields the
+     *  same signature (same entropy).
+     */
+    private static readonly STARKNET_REPRODUCIBLE_ENTROPY_MESSAGE;
+    /**
+     * A static message (warning part), which should be signed by the Starknet wallets to generate reproducible entropy. Works when
+     *  wallets use signing with deterministic nonce, such that signature over the same message always yields the
+     *  same signature (same entropy).
+     */
+    private static readonly STARKNET_REPRODUCIBLE_ENTROPY_WARNING;
+    /**
+     * Returns a SNIP-12 message to be signed for extracting reproducible entropy. Works when wallets use signing with
+     *  deterministic nonce, such that signature over the same message always yields the same signature (same entropy).
+     *
+     * @param starknetChainId Starknet chain ID to use for the SNIP-12 message
+     * @param appName Application name to differentiate reproducible entropy generated across different apps
+     */
+    static getReproducibleEntropyMessage(starknetChainId: constants.StarknetChainId, appName: string): {
+        types: {
+            StarknetDomain: {
+                name: string;
+                type: string;
+            }[];
+            Message: {
+                name: string;
+                type: string;
+            }[];
+        };
+        primaryType: string;
+        domain: {
+            name: string;
+            version: string;
+            chainId: string;
+            revision: string;
+        };
+        message: {
+            Message: string;
+            Warning: string;
+        };
+    };
     type: "AtomiqAbstractSigner";
     readonly isManagingNoncesInternally: boolean;
     readonly account: Account;
@@ -23,9 +65,8 @@ export declare class StarknetSigner implements AbstractSigner {
      */
     getAddress(): string;
     /**
-     *
      * @param tx
-     * @protected
+     * @internal
      */
     protected _signTransaction(tx: StarknetTx): Promise<StarknetTx>;
     /**

package/dist/starknet/wallet/StarknetSigner.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetSigner = void 0;
+const starknet_1 = require("starknet");
 const Utils_1 = require("../../utils/Utils");
 const StarknetTransactions_1 = require("../chain/modules/StarknetTransactions");
 /**
@@ -10,6 +11,42 @@ const StarknetTransactions_1 = require("../chain/modules/StarknetTransactions");
  * @category Wallets
  */
 class StarknetSigner {
+    /**
+     * Returns a SNIP-12 message to be signed for extracting reproducible entropy. Works when wallets use signing with
+     *  deterministic nonce, such that signature over the same message always yields the same signature (same entropy).
+     *
+     * @param starknetChainId Starknet chain ID to use for the SNIP-12 message
+     * @param appName Application name to differentiate reproducible entropy generated across different apps
+     */
+    static getReproducibleEntropyMessage(starknetChainId, appName) {
+        const message = StarknetSigner.STARKNET_REPRODUCIBLE_ENTROPY_MESSAGE.replace(new RegExp("%APPNAME%", 'g'), appName);
+        const warning = StarknetSigner.STARKNET_REPRODUCIBLE_ENTROPY_WARNING.replace(new RegExp("%APPNAME%", 'g'), appName);
+        return {
+            types: {
+                StarknetDomain: [
+                    { name: 'name', type: 'shortstring' },
+                    { name: 'version', type: 'shortstring' },
+                    { name: 'chainId', type: 'shortstring' },
+                    { name: 'revision', type: 'shortstring' },
+                ],
+                Message: [
+                    { name: 'Message', type: 'string' },
+                    { name: 'Warning', type: 'string' }
+                ],
+            },
+            primaryType: 'Message',
+            domain: {
+                name: appName,
+                version: '1',
+                chainId: starknet_1.shortString.decodeShortString(starknetChainId),
+                revision: '1'
+            },
+            message: {
+                'Message': message,
+                'Warning': warning
+            }
+        };
+    }
     constructor(account, isManagingNoncesInternally = false) {
         this.type = "AtomiqAbstractSigner";
         this.account = account;
@@ -22,9 +59,8 @@ class StarknetSigner {
         return (0, Utils_1.toHex)(this.account.address);
     }
     /**
-     *
      * @param tx
-     * @protected
+     * @internal
      */
     async _signTransaction(tx) {
         if ((0, StarknetTransactions_1.isStarknetTxInvoke)(tx)) {
@@ -112,3 +148,17 @@ class StarknetSigner {
     }
 }
 exports.StarknetSigner = StarknetSigner;
+/**
+ * A static message (text message part), which should be signed by the Starknet wallets to generate reproducible entropy. Works when
+ *  wallets use signing with deterministic nonce, such that signature over the same message always yields the
+ *  same signature (same entropy).
+ */
+StarknetSigner.STARKNET_REPRODUCIBLE_ENTROPY_MESSAGE = "Signing this messages generates a reproducible secret" +
+    " to be used on %APPNAME%.";
+/**
+ * A static message (warning part), which should be signed by the Starknet wallets to generate reproducible entropy. Works when
+ *  wallets use signing with deterministic nonce, such that signature over the same message always yields the
+ *  same signature (same entropy).
+ */
+StarknetSigner.STARKNET_REPRODUCIBLE_ENTROPY_WARNING = "PLEASE DOUBLE CHECK THAT YOU ARE ON THE %APPNAME%" +
+    " WEBSITE BEFORE SIGNING THE MESSAGE, SIGNING THIS MESSAGE ON ANY OTHER WEBSITE MIGHT LEAD TO LOSS OF FUNDS!";

package/dist/utils/Utils.d.ts

@@ -44,7 +44,7 @@ export declare function bufferToByteArray(buffer: Buffer, startIndex?: number, e
 export declare function poseidonHashRange(buffer: Buffer, startIndex?: number, endIndex?: number): BigNumberish;
 export declare function findLastIndex<T>(array: T[], callback: (value: T, index: number) => boolean): number;
 export declare function bigIntMax(a: bigint, b: bigint): bigint;
-export declare function serializeSignature(signature?: Signature): ReplaceBigInt<Signature> | undefined;
+export declare function serializeSignature(signature?: Signature): string[] | undefined;
 export declare function deserializeSignature(signature?: ReplaceBigInt<Signature>): Signature | undefined;
 export declare function serializeResourceBounds(resourceBounds: {
     l2_gas: {

package/dist/utils/Utils.js

@@ -113,11 +113,11 @@ function calculateHash(tx) {
         case "DEPLOY_ACCOUNT":
             if (tx.signed.constructorCalldata == null ||
                 tx.signed.addressSalt == null ||
-                tx.tx.contractAddress == null)
+                tx.details.walletAddress == null)
                 throw new Error("TX not enough data to compute hash!");
             const deployAccountData = starknet_1.CallData.compile(tx.signed.constructorCalldata);
             return tx.txId = starknet_1.hash.calculateDeployAccountTransactionHash({
-                contractAddress: tx.tx.contractAddress,
+                contractAddress: tx.details.walletAddress,
                 classHash: tx.signed.classHash,
                 compiledConstructorCalldata: deployAccountData,
                 salt: tx.signed.addressSalt,

package/node/index.d.ts

@@ -0,0 +1 @@
+export * from "../dist/node";

package/node/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("../dist/node");

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "8.1.11",
+  "version": "8.2.2",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
+    "build": "npx -y -p typescript@4.9 tsc",
     "prepublishOnly": "npm run build",
     "test": "echo \"Error: no test specified\" && exit 1",
     "build:ts4": "npx -p typescript@4.9 tsc --noEmit",
@@ -13,7 +13,8 @@
   },
   "files": [
     "/dist",
-    "/src"
+    "/src",
+    "/node"
   ],
   "keywords": [
     "Starknet",
@@ -30,7 +31,7 @@
     "url": "git+https://github.com/atomiqlabs/atomiq-chain-starknet.git"
   },
   "dependencies": {
-    "@atomiqlabs/base": "^13.1.9",
+    "@atomiqlabs/base": "^13.2.0",
     "@noble/hashes": "^1.7.1",
     "@scure/btc-signer": "^1.6.0",
     "abi-wan-kanabi": "2.2.4",

package/src/index.ts

@@ -1,3 +1,71 @@
+/**
+ * # @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
+ */
 import * as WebSocket from "ws";
 if(global.window==null) global.WebSocket = WebSocket as any;
 
@@ -6,8 +74,14 @@ 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";

package/src/node/index.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/src/starknet/StarknetInitializer.ts

@@ -25,7 +25,7 @@ export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK" | "WBTC" | "TBTC"
  *
  * @category Chain Interface
  */
-export const StarknetAssets: StarknetAssetsType = {
+const StarknetAssets: StarknetAssetsType = {
     ETH: {
         address: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
         decimals: 18,
@@ -65,17 +65,50 @@ export const StarknetAssets: StarknetAssetsType = {
  * @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
@@ -85,8 +118,14 @@ export type StarknetOptions = {
         }
     }
 
+    /**
+     * Starknet network fee API
+     */
     fees?: StarknetFees,
 
+    /**
+     * Starknet configuration
+     */
     starknetConfig?: StarknetConfig
 }
 

package/src/starknet/btcrelay/StarknetBtcRelay.ts

@@ -11,8 +11,8 @@ import {StarknetBtcStoredHeader} from "./headers/StarknetBtcStoredHeader";
 import {StarknetTx} from "../chain/modules/StarknetTransactions";
 import {StarknetSigner} from "../wallet/StarknetSigner";
 import {BtcRelayAbi} from "./BtcRelayAbi";
-import {BigNumberish, constants, hash} from "starknet";
-import {StarknetFees, starknetGasAdd, starknetGasMul} from "../chain/modules/StarknetFees";
+import {BigNumberish, hash} from "starknet";
+import {StarknetFees} from "../chain/modules/StarknetFees";
 import {StarknetChainInterface} from "../chain/StarknetChainInterface";
 import {StarknetAction} from "../chain/StarknetAction";
 
@@ -70,7 +70,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
      * @param mainHeaders New bitcoin blockheaders to submit
      * @param storedHeader Current latest committed and stored bitcoin blockheader in the light client
      */
-    public SaveMainHeaders(signer: string, mainHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction {
+    private SaveMainHeaders(signer: string, mainHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction {
 
         return new StarknetAction(signer, this.Chain,
             {
@@ -78,7 +78,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
                 entrypoint: "submit_main_blockheaders",
                 calldata: serializeCalldata(mainHeaders, storedHeader, [])
             },
-            starknetGasMul(GAS_PER_BLOCKHEADER, mainHeaders.length)
+            StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER, mainHeaders.length)
         )
     }
 
@@ -91,14 +91,14 @@ export class StarknetBtcRelay<B extends BtcBlock>
      * @param forkHeaders Fork bitcoin blockheaders to submit
      * @param storedHeader Committed and stored bitcoin blockheader from which to fork the light client
      */
-    public SaveShortForkHeaders(signer: string, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction {
+    private SaveShortForkHeaders(signer: string, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction {
         return new StarknetAction(signer, this.Chain,
             {
                 contractAddress: this.contract.address,
                 entrypoint: "submit_short_fork_blockheaders",
                 calldata: serializeCalldata(forkHeaders, storedHeader, [])
             },
-            starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length)
+            StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length)
         )
     }
 
@@ -112,21 +112,24 @@ export class StarknetBtcRelay<B extends BtcBlock>
      *  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
      */
-    public SaveLongForkHeaders(signer: string, forkId: number, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader, totalForkHeaders: number = 100): StarknetAction {
+    private SaveLongForkHeaders(signer: string, forkId: number, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader, totalForkHeaders: number = 100): StarknetAction {
         return new StarknetAction(signer, this.Chain,
             {
                 contractAddress: this.contract.address,
                 entrypoint: "submit_fork_blockheaders",
                 calldata: serializeCalldata(forkHeaders, storedHeader, [toHex(forkId)])
             },
-            starknetGasAdd(
-                starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length),
-                starknetGasMul(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)
+            StarknetFees.starknetGasAdd(
+                StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length),
+                StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)
             )
         )
     }
 
-    bitcoinRpc: BitcoinRpc<B>;
+    /**
+     * @internal
+     */
+    readonly _bitcoinRpc: BitcoinRpc<B>;
 
     readonly maxHeadersPerTx: number = 40;
     readonly maxForkHeadersPerTx: number = 30;
@@ -147,7 +150,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
                 ? btcRelayDeploymentHeights[bitcoinNetwork]
                 : undefined)
         );
-        this.bitcoinRpc = bitcoinRpc;
+        this._bitcoinRpc = bitcoinRpc;
     }
 
     /**
@@ -223,7 +226,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
             const starknetBlockHash = hash.computePoseidonHashOnElements(bufferToU32Array(Buffer.from([...blockHash]).reverse()));
             keys.push(starknetBlockHash);
         }
-        return this.Events.findInContractEvents(
+        return this._Events.findInContractEvents(
             ["btc_relay::events::StoreHeader", "btc_relay::events::StoreForkHeader"],
             keys,
             (event) => {
@@ -314,7 +317,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
         resultStoredHeader: StarknetBtcStoredHeader,
         resultBitcoinHeader: B
     } | null> {
-        const data = await this.Events.findInContractEvents(
+        const data = await this._Events.findInContractEvents(
             ["btc_relay::events::StoreHeader", "btc_relay::events::StoreForkHeader"],
             null,
             async (event) => {
@@ -324,14 +327,14 @@ export class StarknetBtcRelay<B extends BtcBlock>
                 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/src/starknet/btcrelay/headers/StarknetBtcHeader.ts

@@ -33,6 +33,8 @@ export 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) {
         this.reversed_version = Number(obj.reversed_version);

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

@@ -31,7 +31,9 @@ export class StarknetBtcStoredHeader implements BtcStoredHeader<StarknetBtcHeade
     /**
      * 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) {
         this.blockheader = obj.blockheader instanceof StarknetBtcHeader ? obj.blockheader : new StarknetBtcHeader(obj.blockheader);

package/src/starknet/chain/StarknetAction.ts

@@ -1,7 +1,7 @@
 import {Call} from "starknet";
 import {StarknetChainInterface} from "./StarknetChainInterface";
 import {StarknetTx} from "./modules/StarknetTransactions";
-import {StarknetGas, starknetGasAdd} from "./modules/StarknetFees";
+import {StarknetFees, StarknetGas} from "./modules/StarknetFees";
 
 /**
  * An action which contains multiple underlying contract calls (invokes), tracks their total gas limits
@@ -54,7 +54,7 @@ export class StarknetAction {
      */
     public addIx(instruction: Call, gasLimit?: StarknetGas) {
         this.instructions.push(instruction);
-        if(gasLimit!=null) this.gas = starknetGasAdd(this.gas, gasLimit);
+        if(gasLimit!=null) this.gas = StarknetFees.starknetGasAdd(this.gas, gasLimit);
     }
 
     /**

package/src/starknet/chain/StarknetChainInterface.ts

@@ -20,10 +20,28 @@ import {StarknetBrowserSigner} from "../wallet/StarknetBrowserSigner";
  * @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, //100
+    /**
+     * 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, //2000
+    /**
+     * Maximum numbers of keys allowed to be specified in a single `starknet_getEvents` RPC call
+     *
+     * Defaults to 64 keys
+     */
     maxGetLogKeys?: number, //64
-
+    /**
+     * Maximum number of parallel contract calls to execute in batch functions
+     */
     maxParallelCalls?: number, //10
 };
 
@@ -39,10 +57,12 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Signed
 
     /**
      * Optional websocket channel for instant notifications
+     * @internal
      */
     readonly wsChannel?: WebSocketChannel;
     /**
      * Underlying starknet.js provider
+     * @internal
      */
     readonly provider: Provider;
 
@@ -191,6 +211,14 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Signed
         return this.Transactions.sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
     }
 
+    /**
+     * @inheritDoc
+     */
+    async prepareTxs(txs: StarknetTx[]): Promise<StarknetTx[]> {
+        await this.Transactions.prepareTransactions(txs);
+        return txs;
+    }
+
     /**
      * @inheritDoc
      */