@atomiqlabs/chain-starknet 8.1.11 → 8.2.2

package/dist/starknet/chain/modules/StarknetFees.js

@@ -1,49 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetFees = exports.starknetGasAdd = exports.starknetGasMul = void 0;
+exports.StarknetFees = void 0;
 const Utils_1 = require("../../../utils/Utils");
 const MAX_FEE_AGE = 5000;
-/**
- * Multiplies all the gas parameters by a specific scalar
- *
- * @param gas
- * @param scalar
- *
- * @category Chain Interface
- */
-function starknetGasMul(gas, scalar) {
-    return { l1Gas: gas.l1Gas * scalar, l2Gas: gas.l2Gas * scalar, l1DataGas: gas.l1DataGas * scalar };
-}
-exports.starknetGasMul = starknetGasMul;
-/**
- * Sums up all the gas parameters
- *
- * @param a
- * @param b
- *
- * @category Chain Interface
- */
-function starknetGasAdd(a, b) {
-    if (b == null)
-        return a;
-    return { l1Gas: a.l1Gas + b.l1Gas, l2Gas: a.l2Gas + b.l2Gas, l1DataGas: a.l1DataGas + b.l1DataGas };
-}
-exports.starknetGasAdd = starknetGasAdd;
 /**
  * A module for starknet fee estimation
  *
  * @category Chain Interface
  */
 class StarknetFees {
+    /**
+     * Multiplies all the gas parameters by a specific scalar
+     *
+     * @param gas
+     * @param scalar
+     */
+    static starknetGasMul(gas, scalar) {
+        return { l1Gas: gas.l1Gas * scalar, l2Gas: gas.l2Gas * scalar, l1DataGas: gas.l1DataGas * scalar };
+    }
+    /**
+     * Sums up all the gas parameters
+     *
+     * @param a
+     * @param b
+     */
+    static starknetGasAdd(a, b) {
+        if (b == null)
+            return a;
+        return { l1Gas: a.l1Gas + b.l1Gas, l2Gas: a.l2Gas + b.l2Gas, l1DataGas: a.l1DataGas + b.l1DataGas };
+    }
     /**
      * 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
      */
-    constructor(provider, maxFeeRate = { l1GasCost: 20000000000000000n, l2GasCost: 4000000000000000n, l1DataGasCost: 10000000000000000n }, feeMultiplier = 1.25, da) {
+    constructor(provider, maxFeeRate = { l1GasCost: 20000000000000000n, l2GasCost: 4000000000000000n, l1DataGasCost: 10000000000000000n }, feeMultiplier = 1.25, da = { fee: "L1", nonce: "L1" }) {
         this.logger = (0, Utils_1.getLogger)("StarknetFees: ");
         this.provider = provider;
         this.maxFeeRate = maxFeeRate;

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

@@ -7,28 +7,52 @@ export type StarknetTxBase = {
     };
     txId?: string;
 };
+/**
+ * "INVOKE" type of transaction, used to call smart contracts on Starknet
+ *
+ * @category Chain Interface
+ */
 export type StarknetTxInvoke = StarknetTxBase & {
     type: "INVOKE";
     tx: Array<Call>;
     signed?: Invocation;
 };
+/**
+ * Type-guard for the "INVOKE" type of transaction, used to call smart contracts on Starknet
+ *
+ * @category Chain Interface
+ */
 export declare function isStarknetTxInvoke(obj: any): obj is StarknetTxInvoke;
+/**
+ * "DEPLOY_ACCOUNT" type of transaction, used as a first transaction that the account does to deploy its smart
+ *  account contract on the Starknet
+ *
+ * @category Chain Interface
+ */
 export type StarknetTxDeployAccount = StarknetTxBase & {
     type: "DEPLOY_ACCOUNT";
     tx: DeployAccountContractPayload;
     signed?: DeployAccountContractTransaction;
 };
+/**
+ * Type-guard for the "DEPLOY_ACCOUNT" type of transaction, used as a first transaction that the account does
+ *  to deploy its smart account contract on the Starknet
+ *
+ * @category Chain Interface
+ */
 export declare function isStarknetTxDeployAccount(obj: any): obj is StarknetTxDeployAccount;
 /**
- * Unsigned starknet transaction, either an invoke transaction calling contracts or account deploy transaction
+ * Represents a Starknet transactions, which can either be an "INVOKE" or "DEPLOY_ACCOUNT" type, use the
+ *  {@link isStarknetTxInvoke} & {@link isStarknetTxDeployAccount} to narrow down the type.
  *
  * @category Chain Interface
  */
 export type StarknetTx = StarknetTxInvoke | StarknetTxDeployAccount;
 /**
- * Signed starknet transaction, either an invoke transaction calling contracts or account deploy transaction.
+ * Represents a signed Starknet transactions, which can either be an "INVOKE" or "DEPLOY_ACCOUNT" type, use the
+ *  {@link isStarknetTxInvoke} & {@link isStarknetTxDeployAccount} to narrow down the type.
  *
- * @remarks Uses the same type as the unsinged tx for Starknet!
+ * @remark For Starknet this is just an alias for {@link StarknetTx}
  *
  * @category Chain Interface
  */
@@ -66,13 +90,15 @@ export declare class StarknetTransactions extends StarknetModule {
      */
     private confirmTransaction;
     /**
-     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed
+     *  & calls beforeTxSigned callback (only if signer is passed!)
      *
      * @param signer
      * @param txs
-     * @private
      */
-    private prepareTransactions;
+    prepareTransactions(txs: (StarknetTx & {
+        addedInPrepare?: boolean;
+    })[], signer?: StarknetSigner): Promise<void>;
     /**
      * Sends out a signed transaction to the RPC
      *

package/dist/starknet/chain/modules/StarknetTransactions.js

@@ -5,6 +5,11 @@ const StarknetModule_1 = require("../StarknetModule");
 const starknet_1 = require("starknet");
 const Utils_1 = require("../../../utils/Utils");
 const base_1 = require("@atomiqlabs/base");
+/**
+ * Type-guard for the "INVOKE" type of transaction, used to call smart contracts on Starknet
+ *
+ * @category Chain Interface
+ */
 function isStarknetTxInvoke(obj) {
     return typeof (obj) === "object" &&
         typeof (obj.details) === "object" &&
@@ -14,6 +19,12 @@ function isStarknetTxInvoke(obj) {
         (obj.signed == null || typeof (obj.signed) === "object");
 }
 exports.isStarknetTxInvoke = isStarknetTxInvoke;
+/**
+ * Type-guard for the "DEPLOY_ACCOUNT" type of transaction, used as a first transaction that the account does
+ *  to deploy its smart account contract on the Starknet
+ *
+ * @category Chain Interface
+ */
 function isStarknetTxDeployAccount(obj) {
     return typeof (obj) === "object" &&
         typeof (obj.details) === "object" &&
@@ -203,29 +214,45 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
         return result.txId;
     }
     /**
-     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed
+     *  & calls beforeTxSigned callback (only if signer is passed!)
      *
      * @param signer
      * @param txs
-     * @private
      */
-    async prepareTransactions(signer, txs) {
-        let nonce = await this.getNonce(signer.getAddress());
-        const latestPendingNonce = this.latestPendingNonces[(0, Utils_1.toHex)(signer.getAddress())];
+    async prepareTransactions(txs, signer) {
+        if (txs.length === 0)
+            return;
+        const signerAddress = signer?.getAddress() ?? txs[0].details.walletAddress;
+        if (signerAddress == null)
+            throw new Error("Cannot get tx sender address!");
+        let nonce = await this.getNonce(signerAddress);
+        const latestPendingNonce = this.latestPendingNonces[(0, Utils_1.toHex)(signerAddress)];
         if (latestPendingNonce != null && latestPendingNonce > nonce) {
             this.logger.debug("prepareTransactions(): Using 'pending' nonce from local cache!");
             nonce = latestPendingNonce;
         }
         //Add deploy account tx
         if (nonce === 0n) {
-            const deployPayload = await signer.getDeployPayload();
-            if (deployPayload != null) {
-                const tx = await this.root.Accounts.getAccountDeployTransaction(deployPayload);
+            if (signer != null) {
+                const deployPayload = await signer.getDeployPayload();
+                if (deployPayload != null) {
+                    const tx = await this.root.Accounts.getAccountDeployTransaction(deployPayload);
+                    tx.addedInPrepare = true;
+                    txs.unshift(tx);
+                }
+            }
+            else {
+                // Use a 0x0 class hash to indicate that deployment is needed by external signer
+                const tx = await this.root.Accounts.getAccountDeployTransaction({
+                    classHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    contractAddress: signerAddress
+                });
                 tx.addedInPrepare = true;
                 txs.unshift(tx);
             }
         }
-        if (!signer.isManagingNoncesInternally) {
+        if (signer == null || !signer.isManagingNoncesInternally) {
             if (nonce === 0n) {
                 //Just increment the nonce by one and hope the wallet is smart enough to deploy account first
                 nonce = 1n;
@@ -235,18 +262,19 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
                 if (tx.details.nonce != null)
                     nonce = BigInt(tx.details.nonce); //Take the nonce from last tx
                 if (nonce == null)
-                    nonce = BigInt(await this.root.provider.getNonceForAddress(signer.getAddress())); //Fetch the nonce
+                    nonce = BigInt(await this.root.provider.getNonceForAddress(signerAddress)); //Fetch the nonce
                 if (tx.details.nonce == null)
                     tx.details.nonce = nonce;
                 this.logger.debug("prepareTransactions(): transaction prepared (" + (i + 1) + "/" + txs.length + "), nonce: " + tx.details.nonce);
                 nonce += BigInt(1);
             }
         }
-        for (let tx of txs) {
-            for (let callback of this.cbksBeforeTxSigned) {
-                await callback(tx);
+        if (signer != null)
+            for (let tx of txs) {
+                for (let callback of this.cbksBeforeTxSigned) {
+                    await callback(tx);
+                }
             }
-        }
     }
     /**
      * Sends out a signed transaction to the RPC
@@ -282,13 +310,14 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
      */
     async sendAndConfirm(signer, _txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
         const txs = _txs;
-        await this.prepareTransactions(signer, txs);
+        await this.prepareTransactions(txs, signer);
         const signedTxs = [];
         //Don't separate the signing process from the sending when using browser-based wallet
         if (signer.signTransaction != null)
             for (let i = 0; i < txs.length; i++) {
                 const tx = txs[i];
                 const signedTx = await signer.signTransaction(tx);
+                (0, Utils_1.calculateHash)(signedTx);
                 signedTx.addedInPrepare = tx.addedInPrepare;
                 signedTxs.push(signedTx);
                 this.logger.debug("sendAndConfirm(): transaction signed (" + (i + 1) + "/" + txs.length + "): " + signedTx.txId);
@@ -373,9 +402,10 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
         return txIds;
     }
     async sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
-        signedTxs.forEach(val => {
-            if (val.signed == null)
+        signedTxs.forEach(tx => {
+            if (tx.signed == null)
                 throw new Error("Transactions have to be signed!");
+            (0, Utils_1.calculateHash)(tx);
         });
         this.logger.debug("sendSignedAndConfirm(): sending transactions, count: " + signedTxs.length +
             " waitForConfirmation: " + waitForConfirmation + " parallel: " + parallel);

package/dist/starknet/contract/StarknetContractBase.d.ts

@@ -7,8 +7,17 @@ import { StarknetContractEvents } from "./modules/StarknetContractEvents";
  */
 export declare class StarknetContractBase<T extends Abi> {
     readonly contract: TypedContractV2<T>;
-    readonly Events: StarknetContractEvents<T>;
-    readonly Chain: StarknetChainInterface;
-    readonly contractDeploymentHeight?: number;
+    /**
+     * @internal
+     */
+    readonly _Events: StarknetContractEvents<T>;
+    /**
+     * @internal
+     */
+    protected readonly Chain: StarknetChainInterface;
+    /**
+     * @internal
+     */
+    readonly _contractDeploymentHeight?: number;
     constructor(chainInterface: StarknetChainInterface, contractAddress: string, contractAbi: T, contractDeploymentHeight?: number);
 }

package/dist/starknet/contract/StarknetContractBase.js

@@ -14,8 +14,8 @@ class StarknetContractBase {
             address: contractAddress,
             providerOrAccount: chainInterface.provider
         }).typedv2(contractAbi);
-        this.Events = new StarknetContractEvents_1.StarknetContractEvents(chainInterface, this, contractAbi);
-        this.contractDeploymentHeight = contractDeploymentHeight;
+        this._Events = new StarknetContractEvents_1.StarknetContractEvents(chainInterface, this, contractAbi);
+        this._contractDeploymentHeight = contractDeploymentHeight;
     }
 }
 exports.StarknetContractBase = StarknetContractBase;

package/dist/starknet/contract/modules/StarknetContractEvents.js

@@ -105,7 +105,7 @@ class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
                     return result;
             }
             return null;
-        }, Math.max(startHeight ?? 0, this.contract.contractDeploymentHeight ?? 0), abortSignal);
+        }, Math.max(startHeight ?? 0, this.contract._contractDeploymentHeight ?? 0), abortSignal);
     }
 }
 exports.StarknetContractEvents = StarknetContractEvents;

package/dist/starknet/events/StarknetChainEvents.d.ts

@@ -17,5 +17,8 @@ export declare class StarknetChainEvents extends StarknetChainEventsBrowser {
      * @private
      */
     private saveLastEventData;
+    /**
+     * @inheritDoc
+     */
     init(noAutomaticPoll?: boolean): Promise<void>;
 }

package/dist/starknet/events/StarknetChainEvents.js

@@ -48,6 +48,9 @@ class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEven
     saveLastEventData(newState) {
         return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, newState.map(value => value.lastTxHash == null ? value.lastBlockNumber.toString(10) : value.lastBlockNumber.toString(10) + ";" + value.lastTxHash).join(","));
     }
+    /**
+     * @inheritDoc
+     */
     async init(noAutomaticPoll) {
         if (noAutomaticPoll)
             return;

package/dist/starknet/events/StarknetChainEventsBrowser.d.ts

@@ -11,7 +11,13 @@ import { StarknetChainInterface } from "../chain/StarknetChainInterface";
  * @category Events
  */
 export type StarknetEventListenerState = {
+    /**
+     * Block number of the last processed event
+     */
     lastBlockNumber: number;
+    /**
+     * Transaction hash of the last processed event
+     */
     lastTxHash?: string;
 };
 /**
@@ -24,16 +30,49 @@ export type StarknetEventListenerState = {
 export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData, StarknetEventListenerState[]> {
     private eventsProcessing;
     private processedEvents;
+    /**
+     * @internal
+     */
     protected readonly Chain: StarknetChainInterface;
+    /**
+     * @internal
+     */
     protected readonly listeners: EventListener<StarknetSwapData>[];
+    /**
+     * @internal
+     */
     protected readonly wsChannel?: WebSocketChannel;
+    /**
+     * @internal
+     */
     protected readonly provider: Provider;
+    /**
+     * @internal
+     */
     protected readonly starknetSwapContract: StarknetSwapContract;
+    /**
+     * @internal
+     */
     protected readonly starknetSpvVaultContract: StarknetSpvVaultContract;
+    /**
+     * @internal
+     */
     protected readonly logger: import("../../utils/Utils").LoggerType;
+    /**
+     * @internal
+     */
     protected escrowContractSubscription?: SubscriptionStarknetEventsEvent;
+    /**
+     * @internal
+     */
     protected spvVaultContractSubscription?: SubscriptionStarknetEventsEvent;
+    /**
+     * @internal
+     */
     protected stopped: boolean;
+    /**
+     * @internal
+     */
     protected pollIntervalSeconds: number;
     private timeout;
     constructor(chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
@@ -129,10 +168,7 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
      * @private
      */
     private checkEventsEcrowManager;
-    protected checkEventsSpvVaults(currentBlock: {
-        timestamp: number;
-        block_number: number;
-    }, lastTxHash?: string, lastBlockNumber?: number): Promise<StarknetEventListenerState>;
+    private checkEventsSpvVaults;
     /**
      * @inheritDoc
      */
@@ -140,9 +176,12 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
     /**
      * Sets up event handlers listening for swap events over websocket
      *
-     * @protected
+     * @internal
      */
     protected setupPoll(lastState?: StarknetEventListenerState[], saveLatestProcessedBlockNumber?: (newState: StarknetEventListenerState[]) => Promise<void>): Promise<void>;
+    /**
+     * @internal
+     */
     protected wsStarted: boolean;
     /**
      *
@@ -155,8 +194,7 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
      */
     private subscribeWsSpvVaultEvents;
     /**
-     *
-     * @protected
+     * @internal
      */
     protected setupWebsocket(): Promise<void>;
     /**

package/dist/starknet/events/StarknetChainEventsBrowser.js

@@ -19,9 +19,21 @@ class StarknetChainEventsBrowser {
     constructor(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds = 5) {
         this.eventsProcessing = {};
         this.processedEvents = new Set();
+        /**
+         * @internal
+         */
         this.listeners = [];
+        /**
+         * @internal
+         */
         this.logger = (0, Utils_1.getLogger)("StarknetChainEventsBrowser: ");
+        /**
+         * @internal
+         */
         this.stopped = true;
+        /**
+         * @internal
+         */
         this.wsStarted = false;
         this.Chain = chainInterface;
         this.wsChannel = chainInterface.wsChannel;
@@ -302,7 +314,7 @@ class StarknetChainEventsBrowser {
             return { lastTxHash, lastBlockNumber };
         }
         // this.logger.debug("checkEvents(EscrowManager): Requesting logs: "+logStartHeight+"...pending");
-        let events = await this.starknetSwapContract.Events.getContractBlockEvents(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], [], lastBlockNumber, null);
+        let events = await this.starknetSwapContract._Events.getContractBlockEvents(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], [], lastBlockNumber, null);
         if (lastTxHash != null) {
             const latestProcessedEventIndex = (0, Utils_1.findLastIndex)(events, val => val.txHash === lastTxHash);
             if (latestProcessedEventIndex !== -1) {
@@ -335,7 +347,7 @@ class StarknetChainEventsBrowser {
             return { lastTxHash, lastBlockNumber };
         }
         // this.logger.debug("checkEvents(SpvVaults): Requesting logs: "+logStartHeight+"...pending");
-        let events = await this.starknetSpvVaultContract.Events.getContractBlockEvents(["spv_swap_vault::events::Opened", "spv_swap_vault::events::Deposited", "spv_swap_vault::events::Closed", "spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"], [], lastBlockNumber, null);
+        let events = await this.starknetSpvVaultContract._Events.getContractBlockEvents(["spv_swap_vault::events::Opened", "spv_swap_vault::events::Deposited", "spv_swap_vault::events::Closed", "spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"], [], lastBlockNumber, null);
         if (lastTxHash != null) {
             const latestProcessedEventIndex = (0, Utils_1.findLastIndex)(events, val => val.txHash === lastTxHash);
             if (latestProcessedEventIndex !== -1) {
@@ -376,7 +388,7 @@ class StarknetChainEventsBrowser {
     /**
      * Sets up event handlers listening for swap events over websocket
      *
-     * @protected
+     * @internal
      */
     async setupPoll(lastState, saveLatestProcessedBlockNumber) {
         let func;
@@ -404,7 +416,7 @@ class StarknetChainEventsBrowser {
             try {
                 subscription = await this.wsChannel.subscribeEvents({
                     fromAddress: this.starknetSwapContract.contract.address,
-                    keys: this.starknetSwapContract.Events.toFilter(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], []),
+                    keys: this.starknetSwapContract._Events.toFilter(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], []),
                     finalityStatus: starknet_1.TransactionFinalityStatus.ACCEPTED_ON_L2
                 });
             }
@@ -414,7 +426,7 @@ class StarknetChainEventsBrowser {
             }
         } while (subscription == null);
         subscription.on((event) => {
-            const parsedEvents = this.starknetSwapContract.Events.toStarknetAbiEvents([event]);
+            const parsedEvents = this.starknetSwapContract._Events.toStarknetAbiEvents([event]);
             this.processEvents(parsedEvents, event.block_number).catch(e => {
                 console.error(`WS: EscrowContract: Failed to process event ${parsedEvents[0].txHash}:${parsedEvents[0].name}: `, e);
             });
@@ -432,7 +444,7 @@ class StarknetChainEventsBrowser {
             try {
                 subscription = await this.wsChannel.subscribeEvents({
                     fromAddress: this.starknetSpvVaultContract.contract.address,
-                    keys: this.starknetSpvVaultContract.Events.toFilter(["spv_swap_vault::events::Opened", "spv_swap_vault::events::Deposited", "spv_swap_vault::events::Closed", "spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"], []),
+                    keys: this.starknetSpvVaultContract._Events.toFilter(["spv_swap_vault::events::Opened", "spv_swap_vault::events::Deposited", "spv_swap_vault::events::Closed", "spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"], []),
                     finalityStatus: starknet_1.TransactionFinalityStatus.ACCEPTED_ON_L2
                 });
             }
@@ -442,7 +454,7 @@ class StarknetChainEventsBrowser {
             }
         } while (subscription == null);
         subscription.on((event) => {
-            const parsedEvents = this.starknetSpvVaultContract.Events.toStarknetAbiEvents([event]);
+            const parsedEvents = this.starknetSpvVaultContract._Events.toStarknetAbiEvents([event]);
             this.processEvents(parsedEvents, event.block_number).catch(e => {
                 console.error(`WS: SpvVaultContract: Failed to process event ${parsedEvents[0].txHash}:${parsedEvents[0].name}: `, e);
             });
@@ -451,8 +463,7 @@ class StarknetChainEventsBrowser {
         this.logger.debug("subscribeWsSpvVaultEvents(): Successfully subscribed to spv vault contract WS events");
     }
     /**
-     *
-     * @protected
+     * @internal
      */
     async setupWebsocket() {
         if (this.wsChannel == null)

package/dist/starknet/spv_swap/StarknetSpvVaultContract.js

@@ -213,7 +213,7 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
      */
     async getAllVaults(owner) {
         const openedVaults = new Set();
-        await this.Events.findInContractEventsForward(["spv_swap_vault::events::Opened", "spv_swap_vault::events::Closed"], owner == null ? null : [null, null, owner], (event) => {
+        await this._Events.findInContractEventsForward(["spv_swap_vault::events::Opened", "spv_swap_vault::events::Closed"], owner == null ? null : [null, null, owner], (event) => {
             const owner = (0, Utils_1.toHex)(event.params.owner);
             const vaultId = (0, Utils_1.toBigInt)(event.params.vault_id);
             const vaultIdentifier = owner + ":" + vaultId.toString(10);
@@ -350,7 +350,7 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
                     }
                 }
             });
-            await this.Events.findInContractEventsForward(events, [lows, highs], async (event) => {
+            await this._Events.findInContractEventsForward(events, [lows, highs], async (event) => {
                 const txId = (0, Utils_1.bigNumberishToBuffer)(event.params.btc_tx_hash, 32).reverse().toString("hex");
                 if (result[txId] == null) {
                     this.logger.warn(`getWithdrawalStates(): findInContractEvents-callback: loaded event for ${txId}, but transaction not found in input params!`);
@@ -374,7 +374,7 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
         };
         const events = ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"];
         const keys = [(0, Utils_1.toHex)(txHashU256.low), (0, Utils_1.toHex)(txHashU256.high)];
-        await this.Events.findInContractEventsForward(events, keys, async (event) => {
+        await this._Events.findInContractEventsForward(events, keys, async (event) => {
             const eventResult = this.parseWithdrawalEvent(event);
             if (eventResult != null)
                 result = eventResult;
@@ -385,7 +385,7 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
         const { height: latestBlockheight } = await this.Chain.getFinalizedBlock();
         const withdrawals = {};
         const eventTypes = ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"];
-        await this.Events.findInContractEventsForward(eventTypes, [null, null, null, null, recipient], async (_event) => {
+        await this._Events.findInContractEventsForward(eventTypes, [null, null, null, null, recipient], async (_event) => {
             const eventResult = this.parseWithdrawalEvent(_event);
             if (eventResult == null || eventResult.type === base_1.SpvWithdrawalStateType.CLOSED)
                 return null;

package/dist/starknet/swaps/StarknetSwapContract.js

@@ -315,13 +315,13 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
                         };
                     },
                     getClaimTxId: async () => {
-                        const events = await this.Events.getContractBlockEvents(["escrow_manager::events::Claim"], [null, null, null, "0x" + escrowHash], blockHeight, blockHeight);
+                        const events = await this._Events.getContractBlockEvents(["escrow_manager::events::Claim"], [null, null, null, "0x" + escrowHash], blockHeight, blockHeight);
                         if (events.length === 0)
                             throw new Error("Claim event not found!");
                         return events[0].txHash;
                     },
                     getClaimResult: async () => {
-                        const events = await this.Events.getContractBlockEvents(["escrow_manager::events::Claim"], [null, null, null, "0x" + escrowHash], blockHeight, blockHeight);
+                        const events = await this._Events.getContractBlockEvents(["escrow_manager::events::Claim"], [null, null, null, "0x" + escrowHash], blockHeight, blockHeight);
                         if (events.length === 0)
                             throw new Error("Claim event not found!");
                         const event = events[0];
@@ -343,7 +343,7 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
                         };
                     },
                     getRefundTxId: async () => {
-                        const events = await this.Events.getContractBlockEvents(["escrow_manager::events::Refund"], [null, null, null, "0x" + escrowHash], blockHeight, blockHeight);
+                        const events = await this._Events.getContractBlockEvents(["escrow_manager::events::Refund"], [null, null, null, "0x" + escrowHash], blockHeight, blockHeight);
                         if (events.length === 0)
                             throw new Error("Refund event not found!");
                         return events[0].txHash;
@@ -475,8 +475,8 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
             }
         };
         //We have to fetch separately the different directions
-        await this.Events.findInContractEventsForward(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], [signer, null], processor, startBlockheight);
-        await this.Events.findInContractEventsForward(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], [null, signer], processor, startBlockheight);
+        await this._Events.findInContractEventsForward(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], [signer, null], processor, startBlockheight);
+        await this._Events.findInContractEventsForward(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], [null, signer], processor, startBlockheight);
         for (let escrowHash in swapsOpened) {
             const foundSwapData = swapsOpened[escrowHash];
             const data = await foundSwapData.data;

package/dist/starknet/swaps/handlers/claim/btc/IBitcoinClaimHandler.js

@@ -27,7 +27,7 @@ class IBitcoinClaimHandler {
         const commitmentHash = starknet_1.hash.computePoseidonHashOnElements(serializedData);
         if (!swapData.isClaimData(commitmentHash))
             throw new Error("Invalid commit data");
-        const merkleProof = await btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
+        const merkleProof = await btcRelay._bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
         if (merkleProof == null)
             throw new Error(`Failed to generate merkle proof for tx: ${tx.txid}!`);
         logger.debug("getWitness(): merkle proof computed: ", merkleProof);

package/dist/starknet/swaps/modules/StarknetSwapClaim.js

@@ -17,7 +17,7 @@ class StarknetSwapClaim extends StarknetSwapModule_1.StarknetSwapModule {
      * @private
      */
     Claim(signer, swapData, witness, claimHandlerGas) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.claim(swapData.toEscrowStruct(), witness), (0, StarknetFees_1.starknetGasAdd)(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas));
+        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.claim(swapData.toEscrowStruct(), witness), StarknetFees_1.StarknetFees.starknetGasAdd(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas));
     }
     /**
      * Creates transactions claiming the swap using a secret (for HTLC swaps)
@@ -88,7 +88,7 @@ class StarknetSwapClaim extends StarknetSwapModule_1.StarknetSwapModule {
         let gasRequired = swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM;
         const claimHandler = this.contract.claimHandlersByAddress[(0, Utils_1.toHex)(swapData.claimHandler)];
         if (claimHandler != null)
-            gasRequired = (0, StarknetFees_1.starknetGasAdd)(gasRequired, claimHandler.getGas(swapData));
+            gasRequired = StarknetFees_1.StarknetFees.starknetGasAdd(gasRequired, claimHandler.getGas(swapData));
         return StarknetFees_1.StarknetFees.getGasFee(gasRequired, feeRate);
     }
 }

package/dist/starknet/swaps/modules/StarknetSwapRefund.js

@@ -21,7 +21,7 @@ class StarknetSwapRefund extends StarknetSwapModule_1.StarknetSwapModule {
      * @private
      */
     Refund(signer, swapData, witness, handlerGas) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness), (0, StarknetFees_1.starknetGasAdd)(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas));
+        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness), StarknetFees_1.StarknetFees.starknetGasAdd(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas));
     }
     /**
      * Action for cooperative refunding with signature