@atomiqlabs/chain-evm 2.0.7 → 2.0.8

package/dist/evm/swaps/EVMSwapData.js

@@ -106,22 +106,37 @@ class EVMSwapData extends base_1.SwapData {
             this.successActionCommitment = offererOrData.successActionCommitment ?? ethers_1.ZeroHash;
         }
     }
+    /**
+     * @inheritDoc
+     */
     getOfferer() {
         return this.offerer;
     }
+    /**
+     * @inheritDoc
+     */
     setOfferer(newOfferer) {
         this.offerer = newOfferer;
         this.payIn = true;
     }
+    /**
+     * @inheritDoc
+     */
     getClaimer() {
         return this.claimer;
     }
+    /**
+     * @inheritDoc
+     */
     setClaimer(newClaimer) {
         this.claimer = newClaimer;
         this.payIn = false;
         this.payOut = true;
         this.reputation = false;
     }
+    /**
+     * @inheritDoc
+     */
     serialize() {
         return {
             type: "evm",
@@ -145,30 +160,57 @@ class EVMSwapData extends base_1.SwapData {
             successActionCommitment: this.successActionCommitment
         };
     }
+    /**
+     * @inheritDoc
+     */
     getAmount() {
         return this.amount;
     }
+    /**
+     * @inheritDoc
+     */
     getToken() {
         return this.token;
     }
+    /**
+     * @inheritDoc
+     */
     isToken(token) {
         return this.token.toLowerCase() === token.toLowerCase();
     }
+    /**
+     * @inheritDoc
+     */
     getType() {
         return this.kind;
     }
+    /**
+     * @inheritDoc
+     */
     getExpiry() {
         return TimelockRefundHandler_1.TimelockRefundHandler.getExpiry(this);
     }
+    /**
+     * @inheritDoc
+     */
     isPayIn() {
         return this.payIn;
     }
+    /**
+     * @inheritDoc
+     */
     isPayOut() {
         return this.payOut;
     }
+    /**
+     * @inheritDoc
+     */
     isTrackingReputation() {
         return this.reputation;
     }
+    /**
+     * @inheritDoc
+     */
     getEscrowHash() {
         const encoded = ethers_1.AbiCoder.defaultAbiCoder().encode(["address", "address", "uint256", "address", "uint256", "address", "bytes32", "address", "bytes32", "uint256", "uint256", "address", "bytes32"], [
             this.offerer, this.claimer, this.amount, this.token, this.getFlags(),
@@ -178,15 +220,24 @@ class EVMSwapData extends base_1.SwapData {
         let escrowHash = (0, ethers_1.keccak256)(encoded);
         return escrowHash.slice(2); //Strip `0x`
     }
+    /**
+     * @inheritDoc
+     */
     getClaimHash() {
         let hash = this.claimData;
         if (hash.startsWith("0x"))
             hash = hash.slice(2);
         return hash;
     }
+    /**
+     * @inheritDoc
+     */
     getSequence() {
         return this.sequence;
     }
+    /**
+     * @inheritDoc
+     */
     getConfirmationsHint() {
         if (this.extraData == null)
             return null;
@@ -194,6 +245,9 @@ class EVMSwapData extends base_1.SwapData {
             return null;
         return parseInt(this.extraData.slice(80), 16);
     }
+    /**
+     * @inheritDoc
+     */
     getNonceHint() {
         if (this.extraData == null)
             return null;
@@ -201,6 +255,9 @@ class EVMSwapData extends base_1.SwapData {
             return null;
         return BigInt("0x" + this.extraData.slice(64, 80));
     }
+    /**
+     * @inheritDoc
+     */
     getTxoHashHint() {
         if (this.extraData == null)
             return null;
@@ -208,34 +265,61 @@ class EVMSwapData extends base_1.SwapData {
             return null;
         return this.extraData.slice(0, 64);
     }
+    /**
+     * @inheritDoc
+     */
     getExtraData() {
         return this.extraData ?? null;
     }
+    /**
+     * @inheritDoc
+     */
     setExtraData(extraData) {
         this.extraData = extraData;
     }
+    /**
+     * @inheritDoc
+     */
     getSecurityDeposit() {
         return this.securityDeposit;
     }
+    /**
+     * @inheritDoc
+     */
     getClaimerBounty() {
         return this.claimerBounty;
     }
+    /**
+     * @inheritDoc
+     */
     getTotalDeposit() {
         return this.claimerBounty < this.securityDeposit ? this.securityDeposit : this.claimerBounty;
     }
+    /**
+     * @inheritDoc
+     */
     getDepositToken() {
         return this.depositToken;
     }
+    /**
+     * @inheritDoc
+     */
     isDepositToken(token) {
         if (!token.startsWith("0x"))
             token = "0x" + token;
         return this.depositToken.toLowerCase() === token.toLowerCase();
     }
+    /**
+     * @inheritDoc
+     */
     isClaimer(address) {
         if (!address.startsWith("0x"))
             address = "0x" + address;
         return this.claimer.toLowerCase() === address.toLowerCase();
     }
+    /**
+     * @inheritDoc
+     */
     isOfferer(address) {
         if (!address.startsWith("0x"))
             address = "0x" + address;
@@ -256,6 +340,9 @@ class EVMSwapData extends base_1.SwapData {
             data = "0x" + data;
         return (this.claimData.startsWith("0x") ? this.claimData : "0x" + this.claimData) === data;
     }
+    /**
+     * @inheritDoc
+     */
     equals(other) {
         return other.offerer.toLowerCase() === this.offerer.toLowerCase() &&
             other.claimer.toLowerCase() === this.claimer.toLowerCase() &&
@@ -290,6 +377,9 @@ class EVMSwapData extends base_1.SwapData {
             successActionCommitment: this.successActionCommitment
         };
     }
+    /**
+     * @inheritDoc
+     */
     hasSuccessAction() {
         return this.successActionCommitment !== ethers_1.ZeroHash;
     }

package/dist/evm/wallet/EVMSigner.d.ts

@@ -10,6 +10,9 @@ export declare class EVMSigner implements AbstractSigner {
     readonly address: string;
     readonly isManagingNoncesInternally: boolean;
     constructor(account: Signer, address: string, isManagingNoncesInternally?: boolean);
+    /**
+     * @inheritDoc
+     */
     getAddress(): string;
     signTransaction?(transaction: TransactionRequest): Promise<string>;
     sendTransaction(transaction: TransactionRequest, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<TransactionResponse>;

package/dist/evm/wallet/EVMSigner.js

@@ -13,6 +13,9 @@ class EVMSigner {
         this.address = address;
         this.isManagingNoncesInternally = isManagingNoncesInternally;
     }
+    /**
+     * @inheritDoc
+     */
     getAddress() {
         return (0, ethers_1.getAddress)(this.address);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "description": "EVM specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/evm/btcrelay/EVMBtcRelay.ts

@@ -226,7 +226,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Returns data about current main chain tip stored in the btc relay
+     * @inheritDoc
      */
     public async getTipData(): Promise<{ commitHash: string; blockhash: string, chainWork: Buffer, blockheight: number } | null> {
         const commitHash = await this.contract.getTipCommitHash();
@@ -246,11 +246,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Retrieves blockheader with a specific blockhash, returns null if requiredBlockheight is provided and
-     *  btc relay contract is not synced up to the desired blockheight
-     *
-     * @param blockData
-     * @param requiredBlockheight
+     * @inheritDoc
      */
     public async retrieveLogAndBlockheight(blockData: {blockhash: string}, requiredBlockheight?: number): Promise<{
         header: EVMBtcStoredHeader,
@@ -277,10 +273,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Retrieves blockheader data by blockheader's commit hash,
-     *
-     * @param commitmentHashStr
-     * @param blockData
+     * @inheritDoc
      */
     public async retrieveLogByCommitHash(commitmentHashStr: string, blockData: {blockhash: string}): Promise<EVMBtcStoredHeader | null> {
         const result = await this.getBlock(commitmentHashStr, Buffer.from(blockData.blockhash, "hex"));
@@ -299,7 +292,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Retrieves latest known stored blockheader & blockheader from bitcoin RPC that is in the main chain
+     * @inheritDoc
      */
     public async retrieveLatestKnownBlockLog(): Promise<{
         resultStoredHeader: EVMBtcStoredHeader,
@@ -340,12 +333,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Saves blockheaders as a bitcoin main chain to the btc relay
-     *
-     * @param signer
-     * @param mainHeaders
-     * @param storedHeader
-     * @param feeRate
+     * @inheritDoc
      */
     public async saveMainHeaders(signer: string, mainHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, feeRate?: string) {
         feeRate ??= await this.Chain.Fees.getFeeRate();
@@ -354,13 +342,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Creates a new long fork and submits the headers to it
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     public async saveNewForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, tipWork: Buffer, feeRate?: string) {
         let forkId: number = Math.floor(Math.random() * 0xFFFFFFFFFFFF);
@@ -378,14 +360,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Continues submitting blockheaders to a given fork
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param forkId
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     public async saveForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, forkId: number, tipWork: Buffer, feeRate?: string) {
         feeRate ??= await this.Chain.Fees.getFeeRate();
@@ -402,13 +377,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Submits short fork with given blockheaders
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     public async saveShortForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, tipWork: Buffer, feeRate?: string) {
         feeRate ??= await this.Chain.Fees.getFeeRate();
@@ -425,10 +394,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Estimate required synchronization fee (worst case) to synchronize btc relay to the required blockheight
-     *
-     * @param requiredBlockheight
-     * @param feeRate
+     * @inheritDoc
      */
     public async estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.Chain.Fees.getFeeRate();
@@ -450,9 +416,7 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Returns fee required (in native token) to synchronize a single block to btc relay
-     *
-     * @param feeRate
+     * @inheritDoc
      */
     public async getFeePerBlock(feeRate?: string): Promise<bigint> {
         feeRate ??= await this.Chain.Fees.getFeeRate();
@@ -460,19 +424,22 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * Gets fee rate required for submitting blockheaders to the main chain
+     * @inheritDoc
      */
     public getMainFeeRate(signer: string | null): Promise<string> {
         return this.Chain.Fees.getFeeRate();
     }
 
     /**
-     * Gets fee rate required for submitting blockheaders to the specific fork
+     * @inheritDoc
      */
     public getForkFeeRate(signer: string, forkId: number): Promise<string> {
         return this.Chain.Fees.getFeeRate();
     }
 
+    /**
+     * @inheritDoc
+     */
     saveInitialHeader(signer: string, header: B, epochStart: number, pastBlocksTimestamps: number[], feeRate?: string): Promise<EVMTx> {
         throw new Error("Not supported, EVM contract is initialized with constructor!");
     }

package/src/evm/chain/EVMChainInterface.ts

@@ -104,46 +104,79 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
     }
 
 
+    /**
+     * @inheritDoc
+     */
     async getBalance(signer: string, tokenAddress: string): Promise<bigint> {
         //TODO: For native token we should discount the cost of transactions
         return await this.Tokens.getTokenBalance(signer, tokenAddress);
     }
 
+    /**
+     * @inheritDoc
+     */
     getNativeCurrencyAddress(): string {
         return this.Tokens.getNativeCurrencyAddress();
     }
 
+    /**
+     * @inheritDoc
+     */
     isValidToken(tokenIdentifier: string): boolean {
         return this.Tokens.isValidToken(tokenIdentifier);
     }
 
+    /**
+     * @inheritDoc
+     */
     isValidAddress(address: string): boolean {
         return EVMAddresses.isValidAddress(address);
     }
 
+    /**
+     * @inheritDoc
+     */
     normalizeAddress(address: string): string {
         return getAddress(address);
     }
 
     ///////////////////////////////////
     //// Callbacks & handlers
+    /**
+     * @inheritDoc
+     */
     offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean {
         return true;
     }
+    /**
+     * @inheritDoc
+     */
     onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void {}
 
+    /**
+     * @inheritDoc
+     */
     onBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): void {
         this.Transactions.onBeforeTxSigned(callback);
     }
 
+    /**
+     * @inheritDoc
+     */
     offBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): boolean {
         return this.Transactions.offBeforeTxSigned(callback);
     }
 
+    /**
+     * @inheritDoc
+     */
     randomAddress(): string {
         return EVMAddresses.randomAddress();
     }
 
+    /**
+     * @inheritDoc
+     */
     randomSigner(): EVMSigner {
         const wallet = Wallet.createRandom();
         return new EVMSigner(wallet, wallet.address);
@@ -151,6 +184,9 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
 
     ////////////////////////////////////////////
     //// Transactions
+    /**
+     * @inheritDoc
+     */
     sendAndConfirm(
         signer: EVMSigner,
         txs: TransactionRequest[],
@@ -163,6 +199,9 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
         return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish, useAccessLists);
     }
 
+    /**
+     * @inheritDoc
+     */
     sendSignedAndConfirm(
         signedTxs: Transaction[],
         waitForConfirmation?: boolean,
@@ -173,30 +212,51 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
         return this.Transactions.sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
     }
 
+    /**
+     * @inheritDoc
+     */
     serializeTx(tx: TransactionRequest): Promise<string> {
         return this.Transactions.serializeUnsignedTx(tx);
     }
 
+    /**
+     * @inheritDoc
+     */
     deserializeTx(txData: string): Promise<TransactionRequest> {
         return Promise.resolve(this.Transactions.deserializeUnsignedTx(txData));
     }
 
+    /**
+     * @inheritDoc
+     */
     serializeSignedTx(tx: Transaction): Promise<string> {
         return Promise.resolve(this.Transactions.serializeSignedTx(tx));
     }
 
+    /**
+     * @inheritDoc
+     */
     deserializeSignedTx(txData: string): Promise<Transaction> {
         return Promise.resolve(this.Transactions.deserializeSignedTx(txData));
     }
 
+    /**
+     * @inheritDoc
+     */
     getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
         return this.Transactions.getTxIdStatus(txId);
     }
 
+    /**
+     * @inheritDoc
+     */
     getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
         return this.Transactions.getTxStatus(tx);
     }
 
+    /**
+     * @inheritDoc
+     */
     async getFinalizedBlock(): Promise<{ height: number; blockHash: string }> {
         const block = await this.Blocks.getBlock(this.config.finalizedBlockTag);
         return {
@@ -205,10 +265,16 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
         };
     }
 
+    /**
+     * @inheritDoc
+     */
     async txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<TransactionRequest[]> {
         return [await this.Tokens.Transfer(signer, token, amount, dstAddress, feeRate)];
     }
 
+    /**
+     * @inheritDoc
+     */
     async transfer(
         signer: EVMSigner,
         token: string,
@@ -221,6 +287,9 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
         return txId;
     }
 
+    /**
+     * @inheritDoc
+     */
     async wrapSigner(signer: Signer): Promise<EVMSigner> {
         const address = await signer.getAddress();
         if(signer instanceof JsonRpcSigner || signer.provider instanceof BrowserProvider) {

package/src/evm/chain/modules/EVMTransactions.ts

@@ -253,7 +253,11 @@ export class EVMTransactions extends EVMModule<any> {
             for(let i=0;i<txs.length;i++) {
                 let tx: TransactionResponse | Transaction;
                 if(signer.signTransaction==null) {
-                    tx = await signer.sendTransaction(txs[i], onBeforePublish);
+                    tx = await signer.sendTransaction(txs[i], onBeforePublish)
+                        .catch(e => {
+                            if(e?.message?.includes("User rejected")) e.message = "User refused to sign the transaction";
+                            throw e;
+                        });
                 } else {
                     const signedTx = signedTxs[i];
                     await this.sendSignedTransaction(signedTx, onBeforePublish);
@@ -281,7 +285,11 @@ export class EVMTransactions extends EVMModule<any> {
             for(let i=0;i<txs.length;i++) {
                 let tx: TransactionResponse | Transaction;
                 if(signer.signTransaction==null) {
-                    tx = await signer.sendTransaction(txs[i], onBeforePublish);
+                    tx = await signer.sendTransaction(txs[i], onBeforePublish)
+                      .catch(e => {
+                          if(e?.message?.includes("User rejected")) e.message = "User refused to sign the transaction";
+                          throw e;
+                      });
                 } else {
                     const signedTx = signedTxs[i];
                     await this.sendSignedTransaction(signedTx, onBeforePublish);

package/src/evm/events/EVMChainEventsBrowser.ts

@@ -409,6 +409,9 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, EVMEventL
         return {lastEvent, lastBlockNumber};
     }
 
+    /**
+     * @inheritDoc
+     */
     async poll(lastState?: EVMEventListenerState[]): Promise<EVMEventListenerState[]> {
         lastState ??= [];
 
@@ -560,6 +563,9 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, EVMEventL
         });
     }
 
+    /**
+     * @inheritDoc
+     */
     async init(noAutomaticPoll?: boolean): Promise<void> {
         if(noAutomaticPoll) return Promise.resolve();
         if((this.provider as any).websocket!=null) {
@@ -571,6 +577,9 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, EVMEventL
         return Promise.resolve();
     }
 
+    /**
+     * @inheritDoc
+     */
     async stop(): Promise<void> {
         this.stopped = true;
         if(this.timeout!=null) clearTimeout(this.timeout);
@@ -583,10 +592,16 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, EVMEventL
         }
     }
 
+    /**
+     * @inheritDoc
+     */
     registerListener(cbk: EventListener<EVMSwapData>): void {
         this.listeners.push(cbk);
     }
 
+    /**
+     * @inheritDoc
+     */
     unregisterListener(cbk: EventListener<EVMSwapData>): boolean {
         const index = this.listeners.indexOf(cbk);
         if(index>=0) {