@atomiqlabs/chain-evm 1.0.0-dev.75 → 1.0.0-dev.77

package/dist/evm/swaps/modules/EVMSwapRefund.d.ts

@@ -1,62 +1,62 @@
-import { EVMSwapModule } from "../EVMSwapModule";
-import { EVMSwapData } from "../EVMSwapData";
-import { EVMSigner } from "../../wallet/EVMSigner";
-import { EVMTx } from "../../chain/modules/EVMTransactions";
-export declare class EVMSwapRefund extends EVMSwapModule {
-    private static readonly GasCosts;
-    /**
-     * Action for generic Refund instruction
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param feeRate
-     * @param handlerGas
-     * @private
-     */
-    private Refund;
-    /**
-     * Action for cooperative refunding with signature
-     *
-     * @param sender
-     * @param swapData
-     * @param timeout
-     * @param signature
-     * @param feeRate
-     * @private
-     */
-    private RefundWithSignature;
-    signSwapRefund(signer: EVMSigner, swapData: EVMSwapData, authorizationTimeout: number): Promise<{
-        prefix: string;
-        timeout: string;
-        signature: string;
-    }>;
-    isSignatureValid(swapData: EVMSwapData, timeout: string, prefix: string, signature: string): Promise<null>;
-    /**
-     * Creates transactions required for refunding timed out swap
-     *
-     * @param signer
-     * @param swapData swap data to refund
-     * @param check whether to check if swap is already expired and refundable
-     * @param feeRate fee rate to be used for the transactions
-     * @param witnessData
-     */
-    txsRefund<T>(signer: string, swapData: EVMSwapData, check?: boolean, feeRate?: string, witnessData?: T): Promise<EVMTx[]>;
-    /**
-     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
-     *
-     * @param signer
-     * @param swapData swap data to refund
-     * @param timeout signature timeout
-     * @param prefix signature prefix of the counterparty
-     * @param signature signature of the counterparty
-     * @param check whether to check if swap is committed before attempting refund
-     * @param feeRate fee rate to be used for the transactions
-     */
-    txsRefundWithAuthorization(signer: string, swapData: EVMSwapData, timeout: string, prefix: string, signature: string, check?: boolean, feeRate?: string): Promise<EVMTx[]>;
-    getRefundGas(swapData: EVMSwapData): number;
-    /**
-     * Get the estimated transaction fee of the refund transaction
-     */
-    getRefundFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
-}
+import { EVMSwapModule } from "../EVMSwapModule";
+import { EVMSwapData } from "../EVMSwapData";
+import { EVMSigner } from "../../wallet/EVMSigner";
+import { EVMTx } from "../../chain/modules/EVMTransactions";
+export declare class EVMSwapRefund extends EVMSwapModule {
+    private static readonly GasCosts;
+    /**
+     * Action for generic Refund instruction
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param feeRate
+     * @param handlerGas
+     * @private
+     */
+    private Refund;
+    /**
+     * Action for cooperative refunding with signature
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @param feeRate
+     * @private
+     */
+    private RefundWithSignature;
+    signSwapRefund(signer: EVMSigner, swapData: EVMSwapData, authorizationTimeout: number): Promise<{
+        prefix: string;
+        timeout: string;
+        signature: string;
+    }>;
+    isSignatureValid(swapData: EVMSwapData, timeout: string, prefix: string, signature: string): Promise<null>;
+    /**
+     * Creates transactions required for refunding timed out swap
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param check whether to check if swap is already expired and refundable
+     * @param feeRate fee rate to be used for the transactions
+     * @param witnessData
+     */
+    txsRefund<T>(signer: string, swapData: EVMSwapData, check?: boolean, feeRate?: string, witnessData?: T): Promise<EVMTx[]>;
+    /**
+     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param timeout signature timeout
+     * @param prefix signature prefix of the counterparty
+     * @param signature signature of the counterparty
+     * @param check whether to check if swap is committed before attempting refund
+     * @param feeRate fee rate to be used for the transactions
+     */
+    txsRefundWithAuthorization(signer: string, swapData: EVMSwapData, timeout: string, prefix: string, signature: string, check?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    getRefundGas(swapData: EVMSwapData): number;
+    /**
+     * Get the estimated transaction fee of the refund transaction
+     */
+    getRefundFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+}

package/dist/evm/swaps/modules/EVMSwapRefund.js

@@ -1,167 +1,167 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMSwapRefund = void 0;
-const base_1 = require("@atomiqlabs/base");
-const Utils_1 = require("../../../utils/Utils");
-const EVMSwapModule_1 = require("../EVMSwapModule");
-const EVMFees_1 = require("../../chain/modules/EVMFees");
-const Refund = [
-    { name: "swapHash", type: "bytes32" },
-    { name: "timeout", type: "uint256" }
-];
-class EVMSwapRefund extends EVMSwapModule_1.EVMSwapModule {
-    /**
-     * Action for generic Refund instruction
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param feeRate
-     * @param handlerGas
-     * @private
-     */
-    async Refund(signer, swapData, witness, feeRate, handlerGas) {
-        const tx = await this.swapContract.refund.populateTransaction(swapData.toEscrowStruct(), witness);
-        tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, this.getRefundGas(swapData) + (handlerGas ?? 0), feeRate);
-        return tx;
-    }
-    /**
-     * Action for cooperative refunding with signature
-     *
-     * @param sender
-     * @param swapData
-     * @param timeout
-     * @param signature
-     * @param feeRate
-     * @private
-     */
-    async RefundWithSignature(sender, swapData, timeout, signature, feeRate) {
-        const tx = await this.swapContract.cooperativeRefund.populateTransaction(swapData.toEscrowStruct(), signature, BigInt(timeout));
-        tx.from = sender;
-        EVMFees_1.EVMFees.applyFeeRate(tx, this.getRefundGas(swapData), feeRate);
-        return tx;
-    }
-    async signSwapRefund(signer, swapData, authorizationTimeout) {
-        const authPrefix = "refund";
-        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
-        const signature = await this.root.Signatures.signTypedMessage(this.contract.contractAddress, signer, Refund, "Refund", {
-            "swapHash": "0x" + swapData.getEscrowHash(),
-            "timeout": BigInt(authTimeout)
-        });
-        return {
-            prefix: authPrefix,
-            timeout: authTimeout.toString(10),
-            signature: signature
-        };
-    }
-    async isSignatureValid(swapData, timeout, prefix, signature) {
-        if (prefix !== "refund")
-            throw new base_1.SignatureVerificationError("Invalid prefix");
-        const expiryTimestamp = BigInt(timeout);
-        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
-        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.contract.authGracePeriod);
-        if (isExpired)
-            throw new base_1.SignatureVerificationError("Authorization expired!");
-        const valid = await this.root.Signatures.isValidSignature(this.contract.contractAddress, signature, swapData.claimer, Refund, "Refund", {
-            "swapHash": "0x" + swapData.getEscrowHash(),
-            "timeout": BigInt(expiryTimestamp)
-        });
-        if (!valid) {
-            throw new base_1.SignatureVerificationError("Invalid signature!");
-        }
-        return null;
-    }
-    /**
-     * Creates transactions required for refunding timed out swap
-     *
-     * @param signer
-     * @param swapData swap data to refund
-     * @param check whether to check if swap is already expired and refundable
-     * @param feeRate fee rate to be used for the transactions
-     * @param witnessData
-     */
-    async txsRefund(signer, swapData, check, feeRate, witnessData) {
-        const refundHandler = this.contract.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
-        if (refundHandler == null)
-            throw new Error("Invalid refund handler");
-        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
-            throw new base_1.SwapDataVerificationError("Not refundable yet!");
-        }
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        const { initialTxns, witness } = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
-        const tx = await this.Refund(signer, swapData, witness, feeRate, refundHandler.getGas(swapData));
-        this.logger.debug("txsRefund(): creating refund transaction, swap: " + swapData.getClaimHash());
-        return [...initialTxns, tx];
-    }
-    /**
-     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
-     *
-     * @param signer
-     * @param swapData swap data to refund
-     * @param timeout signature timeout
-     * @param prefix signature prefix of the counterparty
-     * @param signature signature of the counterparty
-     * @param check whether to check if swap is committed before attempting refund
-     * @param feeRate fee rate to be used for the transactions
-     */
-    async txsRefundWithAuthorization(signer, swapData, timeout, prefix, signature, check, feeRate) {
-        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isCommited(swapData), this.retryPolicy)) {
-            throw new base_1.SwapDataVerificationError("Not correctly committed");
-        }
-        await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        const tx = await this.RefundWithSignature(signer, swapData, timeout, signature, feeRate);
-        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: " + swapData.getClaimHash() +
-            " auth expiry: " + timeout + " signature: " + signature);
-        return [tx];
-    }
-    getRefundGas(swapData) {
-        let totalGas = EVMSwapRefund.GasCosts.BASE;
-        if (swapData.reputation)
-            totalGas += EVMSwapRefund.GasCosts.REPUTATION;
-        if (swapData.isPayIn()) {
-            if (swapData.isToken(this.root.getNativeCurrencyAddress())) {
-                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
-            }
-            else {
-                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
-            }
-        }
-        else {
-            totalGas += EVMSwapRefund.GasCosts.LP_VAULT_TRANSFER;
-        }
-        if (swapData.getSecurityDeposit() > 0n) {
-            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
-                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
-            }
-            else {
-                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
-            }
-        }
-        if (swapData.getClaimerBounty() > swapData.getSecurityDeposit()) {
-            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
-                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
-            }
-            else {
-                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
-            }
-        }
-        return totalGas;
-    }
-    /**
-     * Get the estimated transaction fee of the refund transaction
-     */
-    async getRefundFee(swapData, feeRate) {
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        return EVMFees_1.EVMFees.getGasFee(this.getRefundGas(swapData), feeRate);
-    }
-}
-exports.EVMSwapRefund = EVMSwapRefund;
-EVMSwapRefund.GasCosts = {
-    BASE: 35000 + 21000,
-    ERC20_TRANSFER: 40000,
-    NATIVE_TRANSFER: 35500,
-    LP_VAULT_TRANSFER: 10000,
-    REPUTATION: 25000
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMSwapRefund = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../../../utils/Utils");
+const EVMSwapModule_1 = require("../EVMSwapModule");
+const EVMFees_1 = require("../../chain/modules/EVMFees");
+const Refund = [
+    { name: "swapHash", type: "bytes32" },
+    { name: "timeout", type: "uint256" }
+];
+class EVMSwapRefund extends EVMSwapModule_1.EVMSwapModule {
+    /**
+     * Action for generic Refund instruction
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param feeRate
+     * @param handlerGas
+     * @private
+     */
+    async Refund(signer, swapData, witness, feeRate, handlerGas) {
+        const tx = await this.swapContract.refund.populateTransaction(swapData.toEscrowStruct(), witness);
+        tx.from = signer;
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getRefundGas(swapData) + (handlerGas ?? 0), feeRate);
+        return tx;
+    }
+    /**
+     * Action for cooperative refunding with signature
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @param feeRate
+     * @private
+     */
+    async RefundWithSignature(sender, swapData, timeout, signature, feeRate) {
+        const tx = await this.swapContract.cooperativeRefund.populateTransaction(swapData.toEscrowStruct(), signature, BigInt(timeout));
+        tx.from = sender;
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getRefundGas(swapData), feeRate);
+        return tx;
+    }
+    async signSwapRefund(signer, swapData, authorizationTimeout) {
+        const authPrefix = "refund";
+        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
+        const signature = await this.root.Signatures.signTypedMessage(this.contract.contractAddress, signer, Refund, "Refund", {
+            "swapHash": "0x" + swapData.getEscrowHash(),
+            "timeout": BigInt(authTimeout)
+        });
+        return {
+            prefix: authPrefix,
+            timeout: authTimeout.toString(10),
+            signature: signature
+        };
+    }
+    async isSignatureValid(swapData, timeout, prefix, signature) {
+        if (prefix !== "refund")
+            throw new base_1.SignatureVerificationError("Invalid prefix");
+        const expiryTimestamp = BigInt(timeout);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.contract.authGracePeriod);
+        if (isExpired)
+            throw new base_1.SignatureVerificationError("Authorization expired!");
+        const valid = await this.root.Signatures.isValidSignature(this.contract.contractAddress, signature, swapData.claimer, Refund, "Refund", {
+            "swapHash": "0x" + swapData.getEscrowHash(),
+            "timeout": BigInt(expiryTimestamp)
+        });
+        if (!valid) {
+            throw new base_1.SignatureVerificationError("Invalid signature!");
+        }
+        return null;
+    }
+    /**
+     * Creates transactions required for refunding timed out swap
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param check whether to check if swap is already expired and refundable
+     * @param feeRate fee rate to be used for the transactions
+     * @param witnessData
+     */
+    async txsRefund(signer, swapData, check, feeRate, witnessData) {
+        const refundHandler = this.contract.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
+        if (refundHandler == null)
+            throw new Error("Invalid refund handler");
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not refundable yet!");
+        }
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const { initialTxns, witness } = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
+        const tx = await this.Refund(signer, swapData, witness, feeRate, refundHandler.getGas(swapData));
+        this.logger.debug("txsRefund(): creating refund transaction, swap: " + swapData.getClaimHash());
+        return [...initialTxns, tx];
+    }
+    /**
+     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param timeout signature timeout
+     * @param prefix signature prefix of the counterparty
+     * @param signature signature of the counterparty
+     * @param check whether to check if swap is committed before attempting refund
+     * @param feeRate fee rate to be used for the transactions
+     */
+    async txsRefundWithAuthorization(signer, swapData, timeout, prefix, signature, check, feeRate) {
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isCommited(swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not correctly committed");
+        }
+        await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const tx = await this.RefundWithSignature(signer, swapData, timeout, signature, feeRate);
+        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: " + swapData.getClaimHash() +
+            " auth expiry: " + timeout + " signature: " + signature);
+        return [tx];
+    }
+    getRefundGas(swapData) {
+        let totalGas = EVMSwapRefund.GasCosts.BASE;
+        if (swapData.reputation)
+            totalGas += EVMSwapRefund.GasCosts.REPUTATION;
+        if (swapData.isPayIn()) {
+            if (swapData.isToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        else {
+            totalGas += EVMSwapRefund.GasCosts.LP_VAULT_TRANSFER;
+        }
+        if (swapData.getSecurityDeposit() > 0n) {
+            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        if (swapData.getClaimerBounty() > swapData.getSecurityDeposit()) {
+            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        return totalGas;
+    }
+    /**
+     * Get the estimated transaction fee of the refund transaction
+     */
+    async getRefundFee(swapData, feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return EVMFees_1.EVMFees.getGasFee(this.getRefundGas(swapData), feeRate);
+    }
+}
+exports.EVMSwapRefund = EVMSwapRefund;
+EVMSwapRefund.GasCosts = {
+    BASE: 35000 + 21000,
+    ERC20_TRANSFER: 40000,
+    NATIVE_TRANSFER: 35500,
+    LP_VAULT_TRANSFER: 10000,
+    REPUTATION: 25000
+};

package/dist/evm/typechain/common.d.ts

@@ -1,50 +1,50 @@
-import type { FunctionFragment, Typed, EventFragment, ContractTransaction, ContractTransactionResponse, DeferredTopicFilter, EventLog, TransactionRequest, LogDescription } from "ethers";
-export interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> extends DeferredTopicFilter {
-}
-export interface TypedContractEvent<InputTuple extends Array<any> = any, OutputTuple extends Array<any> = any, OutputObject = any> {
-    (...args: Partial<InputTuple>): TypedDeferredTopicFilter<TypedContractEvent<InputTuple, OutputTuple, OutputObject>>;
-    name: string;
-    fragment: EventFragment;
-    getFragment(...args: Partial<InputTuple>): EventFragment;
-}
-type __TypechainAOutputTuple<T> = T extends TypedContractEvent<infer _U, infer W> ? W : never;
-type __TypechainOutputObject<T> = T extends TypedContractEvent<infer _U, infer _W, infer V> ? V : never;
-export interface TypedEventLog<TCEvent extends TypedContractEvent> extends Omit<EventLog, "args"> {
-    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
-}
-export interface TypedLogDescription<TCEvent extends TypedContractEvent> extends Omit<LogDescription, "args"> {
-    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
-}
-export type TypedListener<TCEvent extends TypedContractEvent> = (...listenerArg: [
-    ...__TypechainAOutputTuple<TCEvent>,
-    TypedEventLog<TCEvent>,
-    ...undefined[]
-]) => void;
-export type MinEthersFactory<C, ARGS> = {
-    deploy(...a: ARGS[]): Promise<C>;
-};
-export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
-export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any> ? Parameters<F["deploy"]> : never;
-export type StateMutability = "nonpayable" | "payable" | "view";
-export type BaseOverrides = Omit<TransactionRequest, "to" | "data">;
-export type NonPayableOverrides = Omit<BaseOverrides, "value" | "blockTag" | "enableCcipRead">;
-export type PayableOverrides = Omit<BaseOverrides, "blockTag" | "enableCcipRead">;
-export type ViewOverrides = Omit<TransactionRequest, "to" | "data">;
-export type Overrides<S extends StateMutability> = S extends "nonpayable" ? NonPayableOverrides : S extends "payable" ? PayableOverrides : ViewOverrides;
-export type PostfixOverrides<A extends Array<any>, S extends StateMutability> = A | [...A, Overrides<S>];
-export type ContractMethodArgs<A extends Array<any>, S extends StateMutability> = PostfixOverrides<{
-    [I in keyof A]-?: A[I] | Typed;
-}, S>;
-export type DefaultReturnType<R> = R extends Array<any> ? R[0] : R;
-export interface TypedContractMethod<A extends Array<any> = Array<any>, R = any, S extends StateMutability = "payable"> {
-    (...args: ContractMethodArgs<A, S>): S extends "view" ? Promise<DefaultReturnType<R>> : Promise<ContractTransactionResponse>;
-    name: string;
-    fragment: FunctionFragment;
-    getFragment(...args: ContractMethodArgs<A, S>): FunctionFragment;
-    populateTransaction(...args: ContractMethodArgs<A, S>): Promise<ContractTransaction>;
-    staticCall(...args: ContractMethodArgs<A, "view">): Promise<DefaultReturnType<R>>;
-    send(...args: ContractMethodArgs<A, S>): Promise<ContractTransactionResponse>;
-    estimateGas(...args: ContractMethodArgs<A, S>): Promise<bigint>;
-    staticCallResult(...args: ContractMethodArgs<A, "view">): Promise<R>;
-}
-export {};
+import type { FunctionFragment, Typed, EventFragment, ContractTransaction, ContractTransactionResponse, DeferredTopicFilter, EventLog, TransactionRequest, LogDescription } from "ethers";
+export interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> extends DeferredTopicFilter {
+}
+export interface TypedContractEvent<InputTuple extends Array<any> = any, OutputTuple extends Array<any> = any, OutputObject = any> {
+    (...args: Partial<InputTuple>): TypedDeferredTopicFilter<TypedContractEvent<InputTuple, OutputTuple, OutputObject>>;
+    name: string;
+    fragment: EventFragment;
+    getFragment(...args: Partial<InputTuple>): EventFragment;
+}
+type __TypechainAOutputTuple<T> = T extends TypedContractEvent<infer _U, infer W> ? W : never;
+type __TypechainOutputObject<T> = T extends TypedContractEvent<infer _U, infer _W, infer V> ? V : never;
+export interface TypedEventLog<TCEvent extends TypedContractEvent> extends Omit<EventLog, "args"> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+export interface TypedLogDescription<TCEvent extends TypedContractEvent> extends Omit<LogDescription, "args"> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+export type TypedListener<TCEvent extends TypedContractEvent> = (...listenerArg: [
+    ...__TypechainAOutputTuple<TCEvent>,
+    TypedEventLog<TCEvent>,
+    ...undefined[]
+]) => void;
+export type MinEthersFactory<C, ARGS> = {
+    deploy(...a: ARGS[]): Promise<C>;
+};
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any> ? Parameters<F["deploy"]> : never;
+export type StateMutability = "nonpayable" | "payable" | "view";
+export type BaseOverrides = Omit<TransactionRequest, "to" | "data">;
+export type NonPayableOverrides = Omit<BaseOverrides, "value" | "blockTag" | "enableCcipRead">;
+export type PayableOverrides = Omit<BaseOverrides, "blockTag" | "enableCcipRead">;
+export type ViewOverrides = Omit<TransactionRequest, "to" | "data">;
+export type Overrides<S extends StateMutability> = S extends "nonpayable" ? NonPayableOverrides : S extends "payable" ? PayableOverrides : ViewOverrides;
+export type PostfixOverrides<A extends Array<any>, S extends StateMutability> = A | [...A, Overrides<S>];
+export type ContractMethodArgs<A extends Array<any>, S extends StateMutability> = PostfixOverrides<{
+    [I in keyof A]-?: A[I] | Typed;
+}, S>;
+export type DefaultReturnType<R> = R extends Array<any> ? R[0] : R;
+export interface TypedContractMethod<A extends Array<any> = Array<any>, R = any, S extends StateMutability = "payable"> {
+    (...args: ContractMethodArgs<A, S>): S extends "view" ? Promise<DefaultReturnType<R>> : Promise<ContractTransactionResponse>;
+    name: string;
+    fragment: FunctionFragment;
+    getFragment(...args: ContractMethodArgs<A, S>): FunctionFragment;
+    populateTransaction(...args: ContractMethodArgs<A, S>): Promise<ContractTransaction>;
+    staticCall(...args: ContractMethodArgs<A, "view">): Promise<DefaultReturnType<R>>;
+    send(...args: ContractMethodArgs<A, S>): Promise<ContractTransactionResponse>;
+    estimateGas(...args: ContractMethodArgs<A, S>): Promise<bigint>;
+    staticCallResult(...args: ContractMethodArgs<A, "view">): Promise<R>;
+}
+export {};

package/dist/evm/typechain/common.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,5 +1,5 @@
-import { Signer } from "ethers";
-import { EVMSigner } from "./EVMSigner";
-export declare class EVMBrowserSigner extends EVMSigner {
-    constructor(account: Signer, address: string);
-}
+import { Signer } from "ethers";
+import { EVMSigner } from "./EVMSigner";
+export declare class EVMBrowserSigner extends EVMSigner {
+    constructor(account: Signer, address: string);
+}

package/dist/evm/wallet/EVMBrowserSigner.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMBrowserSigner = void 0;
-const EVMSigner_1 = require("./EVMSigner");
-class EVMBrowserSigner extends EVMSigner_1.EVMSigner {
-    constructor(account, address) {
-        super(account, address, false);
-        this.signTransaction = null;
-    }
-}
-exports.EVMBrowserSigner = EVMBrowserSigner;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMBrowserSigner = void 0;
+const EVMSigner_1 = require("./EVMSigner");
+class EVMBrowserSigner extends EVMSigner_1.EVMSigner {
+    constructor(account, address) {
+        super(account, address, false);
+        this.signTransaction = null;
+    }
+}
+exports.EVMBrowserSigner = EVMBrowserSigner;