@atomiqlabs/chain-evm 1.0.0-dev.22

package/dist/evm/swaps/EscrowManagerTypechain.d.ts

@@ -0,0 +1,475 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../typechain/common";
+export type EscrowDataStruct = {
+    offerer: AddressLike;
+    claimer: AddressLike;
+    amount: BigNumberish;
+    token: AddressLike;
+    flags: BigNumberish;
+    claimHandler: AddressLike;
+    claimData: BytesLike;
+    refundHandler: AddressLike;
+    refundData: BytesLike;
+    securityDeposit: BigNumberish;
+    claimerBounty: BigNumberish;
+    depositToken: AddressLike;
+    successActionCommitment: BytesLike;
+};
+export type EscrowDataStructOutput = [
+    offerer: string,
+    claimer: string,
+    amount: bigint,
+    token: string,
+    flags: bigint,
+    claimHandler: string,
+    claimData: string,
+    refundHandler: string,
+    refundData: string,
+    securityDeposit: bigint,
+    claimerBounty: bigint,
+    depositToken: string,
+    successActionCommitment: string
+] & {
+    offerer: string;
+    claimer: string;
+    amount: bigint;
+    token: string;
+    flags: bigint;
+    claimHandler: string;
+    claimData: string;
+    refundHandler: string;
+    refundData: string;
+    securityDeposit: bigint;
+    claimerBounty: bigint;
+    depositToken: string;
+    successActionCommitment: string;
+};
+export type ContractCallStruct = {
+    target: AddressLike;
+    value: BigNumberish;
+    data: BytesLike;
+};
+export type ContractCallStructOutput = [
+    target: string,
+    value: bigint,
+    data: string
+] & {
+    target: string;
+    value: bigint;
+    data: string;
+};
+export type ExecutionActionStruct = {
+    gasLimit: BigNumberish;
+    drainTokens: AddressLike[];
+    calls: ContractCallStruct[];
+};
+export type ExecutionActionStructOutput = [
+    gasLimit: bigint,
+    drainTokens: string[],
+    calls: ContractCallStructOutput[]
+] & {
+    gasLimit: bigint;
+    drainTokens: string[];
+    calls: ContractCallStructOutput[];
+};
+export type LpVaultBalanceQueryStruct = {
+    owner: AddressLike;
+    token: AddressLike;
+};
+export type LpVaultBalanceQueryStructOutput = [owner: string, token: string] & {
+    owner: string;
+    token: string;
+};
+export type EscrowStateStruct = {
+    initBlockheight: BigNumberish;
+    finishBlockheight: BigNumberish;
+    state: BigNumberish;
+};
+export type EscrowStateStructOutput = [
+    initBlockheight: bigint,
+    finishBlockheight: bigint,
+    state: bigint
+] & {
+    initBlockheight: bigint;
+    finishBlockheight: bigint;
+    state: bigint;
+};
+export type ReputationQueryStruct = {
+    owner: AddressLike;
+    token: AddressLike;
+    claimHandler: AddressLike;
+};
+export type ReputationQueryStructOutput = [
+    owner: string,
+    token: string,
+    claimHandler: string
+] & {
+    owner: string;
+    token: string;
+    claimHandler: string;
+};
+export type ReputationStateStruct = {
+    amount: BigNumberish;
+    count: BigNumberish;
+};
+export type ReputationStateStructOutput = [amount: bigint, count: bigint] & {
+    amount: bigint;
+    count: bigint;
+};
+export interface EscrowManagerInterface extends Interface {
+    getFunction(nameOrSignature: "claim" | "claimWithSuccessAction" | "cooperativeRefund" | "deposit" | "eip712Domain" | "getBalance" | "getHashState" | "getHashStateMultiple" | "getReputation" | "getState" | "initialize" | "refund" | "withdraw"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Claim" | "EIP712DomainChanged" | "ExecutionError" | "Initialize" | "Refund"): EventFragment;
+    encodeFunctionData(functionFragment: "claim", values: [EscrowDataStruct, BytesLike]): string;
+    encodeFunctionData(functionFragment: "claimWithSuccessAction", values: [EscrowDataStruct, BytesLike, ExecutionActionStruct]): string;
+    encodeFunctionData(functionFragment: "cooperativeRefund", values: [EscrowDataStruct, BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "deposit", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "eip712Domain", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getBalance", values: [LpVaultBalanceQueryStruct[]]): string;
+    encodeFunctionData(functionFragment: "getHashState", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "getHashStateMultiple", values: [BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "getReputation", values: [ReputationQueryStruct[]]): string;
+    encodeFunctionData(functionFragment: "getState", values: [EscrowDataStruct]): string;
+    encodeFunctionData(functionFragment: "initialize", values: [EscrowDataStruct, BytesLike, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: "refund", values: [EscrowDataStruct, BytesLike]): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [AddressLike, BigNumberish, AddressLike]): string;
+    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimWithSuccessAction", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "cooperativeRefund", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "eip712Domain", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getHashState", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getHashStateMultiple", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getReputation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getState", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "refund", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+}
+export declare namespace ClaimEvent {
+    type InputTuple = [
+        offerer: AddressLike,
+        claimer: AddressLike,
+        escrowHash: BytesLike,
+        claimHandler: AddressLike,
+        witnessResult: BytesLike
+    ];
+    type OutputTuple = [
+        offerer: string,
+        claimer: string,
+        escrowHash: string,
+        claimHandler: string,
+        witnessResult: string
+    ];
+    interface OutputObject {
+        offerer: string;
+        claimer: string;
+        escrowHash: string;
+        claimHandler: string;
+        witnessResult: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace EIP712DomainChangedEvent {
+    type InputTuple = [];
+    type OutputTuple = [];
+    interface OutputObject {
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace ExecutionErrorEvent {
+    type InputTuple = [escrowHash: BytesLike, error: BytesLike];
+    type OutputTuple = [escrowHash: string, error: string];
+    interface OutputObject {
+        escrowHash: string;
+        error: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace InitializeEvent {
+    type InputTuple = [
+        offerer: AddressLike,
+        claimer: AddressLike,
+        escrowHash: BytesLike,
+        claimHandler: AddressLike,
+        refundHandler: AddressLike
+    ];
+    type OutputTuple = [
+        offerer: string,
+        claimer: string,
+        escrowHash: string,
+        claimHandler: string,
+        refundHandler: string
+    ];
+    interface OutputObject {
+        offerer: string;
+        claimer: string;
+        escrowHash: string;
+        claimHandler: string;
+        refundHandler: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RefundEvent {
+    type InputTuple = [
+        offerer: AddressLike,
+        claimer: AddressLike,
+        escrowHash: BytesLike,
+        refundHandler: AddressLike,
+        witnessResult: BytesLike
+    ];
+    type OutputTuple = [
+        offerer: string,
+        claimer: string,
+        escrowHash: string,
+        refundHandler: string,
+        witnessResult: string
+    ];
+    interface OutputObject {
+        offerer: string;
+        claimer: string;
+        escrowHash: string;
+        refundHandler: string;
+        witnessResult: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface EscrowManager extends BaseContract {
+    connect(runner?: ContractRunner | null): EscrowManager;
+    waitForDeployment(): Promise<this>;
+    interface: EscrowManagerInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    claim: TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        witness: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    claimWithSuccessAction: TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        witness: BytesLike,
+        successAction: ExecutionActionStruct
+    ], [
+        void
+    ], "nonpayable">;
+    cooperativeRefund: TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        signature: BytesLike,
+        timeout: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    deposit: TypedContractMethod<[
+        token: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    eip712Domain: TypedContractMethod<[
+    ], [
+        [
+            string,
+            string,
+            string,
+            bigint,
+            string,
+            string,
+            bigint[]
+        ] & {
+            fields: string;
+            name: string;
+            version: string;
+            chainId: bigint;
+            verifyingContract: string;
+            salt: string;
+            extensions: bigint[];
+        }
+    ], "view">;
+    getBalance: TypedContractMethod<[
+        data: LpVaultBalanceQueryStruct[]
+    ], [
+        bigint[]
+    ], "view">;
+    getHashState: TypedContractMethod<[
+        escrowHash: BytesLike
+    ], [
+        EscrowStateStructOutput
+    ], "view">;
+    getHashStateMultiple: TypedContractMethod<[
+        escrowHash: BytesLike[]
+    ], [
+        EscrowStateStructOutput[]
+    ], "view">;
+    getReputation: TypedContractMethod<[
+        data: ReputationQueryStruct[]
+    ], [
+        [
+            ReputationStateStructOutput,
+            ReputationStateStructOutput,
+            ReputationStateStructOutput
+        ][]
+    ], "view">;
+    getState: TypedContractMethod<[
+        escrowData: EscrowDataStruct
+    ], [
+        EscrowStateStructOutput
+    ], "view">;
+    initialize: TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        signature: BytesLike,
+        timeout: BigNumberish,
+        _extraData: BytesLike
+    ], [
+        void
+    ], "payable">;
+    refund: TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        witness: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    withdraw: TypedContractMethod<[
+        token: AddressLike,
+        amount: BigNumberish,
+        destination: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "claim"): TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        witness: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "claimWithSuccessAction"): TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        witness: BytesLike,
+        successAction: ExecutionActionStruct
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "cooperativeRefund"): TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        signature: BytesLike,
+        timeout: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[
+        token: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "eip712Domain"): TypedContractMethod<[
+    ], [
+        [
+            string,
+            string,
+            string,
+            bigint,
+            string,
+            string,
+            bigint[]
+        ] & {
+            fields: string;
+            name: string;
+            version: string;
+            chainId: bigint;
+            verifyingContract: string;
+            salt: string;
+            extensions: bigint[];
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getBalance"): TypedContractMethod<[
+        data: LpVaultBalanceQueryStruct[]
+    ], [
+        bigint[]
+    ], "view">;
+    getFunction(nameOrSignature: "getHashState"): TypedContractMethod<[
+        escrowHash: BytesLike
+    ], [
+        EscrowStateStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "getHashStateMultiple"): TypedContractMethod<[
+        escrowHash: BytesLike[]
+    ], [
+        EscrowStateStructOutput[]
+    ], "view">;
+    getFunction(nameOrSignature: "getReputation"): TypedContractMethod<[
+        data: ReputationQueryStruct[]
+    ], [
+        [
+            ReputationStateStructOutput,
+            ReputationStateStructOutput,
+            ReputationStateStructOutput
+        ][]
+    ], "view">;
+    getFunction(nameOrSignature: "getState"): TypedContractMethod<[
+        escrowData: EscrowDataStruct
+    ], [
+        EscrowStateStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "initialize"): TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        signature: BytesLike,
+        timeout: BigNumberish,
+        _extraData: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "refund"): TypedContractMethod<[
+        escrow: EscrowDataStruct,
+        witness: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[
+        token: AddressLike,
+        amount: BigNumberish,
+        destination: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "Claim"): TypedContractEvent<ClaimEvent.InputTuple, ClaimEvent.OutputTuple, ClaimEvent.OutputObject>;
+    getEvent(key: "EIP712DomainChanged"): TypedContractEvent<EIP712DomainChangedEvent.InputTuple, EIP712DomainChangedEvent.OutputTuple, EIP712DomainChangedEvent.OutputObject>;
+    getEvent(key: "ExecutionError"): TypedContractEvent<ExecutionErrorEvent.InputTuple, ExecutionErrorEvent.OutputTuple, ExecutionErrorEvent.OutputObject>;
+    getEvent(key: "Initialize"): TypedContractEvent<InitializeEvent.InputTuple, InitializeEvent.OutputTuple, InitializeEvent.OutputObject>;
+    getEvent(key: "Refund"): TypedContractEvent<RefundEvent.InputTuple, RefundEvent.OutputTuple, RefundEvent.OutputObject>;
+    filters: {
+        "Claim(address,address,bytes32,address,bytes)": TypedContractEvent<ClaimEvent.InputTuple, ClaimEvent.OutputTuple, ClaimEvent.OutputObject>;
+        Claim: TypedContractEvent<ClaimEvent.InputTuple, ClaimEvent.OutputTuple, ClaimEvent.OutputObject>;
+        "EIP712DomainChanged()": TypedContractEvent<EIP712DomainChangedEvent.InputTuple, EIP712DomainChangedEvent.OutputTuple, EIP712DomainChangedEvent.OutputObject>;
+        EIP712DomainChanged: TypedContractEvent<EIP712DomainChangedEvent.InputTuple, EIP712DomainChangedEvent.OutputTuple, EIP712DomainChangedEvent.OutputObject>;
+        "ExecutionError(bytes32,bytes)": TypedContractEvent<ExecutionErrorEvent.InputTuple, ExecutionErrorEvent.OutputTuple, ExecutionErrorEvent.OutputObject>;
+        ExecutionError: TypedContractEvent<ExecutionErrorEvent.InputTuple, ExecutionErrorEvent.OutputTuple, ExecutionErrorEvent.OutputObject>;
+        "Initialize(address,address,bytes32,address,address)": TypedContractEvent<InitializeEvent.InputTuple, InitializeEvent.OutputTuple, InitializeEvent.OutputObject>;
+        Initialize: TypedContractEvent<InitializeEvent.InputTuple, InitializeEvent.OutputTuple, InitializeEvent.OutputObject>;
+        "Refund(address,address,bytes32,address,bytes)": TypedContractEvent<RefundEvent.InputTuple, RefundEvent.OutputTuple, RefundEvent.OutputObject>;
+        Refund: TypedContractEvent<RefundEvent.InputTuple, RefundEvent.OutputTuple, RefundEvent.OutputObject>;
+    };
+}

package/dist/evm/swaps/EscrowManagerTypechain.js

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

package/dist/evm/swaps/handlers/IHandler.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+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/dist/evm/swaps/handlers/IHandler.js

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

package/dist/evm/swaps/handlers/claim/ClaimHandlers.d.ts

@@ -0,0 +1,10 @@
+import { ChainSwapType } from "@atomiqlabs/base";
+import { IHandler } from "../IHandler";
+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 declare const claimHandlersList: ClaimHandlerType[];

package/dist/evm/swaps/handlers/claim/ClaimHandlers.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimHandlersList = void 0;
+const HashlockClaimHandler_1 = require("./HashlockClaimHandler");
+const BitcoinTxIdClaimHandler_1 = require("./btc/BitcoinTxIdClaimHandler");
+const BitcoinOutputClaimHandler_1 = require("./btc/BitcoinOutputClaimHandler");
+const BitcoinNoncedOutputClaimHandler_1 = require("./btc/BitcoinNoncedOutputClaimHandler");
+exports.claimHandlersList = [
+    HashlockClaimHandler_1.HashlockClaimHandler,
+    BitcoinTxIdClaimHandler_1.BitcoinTxIdClaimHandler,
+    BitcoinOutputClaimHandler_1.BitcoinOutputClaimHandler,
+    BitcoinNoncedOutputClaimHandler_1.BitcoinNoncedOutputClaimHandler
+];

package/dist/evm/swaps/handlers/claim/HashlockClaimHandler.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChainSwapType } from "@atomiqlabs/base";
+import { Buffer } from "buffer";
+import { IClaimHandler } from "./ClaimHandlers";
+import { EVMSwapData } from "../../EVMSwapData";
+import { EVMTx } from "../../../chain/modules/EVMTransactions";
+export declare class HashlockClaimHandler implements IClaimHandler<Buffer, string> {
+    readonly address: string;
+    static readonly type: ChainSwapType;
+    static readonly gas: number;
+    constructor(address: string);
+    getCommitment(data: Buffer): string;
+    getWitness(signer: string, data: EVMSwapData, witnessData: string): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer;
+    }>;
+    getGas(): number;
+    getType(): ChainSwapType;
+}

package/dist/evm/swaps/handlers/claim/HashlockClaimHandler.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashlockClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const buffer_1 = require("buffer");
+const ethers_1 = require("ethers");
+const sha2_1 = require("@noble/hashes/sha2");
+class HashlockClaimHandler {
+    constructor(address) {
+        this.address = address;
+    }
+    getCommitment(data) {
+        if (data.length !== 32)
+            throw new Error("Invalid swap hash");
+        return (0, ethers_1.hexlify)(data);
+    }
+    getWitness(signer, data, witnessData) {
+        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_1.Buffer.from(witnessData, "hex");
+        if (buffer.length !== 32)
+            throw new Error("Invalid hash secret: buff length");
+        const witnessSha256 = buffer_1.Buffer.from((0, sha2_1.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() {
+        return HashlockClaimHandler.gas;
+    }
+    getType() {
+        return HashlockClaimHandler.type;
+    }
+}
+exports.HashlockClaimHandler = HashlockClaimHandler;
+HashlockClaimHandler.type = base_1.ChainSwapType.HTLC;
+HashlockClaimHandler.gas = 5000;

package/dist/evm/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChainSwapType } from "@atomiqlabs/base";
+import { BitcoinCommitmentData, IBitcoinClaimHandler } from "./IBitcoinClaimHandler";
+import { BitcoinOutputWitnessData } from "./BitcoinOutputClaimHandler";
+import { Buffer } from "buffer";
+import { EVMSwapData } from "../../../EVMSwapData";
+import { EVMTx } from "../../../../chain/modules/EVMTransactions";
+export type BitcoinNoncedOutputCommitmentData = {
+    output: Buffer;
+    amount: bigint;
+    nonce: bigint;
+};
+export declare class BitcoinNoncedOutputClaimHandler extends IBitcoinClaimHandler<BitcoinNoncedOutputCommitmentData, BitcoinOutputWitnessData> {
+    static readonly type: ChainSwapType;
+    static readonly gas: number;
+    protected serializeCommitment(data: BitcoinNoncedOutputCommitmentData & BitcoinCommitmentData): Buffer;
+    getWitness(signer: string, swapData: EVMSwapData, witnessData: BitcoinOutputWitnessData, feeRate?: string): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer;
+    }>;
+    getGas(data: EVMSwapData): number;
+    getType(): ChainSwapType;
+}

package/dist/evm/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinNoncedOutputClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const IBitcoinClaimHandler_1 = require("./IBitcoinClaimHandler");
+const btc_signer_1 = require("@scure/btc-signer");
+const buffer_1 = require("buffer");
+const ethers_1 = require("ethers");
+function getTransactionNonce(btcTx) {
+    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);
+}
+class BitcoinNoncedOutputClaimHandler extends IBitcoinClaimHandler_1.IBitcoinClaimHandler {
+    serializeCommitment(data) {
+        const txoHash = (0, ethers_1.solidityPackedKeccak256)(["uint64", "uint64", "bytes32"], [data.nonce, data.amount, (0, ethers_1.keccak256)(data.output)]);
+        return buffer_1.Buffer.concat([
+            buffer_1.Buffer.from(txoHash.substring(2), "hex"),
+            super.serializeCommitment(data)
+        ]);
+    }
+    async getWitness(signer, swapData, witnessData, feeRate) {
+        if (!swapData.isClaimHandler(this.address))
+            throw new Error("Invalid claim handler");
+        const txBuffer = buffer_1.Buffer.from(witnessData.tx.hex, "hex");
+        const parsedBtcTx = btc_signer_1.Transaction.fromRaw(txBuffer);
+        const out = parsedBtcTx.getOutput(witnessData.vout);
+        const { initialTxns, commitment, blockheader, merkleProof } = await this._getWitness(signer, swapData, witnessData, {
+            output: buffer_1.Buffer.from(out.script),
+            amount: out.amount,
+            nonce: getTransactionNonce(parsedBtcTx)
+        });
+        const voutAndTxData = buffer_1.Buffer.concat([
+            base_1.BigIntBufferUtils.toBuffer(BigInt(witnessData.vout), "be", 4),
+            base_1.BigIntBufferUtils.toBuffer(BigInt(txBuffer.length), "be", 32),
+            txBuffer
+        ]);
+        return {
+            initialTxns,
+            witness: buffer_1.Buffer.concat([
+                commitment,
+                blockheader,
+                voutAndTxData,
+                merkleProof
+            ])
+        };
+    }
+    getGas(data) {
+        return BitcoinNoncedOutputClaimHandler.gas;
+    }
+    getType() {
+        return BitcoinNoncedOutputClaimHandler.type;
+    }
+}
+exports.BitcoinNoncedOutputClaimHandler = BitcoinNoncedOutputClaimHandler;
+BitcoinNoncedOutputClaimHandler.type = base_1.ChainSwapType.CHAIN_NONCED;
+BitcoinNoncedOutputClaimHandler.gas = 40000;