@atomiqlabs/chain-evm 1.0.0-dev.22

package/src/evm/swaps/handlers/IHandler.ts

@@ -0,0 +1,17 @@
+import {EVMSwapData} from "../EVMSwapData";
+import {EVMTx} from "../../chain/modules/EVMTransactions";
+
+export interface IHandler<TCommitmentData, TWitnessData> {
+
+    readonly address: string;
+
+    getCommitment(data: TCommitmentData): string;
+
+    getWitness(signer: string, data: EVMSwapData, witnessData: TWitnessData, feeRate?: string): Promise<{
+        initialTxns: EVMTx[],
+        witness: Buffer
+    }>;
+
+    getGas(data: EVMSwapData): number;
+
+}

package/src/evm/swaps/handlers/claim/ClaimHandlers.ts

@@ -0,0 +1,20 @@
+import {HashlockClaimHandler} from "./HashlockClaimHandler";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {IHandler} from "../IHandler";
+import {BitcoinTxIdClaimHandler} from "./btc/BitcoinTxIdClaimHandler";
+import {BitcoinOutputClaimHandler} from "./btc/BitcoinOutputClaimHandler";
+import {BitcoinNoncedOutputClaimHandler} from "./btc/BitcoinNoncedOutputClaimHandler";
+
+export interface IClaimHandler<C, W> extends IHandler<C, W> {
+    getType(): ChainSwapType;
+}
+
+export type ClaimHandlerType = {gas: number, type: ChainSwapType} & (new (address: string) => IClaimHandler<any, any>);
+
+export const claimHandlersList: ClaimHandlerType[] = [
+    HashlockClaimHandler,
+    BitcoinTxIdClaimHandler,
+    BitcoinOutputClaimHandler,
+    BitcoinNoncedOutputClaimHandler
+];
+

package/src/evm/swaps/handlers/claim/HashlockClaimHandler.ts

@@ -0,0 +1,47 @@
+import {ChainSwapType} from "@atomiqlabs/base";
+import {Buffer} from "buffer";
+import {IClaimHandler} from "./ClaimHandlers";
+import {hexlify} from "ethers";
+import {EVMSwapData} from "../../EVMSwapData";
+import {EVMTx} from "../../../chain/modules/EVMTransactions";
+import {sha256} from "@noble/hashes/sha2";
+
+export class HashlockClaimHandler implements IClaimHandler<Buffer, string> {
+
+    public readonly address: string;
+    public static readonly type: ChainSwapType = ChainSwapType.HTLC;
+    public static readonly gas: number = 5_000;
+
+    constructor(address: string) {
+        this.address = address;
+    }
+
+    getCommitment(data: Buffer): string {
+        if(data.length!==32) throw new Error("Invalid swap hash");
+        return hexlify(data);
+    }
+
+    public getWitness(signer: string, data: EVMSwapData, witnessData: string): Promise<{
+        initialTxns: EVMTx[],
+        witness: Buffer
+    }> {
+        if(!data.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
+        if(witnessData.length!==64) throw new Error("Invalid hash secret: string length");
+        const buffer = Buffer.from(witnessData, "hex");
+        if(buffer.length!==32) throw new Error("Invalid hash secret: buff length");
+
+        const witnessSha256 = Buffer.from(sha256(buffer));
+        if(!data.isClaimData(this.getCommitment(witnessSha256))) throw new Error("Invalid hash secret: poseidon hash doesn't match");
+
+        return Promise.resolve({initialTxns: [], witness: buffer});
+    }
+
+    getGas(): number {
+        return HashlockClaimHandler.gas;
+    }
+
+    getType(): ChainSwapType {
+        return HashlockClaimHandler.type;
+    }
+
+}

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

@@ -0,0 +1,82 @@
+import {BigIntBufferUtils, ChainSwapType} from "@atomiqlabs/base";
+import {BitcoinCommitmentData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
+import {BitcoinOutputWitnessData} from "./BitcoinOutputClaimHandler";
+import {Transaction} from "@scure/btc-signer";
+import {Buffer} from "buffer";
+import {keccak256, solidityPackedKeccak256} from "ethers";
+import {EVMSwapData} from "../../../EVMSwapData";
+import {EVMTx} from "../../../../chain/modules/EVMTransactions";
+
+export type BitcoinNoncedOutputCommitmentData = {
+    output: Buffer,
+    amount: bigint,
+    nonce: bigint
+};
+
+function getTransactionNonce(btcTx: Transaction): bigint {
+    const locktimeSub500M = BigInt(btcTx.lockTime - 500000000);
+    if(locktimeSub500M < 0n) throw new Error("Locktime too low!");
+    const nSequence = BigInt(btcTx.getInput(0).sequence);
+    return (locktimeSub500M << 24n) | (nSequence & 0x00FFFFFFn);
+}
+
+export class BitcoinNoncedOutputClaimHandler extends IBitcoinClaimHandler<BitcoinNoncedOutputCommitmentData, BitcoinOutputWitnessData> {
+
+    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_NONCED;
+    public static readonly gas: number = 40_000;
+
+    protected serializeCommitment(data: BitcoinNoncedOutputCommitmentData & BitcoinCommitmentData): Buffer {
+        const txoHash = solidityPackedKeccak256(["uint64", "uint64", "bytes32"], [data.nonce, data.amount, keccak256(data.output)]);
+        return Buffer.concat([
+            Buffer.from(txoHash.substring(2), "hex"),
+            super.serializeCommitment(data)
+        ]);
+    }
+
+    async getWitness(
+        signer: string,
+        swapData: EVMSwapData,
+        witnessData: BitcoinOutputWitnessData,
+        feeRate?: string
+    ): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer
+    }> {
+        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
+
+        const txBuffer = Buffer.from(witnessData.tx.hex, "hex");
+        const parsedBtcTx = Transaction.fromRaw(txBuffer);
+        const out = parsedBtcTx.getOutput(witnessData.vout);
+
+        const {initialTxns, commitment, blockheader, merkleProof} = await this._getWitness(signer, swapData, witnessData, {
+            output: Buffer.from(out.script),
+            amount: out.amount,
+            nonce: getTransactionNonce(parsedBtcTx)
+        });
+
+        const voutAndTxData = Buffer.concat([
+            BigIntBufferUtils.toBuffer(BigInt(witnessData.vout), "be", 4),
+            BigIntBufferUtils.toBuffer(BigInt(txBuffer.length), "be", 32),
+            txBuffer
+        ]);
+
+        return {
+            initialTxns,
+            witness: Buffer.concat([
+                commitment,
+                blockheader,
+                voutAndTxData,
+                merkleProof
+            ])
+        };
+    }
+
+    getGas(data: EVMSwapData): number {
+        return BitcoinNoncedOutputClaimHandler.gas;
+    }
+
+    getType(): ChainSwapType {
+        return BitcoinNoncedOutputClaimHandler.type;
+    }
+
+}

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

@@ -0,0 +1,76 @@
+import {BigIntBufferUtils, ChainSwapType} from "@atomiqlabs/base";
+import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
+import {Buffer} from "buffer";
+import {keccak256, solidityPackedKeccak256} from "ethers";
+import {EVMTx} from "../../../../chain/modules/EVMTransactions";
+import {Transaction} from "@scure/btc-signer";
+import {EVMSwapData} from "../../../EVMSwapData";
+
+export type BitcoinOutputCommitmentData = {
+    output: Buffer,
+    amount: bigint
+};
+
+export type BitcoinOutputWitnessData = BitcoinWitnessData & {
+    vout: number
+};
+
+export class BitcoinOutputClaimHandler extends IBitcoinClaimHandler<BitcoinOutputCommitmentData, BitcoinOutputWitnessData> {
+
+    public static readonly type: ChainSwapType = ChainSwapType.CHAIN;
+    public static readonly gas: number = 40_000;
+
+    protected serializeCommitment(data: BitcoinOutputCommitmentData & BitcoinCommitmentData): Buffer {
+        const txoHash = solidityPackedKeccak256(["uint64", "bytes32"], [data.amount, keccak256(data.output)]);
+        return Buffer.concat([
+            Buffer.from(txoHash.substring(2), "hex"),
+            super.serializeCommitment(data)
+        ]);
+    }
+
+    async getWitness(
+        signer: string,
+        swapData: EVMSwapData,
+        witnessData: BitcoinOutputWitnessData,
+        feeRate?: string
+    ): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer
+    }> {
+        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
+
+        const txBuffer = Buffer.from(witnessData.tx.hex, "hex");
+        const parsedBtcTx = Transaction.fromRaw(txBuffer);
+        const out = parsedBtcTx.getOutput(witnessData.vout);
+
+        const {initialTxns, commitment, blockheader, merkleProof} = await this._getWitness(signer, swapData, witnessData, {
+            output: Buffer.from(out.script),
+            amount: out.amount
+        });
+
+        const voutAndTxData = Buffer.concat([
+            BigIntBufferUtils.toBuffer(BigInt(witnessData.vout), "be", 4),
+            BigIntBufferUtils.toBuffer(BigInt(txBuffer.length), "be", 32),
+            txBuffer
+        ]);
+
+        return {
+            initialTxns,
+            witness: Buffer.concat([
+                commitment,
+                blockheader,
+                voutAndTxData,
+                merkleProof
+            ])
+        };
+    }
+
+    getGas(data: EVMSwapData): number {
+        return BitcoinOutputClaimHandler.gas;
+    }
+
+    getType(): ChainSwapType {
+        return BitcoinOutputClaimHandler.type;
+    }
+
+}

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

@@ -0,0 +1,46 @@
+import {ChainSwapType} from "@atomiqlabs/base";
+import {getLogger} from "../../../../../utils/Utils";
+import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
+import {Buffer} from "buffer";
+import {EVMSwapData} from "../../../EVMSwapData";
+import {EVMTx} from "../../../../chain/modules/EVMTransactions";
+
+export type BitcoinTxIdCommitmentData = {
+    txId: string
+};
+
+export class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler<BitcoinTxIdCommitmentData, BitcoinWitnessData> {
+
+    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
+    public static readonly gas: number = 10_000;
+
+    protected serializeCommitment(data: BitcoinTxIdCommitmentData & BitcoinCommitmentData): Buffer {
+        return Buffer.concat([
+            Buffer.from(data.txId, "hex").reverse(),
+            super.serializeCommitment(data)
+        ]);
+    }
+
+    getWitness(
+        signer: string,
+        swapData: EVMSwapData,
+        witnessData: BitcoinWitnessData,
+        feeRate?: string
+    ): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer
+    }> {
+        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
+
+        return this._getWitness(signer, swapData, witnessData, {txId: witnessData.tx.txid});
+    }
+
+    getGas(data: EVMSwapData): number {
+        return BitcoinTxIdClaimHandler.gas;
+    }
+
+    getType(): ChainSwapType {
+        return BitcoinTxIdClaimHandler.type;
+    }
+
+}

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

@@ -0,0 +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;
+
+}

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

@@ -0,0 +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");
+    }
+
+}

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

@@ -0,0 +1,153 @@
+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,
+        DEPOSIT: 100_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;
+    }
+
+}