@atomiqlabs/chain-evm 1.0.0-dev.62 → 1.0.0-dev.64

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

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

@@ -1,20 +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
-];
-
+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

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

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

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

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