@atomiqlabs/chain-starknet 8.1.11 → 8.2.2

package/src/starknet/chain/modules/StarknetFees.ts

@@ -25,31 +25,6 @@ export type StarknetGas = {
     l1DataGas: number
 };
 
-/**
- * Multiplies all the gas parameters by a specific scalar
- *
- * @param gas
- * @param scalar
- *
- * @category Chain Interface
- */
-export function starknetGasMul(gas: StarknetGas, scalar: number): StarknetGas {
-    return {l1Gas: gas.l1Gas * scalar, l2Gas: gas.l2Gas * scalar, l1DataGas: gas.l1DataGas * scalar};
-}
-
-/**
- * Sums up all the gas parameters
- *
- * @param a
- * @param b
- *
- * @category Chain Interface
- */
-export function starknetGasAdd(a: StarknetGas, b?: StarknetGas): StarknetGas {
-    if(b==null) return a;
-    return {l1Gas: a.l1Gas + b.l1Gas, l2Gas: a.l2Gas + b.l2Gas, l1DataGas: a.l1DataGas + b.l1DataGas};
-}
-
 /**
  * A module for starknet fee estimation
  *
@@ -57,6 +32,27 @@ export function starknetGasAdd(a: StarknetGas, b?: StarknetGas): StarknetGas {
  */
 export class StarknetFees {
 
+    /**
+     * Multiplies all the gas parameters by a specific scalar
+     *
+     * @param gas
+     * @param scalar
+     */
+    public static starknetGasMul(gas: StarknetGas, scalar: number): StarknetGas {
+        return {l1Gas: gas.l1Gas * scalar, l2Gas: gas.l2Gas * scalar, l1DataGas: gas.l1DataGas * scalar};
+    }
+
+    /**
+     * Sums up all the gas parameters
+     *
+     * @param a
+     * @param b
+     */
+    public static starknetGasAdd(a: StarknetGas, b?: StarknetGas): StarknetGas {
+        if(b==null) return a;
+        return {l1Gas: a.l1Gas + b.l1Gas, l2Gas: a.l2Gas + b.l2Gas, l1DataGas: a.l1DataGas + b.l1DataGas};
+    }
+
     private readonly logger = getLogger("StarknetFees: ");
 
     private readonly feeDA: "L1" | "L2";
@@ -74,7 +70,7 @@ export 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
      */
@@ -82,7 +78,7 @@ export class StarknetFees {
         provider: Provider,
         maxFeeRate: StarknetFeeRate = {l1GasCost: 20_000_000_000_000_000n, l2GasCost: 4_000_000_000_000_000n, l1DataGasCost: 10_000_000_000_000_000n},
         feeMultiplier: number = 1.25,
-        da?: {fee?: "L1" | "L2", nonce?: "L1" | "L2"}
+        da: {fee?: "L1" | "L2", nonce?: "L1" | "L2"} = {fee: "L1", nonce: "L1"}
     ) {
         this.provider = provider;
         this.maxFeeRate = maxFeeRate;

package/src/starknet/chain/modules/StarknetTransactions.ts

@@ -13,10 +13,11 @@ import {
     CallData,
     Calldata,
     ResourceBounds,
-    ResourceBoundsBN
+    ResourceBoundsBN, RawArgs
 } from "starknet";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
 import {
+    calculateHash,
     deserializeResourceBounds,
     deserializeSignature,
     NoBigInt,
@@ -32,12 +33,22 @@ 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 function isStarknetTxInvoke(obj: any): obj is StarknetTxInvoke {
     return typeof(obj)==="object" &&
         typeof(obj.details)==="object" &&
@@ -47,12 +58,24 @@ export function isStarknetTxInvoke(obj: any): obj is StarknetTxInvoke {
         (obj.signed==null || typeof(obj.signed)==="object");
 }
 
+/**
+ * "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 function isStarknetTxDeployAccount(obj: any): obj is StarknetTxDeployAccount {
     return typeof(obj)==="object" &&
         typeof(obj.details)==="object" &&
@@ -63,16 +86,18 @@ export function isStarknetTxDeployAccount(obj: any): obj is StarknetTxDeployAcco
 }
 
 /**
- * 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
  */
@@ -280,15 +305,19 @@ export class StarknetTransactions extends StarknetModule {
     }
 
     /**
-     * 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 async prepareTransactions(signer: StarknetSigner, txs: (StarknetTx & {addedInPrepare?: boolean})[]): Promise<void> {
-        let nonce: bigint = await this.getNonce(signer.getAddress());
-        const latestPendingNonce = this.latestPendingNonces[toHex(signer.getAddress())];
+    public async prepareTransactions(txs: (StarknetTx & {addedInPrepare?: boolean})[], signer?: StarknetSigner): Promise<void> {
+        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: bigint = await this.getNonce(signerAddress);
+        const latestPendingNonce = this.latestPendingNonces[toHex(signerAddress)];
         if(latestPendingNonce!=null && latestPendingNonce > nonce) {
             this.logger.debug("prepareTransactions(): Using 'pending' nonce from local cache!");
             nonce = latestPendingNonce;
@@ -296,15 +325,25 @@ export class StarknetTransactions extends StarknetModule {
 
         //Add deploy account tx
         if(nonce===0n) {
-            const deployPayload = await signer.getDeployPayload();
-            if(deployPayload!=null) {
-                const tx: (StarknetTx & {addedInPrepare?: boolean}) = await this.root.Accounts.getAccountDeployTransaction(deployPayload);
+            if(signer!=null) {
+                const deployPayload = await signer.getDeployPayload();
+                if(deployPayload!=null) {
+                    const tx: (StarknetTx & {addedInPrepare?: boolean}) = 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: (StarknetTx & {addedInPrepare?: boolean}) = 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;
@@ -313,7 +352,7 @@ export class StarknetTransactions extends StarknetModule {
             for(let i=0;i<txs.length;i++) {
                 const tx = txs[i];
                 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
+                if(nonce==null) 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);
@@ -322,7 +361,7 @@ export class StarknetTransactions extends StarknetModule {
             }
         }
 
-        for(let tx of txs) {
+        if(signer!=null) for(let tx of txs) {
             for(let callback of this.cbksBeforeTxSigned) {
                 await callback(tx);
             }
@@ -365,13 +404,14 @@ export class StarknetTransactions extends StarknetModule {
      */
     public async sendAndConfirm(signer: StarknetSigner, _txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]> {
         const txs: (StarknetTx & {addedInPrepare?: boolean})[] = _txs;
-        await this.prepareTransactions(signer, txs);
+        await this.prepareTransactions(txs, signer);
         const signedTxs: (StarknetTx & {addedInPrepare?: boolean})[] = [];
 
         //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: (StarknetTx & {addedInPrepare?: boolean}) = await signer.signTransaction(tx);
+            calculateHash(signedTx);
             signedTx.addedInPrepare = tx.addedInPrepare;
             signedTxs.push(signedTx);
             this.logger.debug("sendAndConfirm(): transaction signed ("+(i+1)+"/"+txs.length+"): "+signedTx.txId);
@@ -462,8 +502,9 @@ export class StarknetTransactions extends StarknetModule {
         signedTxs: SignedStarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal,
         parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>
     ): Promise<string[]> {
-        signedTxs.forEach(val => {
-            if(val.signed==null) throw new Error("Transactions have to be signed!");
+        signedTxs.forEach(tx => {
+            if(tx.signed==null) throw new Error("Transactions have to be signed!");
+            calculateHash(tx);
         });
 
         this.logger.debug("sendSignedAndConfirm(): sending transactions, count: "+signedTxs.length+

package/src/starknet/contract/StarknetContractBase.ts

@@ -10,9 +10,18 @@ export 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,
@@ -26,8 +35,8 @@ export class StarknetContractBase<T extends Abi> {
             address: contractAddress,
             providerOrAccount: chainInterface.provider
         }).typedv2(contractAbi);
-        this.Events = new StarknetContractEvents(chainInterface, this, contractAbi);
-        this.contractDeploymentHeight = contractDeploymentHeight;
+        this._Events = new StarknetContractEvents(chainInterface, this, contractAbi);
+        this._contractDeploymentHeight = contractDeploymentHeight;
     }
 
 }

package/src/starknet/contract/modules/StarknetContractEvents.ts

@@ -148,7 +148,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
                 if(result!=null) return result;
             }
             return null;
-        }, Math.max(startHeight ?? 0, this.contract.contractDeploymentHeight ?? 0), abortSignal);
+        }, Math.max(startHeight ?? 0, this.contract._contractDeploymentHeight ?? 0), abortSignal);
     }
 
 }

package/src/starknet/events/StarknetChainEvents.ts

@@ -60,6 +60,9 @@ export class StarknetChainEvents extends StarknetChainEventsBrowser {
         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?: boolean): Promise<void> {
         if(noAutomaticPoll) return;
 

package/src/starknet/events/StarknetChainEventsBrowser.ts

@@ -46,7 +46,13 @@ const LOGS_SLIDING_WINDOW = 60;
  * @category Events
  */
 export type StarknetEventListenerState = {
+    /**
+     * Block number of the last processed event
+     */
     lastBlockNumber: number,
+    /**
+     * Transaction hash of the last processed event
+     */
     lastTxHash?: string
 };
 
@@ -64,18 +70,51 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
     } = {};
     private processedEvents: Set<string> = new Set();
 
+    /**
+     * @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 = getLogger("StarknetChainEventsBrowser: ");
 
+    /**
+     * @internal
+     */
     protected escrowContractSubscription?: SubscriptionStarknetEventsEvent;
+    /**
+     * @internal
+     */
     protected spvVaultContractSubscription?: SubscriptionStarknetEventsEvent;
 
+    /**
+     * @internal
+     */
     protected stopped: boolean = true;
+    /**
+     * @internal
+     */
     protected pollIntervalSeconds: number;
 
     private timeout: any;
@@ -424,7 +463,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
             return {lastTxHash, lastBlockNumber};
         }
         // this.logger.debug("checkEvents(EscrowManager): Requesting logs: "+logStartHeight+"...pending");
-        let events = await this.starknetSwapContract.Events.getContractBlockEvents(
+        let events = await this.starknetSwapContract._Events.getContractBlockEvents(
             ["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"],
             [],
             lastBlockNumber,
@@ -454,7 +493,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
         return {lastTxHash, lastBlockNumber};
     }
 
-    protected async checkEventsSpvVaults(currentBlock: {timestamp: number, block_number: number}, lastTxHash?: string, lastBlockNumber?: number): Promise<StarknetEventListenerState> {
+    private async checkEventsSpvVaults(currentBlock: {timestamp: number, block_number: number}, lastTxHash?: string, lastBlockNumber?: number): Promise<StarknetEventListenerState> {
         const currentBlockNumber: number = currentBlock.block_number;
         lastBlockNumber ??= currentBlockNumber;
         if(currentBlockNumber < lastBlockNumber) {
@@ -462,7 +501,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
             return {lastTxHash, lastBlockNumber};
         }
         // this.logger.debug("checkEvents(SpvVaults): Requesting logs: "+logStartHeight+"...pending");
-        let events = await this.starknetSpvVaultContract.Events.getContractBlockEvents(
+        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,
@@ -512,7 +551,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
     /**
      * Sets up event handlers listening for swap events over websocket
      *
-     * @protected
+     * @internal
      */
     protected async setupPoll(
         lastState?: StarknetEventListenerState[],
@@ -532,6 +571,9 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
         await func();
     }
 
+    /**
+     * @internal
+     */
     protected wsStarted: boolean = false;
 
     /**
@@ -544,7 +586,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
             try {
                 subscription = await this.wsChannel!.subscribeEvents({
                     fromAddress: this.starknetSwapContract.contract.address,
-                    keys: this.starknetSwapContract.Events.toFilter(
+                    keys: this.starknetSwapContract._Events.toFilter(
                       ["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"],
                       []
                     ),
@@ -557,7 +599,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
         } while(subscription==null);
 
         subscription.on((event) => {
-            const parsedEvents = this.starknetSwapContract.Events.toStarknetAbiEvents<
+            const parsedEvents = this.starknetSwapContract._Events.toStarknetAbiEvents<
               "escrow_manager::events::Initialize" | "escrow_manager::events::Claim" | "escrow_manager::events::Refund"
             >([event]);
             this.processEvents(parsedEvents, event.block_number).catch(e => {
@@ -579,7 +621,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
             try {
                 subscription = await this.wsChannel!.subscribeEvents({
                     fromAddress: this.starknetSpvVaultContract.contract.address,
-                    keys: this.starknetSpvVaultContract.Events.toFilter(
+                    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"],
                       []
                     ),
@@ -592,7 +634,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
         } while(subscription==null);
 
         subscription.on((event) => {
-            const parsedEvents = this.starknetSpvVaultContract.Events.toStarknetAbiEvents<
+            const parsedEvents = this.starknetSpvVaultContract._Events.toStarknetAbiEvents<
               "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"
             >([event]);
             this.processEvents(parsedEvents, event.block_number).catch(e => {
@@ -605,8 +647,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData,
     }
 
     /**
-     *
-     * @protected
+     * @internal
      */
     protected async setupWebsocket() {
         if(this.wsChannel==null) throw new Error("Tried to setup websocket subscription on a provider without WS");

package/src/starknet/spv_swap/StarknetSpvVaultContract.ts

@@ -290,7 +290,7 @@ export class StarknetSpvVaultContract
      */
     async getAllVaults(owner?: string): Promise<StarknetSpvVaultData[]> {
         const openedVaults = new Set<string>();
-        await this.Events.findInContractEventsForward(
+        await this._Events.findInContractEventsForward(
             ["spv_swap_vault::events::Opened", "spv_swap_vault::events::Closed"],
             owner==null ? null : [null, null, owner],
             (event) => {
@@ -444,7 +444,7 @@ export class StarknetSpvVaultContract
                 }
             });
 
-            await this.Events.findInContractEventsForward(
+            await this._Events.findInContractEventsForward(
                 events,[lows, highs],
                 async (event) => {
                     const txId = bigNumberishToBuffer(event.params.btc_tx_hash, 32).reverse().toString("hex");
@@ -475,7 +475,7 @@ export class StarknetSpvVaultContract
             ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed", "spv_swap_vault::events::Closed"];
         const keys = [toHex(txHashU256.low), toHex(txHashU256.high)];
 
-        await this.Events.findInContractEventsForward(
+        await this._Events.findInContractEventsForward(
             events, keys,
             async (event) => {
                 const eventResult = this.parseWithdrawalEvent(event);
@@ -496,7 +496,7 @@ export class StarknetSpvVaultContract
         const eventTypes: ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"] =
             ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"];
 
-        await this.Events.findInContractEventsForward(
+        await this._Events.findInContractEventsForward(
             eventTypes,
             [null, null, null, null, recipient],
             async (_event) => {

package/src/starknet/swaps/StarknetSwapContract.ts

@@ -390,7 +390,7 @@ export class StarknetSwapContract
                         };
                     },
                     getClaimTxId: async () => {
-                        const events = await this.Events.getContractBlockEvents(
+                        const events = await this._Events.getContractBlockEvents(
                             ["escrow_manager::events::Claim"],
                             [null, null, null, "0x"+escrowHash],
                             blockHeight, blockHeight
@@ -399,7 +399,7 @@ export class StarknetSwapContract
                         return events[0].txHash;
                     },
                     getClaimResult: async () => {
-                        const events = await this.Events.getContractBlockEvents(
+                        const events = await this._Events.getContractBlockEvents(
                             ["escrow_manager::events::Claim"],
                             [null, null, null, "0x"+escrowHash],
                             blockHeight, blockHeight
@@ -424,7 +424,7 @@ export class StarknetSwapContract
                         };
                     },
                     getRefundTxId: async () => {
-                        const events = await this.Events.getContractBlockEvents(
+                        const events = await this._Events.getContractBlockEvents(
                           ["escrow_manager::events::Refund"],
                           [null, null, null, "0x"+escrowHash],
                           blockHeight, blockHeight
@@ -604,13 +604,13 @@ export class StarknetSwapContract
         };
 
         //We have to fetch separately the different directions
-        await this.Events.findInContractEventsForward(
+        await this._Events.findInContractEventsForward(
             ["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"],
             [signer, null],
             processor,
             startBlockheight
         );
-        await this.Events.findInContractEventsForward(
+        await this._Events.findInContractEventsForward(
             ["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"],
             [null, signer],
             processor,

package/src/starknet/swaps/handlers/claim/btc/IBitcoinClaimHandler.ts

@@ -61,7 +61,7 @@ export abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> impl
 
         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/src/starknet/swaps/modules/StarknetSwapClaim.ts

@@ -6,7 +6,7 @@ import {StarknetAction} from "../../chain/StarknetAction";
 import {BigNumberish} from "starknet";
 import {IClaimHandler} from "../handlers/claim/ClaimHandlers";
 import {StarknetTx} from "../../chain/modules/StarknetTransactions";
-import {StarknetFees, StarknetGas, starknetGasAdd} from "../../chain/modules/StarknetFees";
+import {StarknetFees, StarknetGas} from "../../chain/modules/StarknetFees";
 import {StarknetBtcStoredHeader} from "../../btcrelay/headers/StarknetBtcStoredHeader";
 import {BitcoinOutputWitnessData} from "../handlers/claim/btc/BitcoinOutputClaimHandler";
 import {BitcoinWitnessData} from "../handlers/claim/btc/IBitcoinClaimHandler";
@@ -36,7 +36,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
     ): StarknetAction {
         return new StarknetAction(signer, this.root,
             this.swapContract.populateTransaction.claim(swapData.toEscrowStruct(), witness),
-            starknetGasAdd(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas)
+            StarknetFees.starknetGasAdd(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas)
         );
     }
 
@@ -133,7 +133,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
         let gasRequired = swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM;
 
         const claimHandler: IClaimHandler<any, any> = this.contract.claimHandlersByAddress[toHex(swapData.claimHandler)];
-        if(claimHandler!=null) gasRequired = starknetGasAdd(gasRequired, claimHandler.getGas(swapData));
+        if(claimHandler!=null) gasRequired = StarknetFees.starknetGasAdd(gasRequired, claimHandler.getGas(swapData));
 
         return StarknetFees.getGasFee(gasRequired, feeRate);
     }

package/src/starknet/swaps/modules/StarknetSwapRefund.ts

@@ -7,7 +7,7 @@ import {IHandler} from "../handlers/IHandler";
 import {BigNumberish} from "starknet";
 import {StarknetTx} from "../../chain/modules/StarknetTransactions";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
-import {StarknetFees, StarknetGas, starknetGasAdd} from "../../chain/modules/StarknetFees";
+import {StarknetFees, StarknetGas} from "../../chain/modules/StarknetFees";
 
 const Refund = [
     { name: 'Swap hash', type: 'felt' },
@@ -38,7 +38,7 @@ export class StarknetSwapRefund extends StarknetSwapModule {
     ): StarknetAction {
         return new StarknetAction(signer, this.root,
             this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness),
-            starknetGasAdd(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas)
+            StarknetFees.starknetGasAdd(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas)
         );
     }
 

package/src/starknet/wallet/StarknetBrowserSigner.ts

@@ -1,5 +1,6 @@
 import {StarknetSigner} from "./StarknetSigner";
-import {Account} from "starknet";
+import {Account, shortString} from "starknet";
+import {bigNumberishToBuffer, serializeSignature} from "../../utils/Utils";
 
 /**
  * Browser-based Starknet signer, use with browser based signer accounts, this ensures that
@@ -9,9 +10,45 @@ import {Account} from "starknet";
  */
 export class StarknetBrowserSigner extends StarknetSigner {
 
-    constructor(account: Account) {
+    private usesECDSADN?: boolean;
+
+    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) {
         super(account, false);
+        this.usesECDSADN = usesECDSADN;
         this.signTransaction = undefined;
+        if(this.usesECDSADN!==false) {
+            this.getReproducibleEntropy = async (appName: string) => {
+                if(this.usesECDSADN===false) throw new Error("This wallet doesn't support generating recoverable entropy!");
+
+                const typedData = StarknetSigner.getReproducibleEntropyMessage(await account.getChainId(), appName);
+
+                const signature = await account.signMessage(typedData);
+                const serializedSignature = serializeSignature(signature)!;
+                if(this.usesECDSADN!==true) {
+                    const secondSignature = 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) => bigNumberishToBuffer(value, 32)));
+            }
+        }
     }
 
 }