@atomiqlabs/chain-evm 1.0.0-dev.34 → 1.0.0-dev.36

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

@@ -1,115 +1,115 @@
-import {IClaimHandler} from "../ClaimHandlers";
-import {BigIntBufferUtils, ChainSwapType, RelaySynchronizer} from "@atomiqlabs/base";
-import {EVMBtcRelay} from "../../../../btcrelay/EVMBtcRelay";
-import { EVMBtcStoredHeader } from "../../../../btcrelay/headers/EVMBtcStoredHeader";
-import {EVMTx} from "../../../../chain/modules/EVMTransactions";
-import {getLogger} from "../../../../../utils/Utils";
-import {keccak256} from "ethers";
-import {Buffer} from "buffer";
-import {EVMSwapData} from "../../../EVMSwapData";
-
-export type BitcoinCommitmentData = {
-    btcRelay: EVMBtcRelay<any>,
-    confirmations: number
-}
-
-export type BitcoinWitnessData = {
-    tx: { blockhash: string, confirmations: number, txid: string, hex: string, height: number },
-    requiredConfirmations: number,
-    commitedHeader?: EVMBtcStoredHeader,
-    btcRelay?: EVMBtcRelay<any>,
-    synchronizer?: RelaySynchronizer<EVMBtcStoredHeader, EVMTx, any>
-};
-
-const logger = getLogger("IBitcoinClaimHandler: ");
-
-export abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> implements IClaimHandler<C & BitcoinCommitmentData, W> {
-
-    public readonly address: string;
-
-    constructor(address: string) {
-        this.address = address;
-    }
-
-    public static readonly address = "";
-    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
-    public static readonly gas: number = 10_000;
-
-    protected serializeCommitment(data: BitcoinCommitmentData): Buffer {
-        const buffer = Buffer.alloc(24);
-        buffer.writeUint32BE(data.confirmations, 0);
-        Buffer.from(data.btcRelay.contractAddress.substring(2), "hex").copy(buffer, 4, 0, 20);
-        return buffer;
-    }
-
-    getCommitment(data: C & BitcoinCommitmentData): string {
-        return keccak256(this.serializeCommitment(data));
-    }
-
-    protected async _getWitness(
-        signer: string,
-        swapData: EVMSwapData,
-        {tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations}: BitcoinWitnessData,
-        commitment: C,
-        feeRate?: string
-    ): Promise<{
-        initialTxns: EVMTx[];
-        witness: Buffer,
-        commitment: Buffer,
-        blockheader: Buffer,
-        merkleProof: Buffer
-    }> {
-        const serializedCommitment: Buffer = this.serializeCommitment({
-            ...commitment,
-            btcRelay,
-            confirmations: requiredConfirmations
-        });
-        const commitmentHash = keccak256(serializedCommitment);
-
-        if(!swapData.isClaimData(commitmentHash)) throw new Error("Invalid commit data");
-
-        const merkleProof = await btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
-        logger.debug("getWitness(): merkle proof computed: ", merkleProof);
-
-        const txs: EVMTx[] = [];
-        if(commitedHeader==null) {
-            const headers = await EVMBtcRelay.getCommitedHeadersAndSynchronize(
-                signer, btcRelay,
-                [{blockheight: tx.height, requiredConfirmations, blockhash: tx.blockhash}],
-                txs, synchronizer, feeRate
-            );
-            if(headers==null) throw new Error("Cannot fetch committed header!");
-            commitedHeader = headers[tx.blockhash];
-        }
-
-        const serializedHeader = commitedHeader.serialize();
-
-        const serializedMerkleProof = Buffer.concat([
-            BigIntBufferUtils.toBuffer(BigInt(merkleProof.pos), "be", 4),
-            BigIntBufferUtils.toBuffer(BigInt(merkleProof.merkle.length), "be", 32),
-            ...merkleProof.merkle
-        ]);
-
-        return {
-            initialTxns: txs,
-            witness: Buffer.concat([
-                serializedCommitment,
-                serializedHeader,
-                serializedMerkleProof
-            ]),
-            commitment: serializedCommitment,
-            blockheader: serializedHeader,
-            merkleProof: serializedMerkleProof
-        };
-    }
-
-    abstract getWitness(signer: string, data: EVMSwapData, witnessData: W, feeRate?: string): Promise<{
-        initialTxns: EVMTx[];
-        witness: Buffer
-    }>;
-
-    abstract getGas(data: EVMSwapData): number;
-
-    abstract getType(): ChainSwapType;
-
-}
+import {IClaimHandler} from "../ClaimHandlers";
+import {BigIntBufferUtils, ChainSwapType, RelaySynchronizer} from "@atomiqlabs/base";
+import {EVMBtcRelay} from "../../../../btcrelay/EVMBtcRelay";
+import { EVMBtcStoredHeader } from "../../../../btcrelay/headers/EVMBtcStoredHeader";
+import {EVMTx} from "../../../../chain/modules/EVMTransactions";
+import {getLogger} from "../../../../../utils/Utils";
+import {keccak256} from "ethers";
+import {Buffer} from "buffer";
+import {EVMSwapData} from "../../../EVMSwapData";
+
+export type BitcoinCommitmentData = {
+    btcRelay: EVMBtcRelay<any>,
+    confirmations: number
+}
+
+export type BitcoinWitnessData = {
+    tx: { blockhash: string, confirmations: number, txid: string, hex: string, height: number },
+    requiredConfirmations: number,
+    commitedHeader?: EVMBtcStoredHeader,
+    btcRelay?: EVMBtcRelay<any>,
+    synchronizer?: RelaySynchronizer<EVMBtcStoredHeader, EVMTx, any>
+};
+
+const logger = getLogger("IBitcoinClaimHandler: ");
+
+export abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> implements IClaimHandler<C & BitcoinCommitmentData, W> {
+
+    public readonly address: string;
+
+    constructor(address: string) {
+        this.address = address;
+    }
+
+    public static readonly address = "";
+    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
+    public static readonly gas: number = 10_000;
+
+    protected serializeCommitment(data: BitcoinCommitmentData): Buffer {
+        const buffer = Buffer.alloc(24);
+        buffer.writeUint32BE(data.confirmations, 0);
+        Buffer.from(data.btcRelay.contractAddress.substring(2), "hex").copy(buffer, 4, 0, 20);
+        return buffer;
+    }
+
+    getCommitment(data: C & BitcoinCommitmentData): string {
+        return keccak256(this.serializeCommitment(data));
+    }
+
+    protected async _getWitness(
+        signer: string,
+        swapData: EVMSwapData,
+        {tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations}: BitcoinWitnessData,
+        commitment: C,
+        feeRate?: string
+    ): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer,
+        commitment: Buffer,
+        blockheader: Buffer,
+        merkleProof: Buffer
+    }> {
+        const serializedCommitment: Buffer = this.serializeCommitment({
+            ...commitment,
+            btcRelay,
+            confirmations: requiredConfirmations
+        });
+        const commitmentHash = keccak256(serializedCommitment);
+
+        if(!swapData.isClaimData(commitmentHash)) throw new Error("Invalid commit data");
+
+        const merkleProof = await btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
+        logger.debug("getWitness(): merkle proof computed: ", merkleProof);
+
+        const txs: EVMTx[] = [];
+        if(commitedHeader==null) {
+            const headers = await EVMBtcRelay.getCommitedHeadersAndSynchronize(
+                signer, btcRelay,
+                [{blockheight: tx.height, requiredConfirmations, blockhash: tx.blockhash}],
+                txs, synchronizer, feeRate
+            );
+            if(headers==null) throw new Error("Cannot fetch committed header!");
+            commitedHeader = headers[tx.blockhash];
+        }
+
+        const serializedHeader = commitedHeader.serialize();
+
+        const serializedMerkleProof = Buffer.concat([
+            BigIntBufferUtils.toBuffer(BigInt(merkleProof.pos), "be", 4),
+            BigIntBufferUtils.toBuffer(BigInt(merkleProof.merkle.length), "be", 32),
+            ...merkleProof.merkle
+        ]);
+
+        return {
+            initialTxns: txs,
+            witness: Buffer.concat([
+                serializedCommitment,
+                serializedHeader,
+                serializedMerkleProof
+            ]),
+            commitment: serializedCommitment,
+            blockheader: serializedHeader,
+            merkleProof: serializedMerkleProof
+        };
+    }
+
+    abstract getWitness(signer: string, data: EVMSwapData, witnessData: W, feeRate?: string): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer
+    }>;
+
+    abstract getGas(data: EVMSwapData): number;
+
+    abstract getType(): ChainSwapType;
+
+}

package/src/evm/swaps/handlers/refund/TimelockRefundHandler.ts

@@ -1,38 +1,38 @@
-import {IHandler} from "../IHandler";
-import {BigIntBufferUtils} from "@atomiqlabs/base";
-import {EVMSwapData} from "../../EVMSwapData";
-import {EVMTx} from "../../../chain/modules/EVMTransactions";
-
-export class TimelockRefundHandler implements IHandler<bigint, never> {
-
-    public readonly address: string;
-    public static readonly gas: number = 5_000;
-
-    constructor(address: string) {
-        this.address = address;
-    }
-
-    public getCommitment(data: bigint): string {
-        return "0x"+BigIntBufferUtils.toBuffer(data, "be", 32).toString("hex");
-    }
-
-    public getWitness(signer: string, data: EVMSwapData): Promise<{
-        initialTxns: EVMTx[],
-        witness: Buffer
-    }> {
-        const expiry = TimelockRefundHandler.getExpiry(data);
-        const currentTimestamp = BigInt(Math.floor(Date.now()/1000));
-        if(expiry > currentTimestamp) throw new Error("Not expired yet!");
-        return Promise.resolve({initialTxns: [], witness: Buffer.alloc(0)});
-    }
-
-    getGas(): number {
-        return TimelockRefundHandler.gas;
-    }
-
-    public static getExpiry(data: EVMSwapData): bigint {
-        const expiryDataBuffer = Buffer.from(data.refundData.startsWith("0x") ? data.refundData.substring(2) : data.refundData, "hex");
-        return BigIntBufferUtils.fromBuffer(expiryDataBuffer, "be");
-    }
-
+import {IHandler} from "../IHandler";
+import {BigIntBufferUtils} from "@atomiqlabs/base";
+import {EVMSwapData} from "../../EVMSwapData";
+import {EVMTx} from "../../../chain/modules/EVMTransactions";
+
+export class TimelockRefundHandler implements IHandler<bigint, never> {
+
+    public readonly address: string;
+    public static readonly gas: number = 5_000;
+
+    constructor(address: string) {
+        this.address = address;
+    }
+
+    public getCommitment(data: bigint): string {
+        return "0x"+BigIntBufferUtils.toBuffer(data, "be", 32).toString("hex");
+    }
+
+    public getWitness(signer: string, data: EVMSwapData): Promise<{
+        initialTxns: EVMTx[],
+        witness: Buffer
+    }> {
+        const expiry = TimelockRefundHandler.getExpiry(data);
+        const currentTimestamp = BigInt(Math.floor(Date.now()/1000));
+        if(expiry > currentTimestamp) throw new Error("Not expired yet!");
+        return Promise.resolve({initialTxns: [], witness: Buffer.alloc(0)});
+    }
+
+    getGas(): number {
+        return TimelockRefundHandler.gas;
+    }
+
+    public static getExpiry(data: EVMSwapData): bigint {
+        const expiryDataBuffer = Buffer.from(data.refundData.startsWith("0x") ? data.refundData.substring(2) : data.refundData, "hex");
+        return BigIntBufferUtils.fromBuffer(expiryDataBuffer, "be");
+    }
+
 }

package/src/evm/swaps/modules/EVMLpVault.ts

@@ -1,153 +1,155 @@
-import { IntermediaryReputationType } from "@atomiqlabs/base";
-import { EVMSwapModule } from "../EVMSwapModule";
-import {TransactionRequest} from "ethers";
-import {EVMFees} from "../../chain/modules/EVMFees";
-import {EVMTx} from "../../chain/modules/EVMTransactions";
-
-export class EVMLpVault extends EVMSwapModule {
-
-    private static readonly GasCosts = {
-        WITHDRAW: 100_000 + 21_000,
-        DEPOSIT: 100_000 + 21_000
-    };
-
-    /**
-     * Action for withdrawing funds from the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     * @private
-     */
-    private async Withdraw(signer: string, token: string, amount: bigint, feeRate: string): Promise<TransactionRequest> {
-        const tx = await this.swapContract.withdraw.populateTransaction(token, amount, signer);
-        tx.from = signer;
-        tx.gasLimit = BigInt(EVMLpVault.GasCosts.WITHDRAW);
-        EVMFees.applyFeeRate(tx, EVMLpVault.GasCosts.WITHDRAW, feeRate);
-        return tx;
-    }
-
-    /**
-     * Action for depositing funds to the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     * @private
-     */
-    private async Deposit(signer: string, token: string, amount: bigint, feeRate: string): Promise<TransactionRequest> {
-        const tx = await this.swapContract.deposit.populateTransaction(token, amount, {
-            value: token.toLowerCase()===this.root.getNativeCurrencyAddress().toLowerCase() ? amount : 0n
-        });
-        tx.from = signer;
-        EVMFees.applyFeeRate(tx, EVMLpVault.GasCosts.DEPOSIT, feeRate);
-        return tx;
-    }
-
-    /**
-     * Returns intermediary's reputation & vault balance for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    public async getIntermediaryData(address: string, token: string): Promise<{
-        balance: bigint,
-        reputation: IntermediaryReputationType
-    }> {
-        const [balance, reputation] = await Promise.all([
-            this.getIntermediaryBalance(address, token),
-            this.getIntermediaryReputation(address, token)
-        ]);
-
-        return {balance, reputation};
-    }
-
-    /**
-     * Returns intermediary's reputation for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    public async getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType> {
-        const filter = Object.keys(this.contract.claimHandlersByAddress).map(claimHandler => ({owner: address, token, claimHandler}));
-        const resp = await this.swapContract.getReputation(filter);
-        if(resp.length!==filter.length) throw new Error("getIntermediaryReputation(): Invalid response length");
-
-        const result: any = {};
-        Object.keys(this.contract.claimHandlersByAddress).forEach((address, index) => {
-            const handler = this.contract.claimHandlersByAddress[address.toLowerCase()];
-            const handlerResp = resp[index];
-            result[handler.getType()] = {
-                successVolume: handlerResp[0].amount,
-                successCount: handlerResp[0].count,
-                coopCloseVolume: handlerResp[1].amount,
-                coopCloseCount: handlerResp[1].count,
-                failVolume: handlerResp[2].amount,
-                failCount: handlerResp[2].count,
-            };
-        });
-        return result as any;
-    }
-
-    /**
-     * Returns the balance of the token an intermediary has in his LP vault
-     *
-     * @param address
-     * @param token
-     */
-    public async getIntermediaryBalance(address: string, token: string): Promise<bigint> {
-        const [balance] = await this.swapContract.getBalance([{owner: address, token}]);
-
-        this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: "+token.toString()+
-            " address: "+address+" amount: "+(balance==null ? "null" : balance.toString()));
-
-        return balance;
-    }
-
-    /**
-     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
-     *  WSOL to SOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    public async txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]> {
-        feeRate ??= await this.root.Fees.getFeeRate();
-        const withdrawTx = await this.Withdraw(signer, token, amount, feeRate);
-
-        this.logger.debug("txsWithdraw(): withdraw TX created, token: "+token.toString()+
-            " amount: "+amount.toString(10));
-
-        return [withdrawTx];
-    }
-
-    /**
-     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    public async txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]> {
-        feeRate ??= await this.root.Fees.getFeeRate();
-
-        const txs: EVMTx[] = [];
-
-        //Approve first
-        if(token.toLowerCase()!==this.root.getNativeCurrencyAddress().toLowerCase())
-            txs.push(await this.root.Tokens.Approve(signer, token, amount, this.contract.contractAddress, feeRate));
-
-        txs.push(await this.Deposit(signer, token, amount, feeRate));
-
-        this.logger.debug("txsDeposit(): deposit TX created, token: "+token.toString()+
-            " amount: "+amount.toString(10));
-
-        return txs;
-    }
-
+import { IntermediaryReputationType } from "@atomiqlabs/base";
+import { EVMSwapModule } from "../EVMSwapModule";
+import {TransactionRequest} from "ethers";
+import {EVMFees} from "../../chain/modules/EVMFees";
+import {EVMTx} from "../../chain/modules/EVMTransactions";
+
+export class EVMLpVault extends EVMSwapModule {
+
+    private static readonly GasCosts = {
+        WITHDRAW: 100_000 + 21_000,
+        DEPOSIT: 100_000 + 21_000
+    };
+
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     * @private
+     */
+    private async Withdraw(signer: string, token: string, amount: bigint, feeRate: string): Promise<TransactionRequest> {
+        const tx = await this.swapContract.withdraw.populateTransaction(token, amount, signer);
+        tx.from = signer;
+        tx.gasLimit = BigInt(EVMLpVault.GasCosts.WITHDRAW);
+        EVMFees.applyFeeRate(tx, EVMLpVault.GasCosts.WITHDRAW, feeRate);
+        return tx;
+    }
+
+    /**
+     * Action for depositing funds to the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     * @private
+     */
+    private async Deposit(signer: string, token: string, amount: bigint, feeRate: string): Promise<TransactionRequest> {
+        const tx = await this.swapContract.deposit.populateTransaction(token, amount, {
+            value: token.toLowerCase()===this.root.getNativeCurrencyAddress().toLowerCase() ? amount : 0n
+        });
+        tx.from = signer;
+        EVMFees.applyFeeRate(tx, EVMLpVault.GasCosts.DEPOSIT, feeRate);
+        return tx;
+    }
+
+    /**
+     * Returns intermediary's reputation & vault balance for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    public async getIntermediaryData(address: string, token: string): Promise<{
+        balance: bigint,
+        reputation: IntermediaryReputationType
+    }> {
+        const [balance, reputation] = await Promise.all([
+            this.getIntermediaryBalance(address, token),
+            this.getIntermediaryReputation(address, token)
+        ]);
+
+        return {balance, reputation};
+    }
+
+    /**
+     * Returns intermediary's reputation for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    public async getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType> {
+        const filter = Object.keys(this.contract.claimHandlersByAddress).map(claimHandler => ({owner: address, token, claimHandler}));
+        const resp = await this.swapContract.getReputation(filter);
+        if(resp.length!==filter.length) throw new Error("getIntermediaryReputation(): Invalid response length");
+
+        const result: any = {};
+        Object.keys(this.contract.claimHandlersByAddress).forEach((address, index) => {
+            const handler = this.contract.claimHandlersByAddress[address.toLowerCase()];
+            const handlerResp = resp[index];
+            result[handler.getType()] = {
+                successVolume: handlerResp[0].amount,
+                successCount: handlerResp[0].count,
+                coopCloseVolume: handlerResp[1].amount,
+                coopCloseCount: handlerResp[1].count,
+                failVolume: handlerResp[2].amount,
+                failCount: handlerResp[2].count,
+            };
+        });
+        return result as any;
+    }
+
+    /**
+     * Returns the balance of the token an intermediary has in his LP vault
+     *
+     * @param address
+     * @param token
+     */
+    public async getIntermediaryBalance(address: string, token: string): Promise<bigint> {
+        const [balance] = await this.swapContract.getBalance([{owner: address, token}]);
+
+        this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: "+token.toString()+
+            " address: "+address+" amount: "+(balance==null ? "null" : balance.toString()));
+
+        return balance;
+    }
+
+    /**
+     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
+     *  WSOL to SOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    public async txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+        const withdrawTx = await this.Withdraw(signer, token, amount, feeRate);
+
+        this.logger.debug("txsWithdraw(): withdraw TX created, token: "+token.toString()+
+            " amount: "+amount.toString(10));
+
+        return [withdrawTx];
+    }
+
+    /**
+     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    public async txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        const txs: EVMTx[] = [];
+
+        //Approve first
+        if(token.toLowerCase()!==this.root.getNativeCurrencyAddress().toLowerCase()) {
+            const approveTx = await this.root.Tokens.checkAndGetApproveTx(signer, token, amount, this.contract.contractAddress, feeRate);
+            if(approveTx!=null) txs.push(approveTx);
+        }
+
+        txs.push(await this.Deposit(signer, token, amount, feeRate));
+
+        this.logger.debug("txsDeposit(): deposit TX created, token: "+token.toString()+
+            " amount: "+amount.toString(10));
+
+        return txs;
+    }
+
 }