@atomiqlabs/chain-starknet 4.0.0-dev.12 → 4.0.0-dev.13

package/src/starknet/swaps/StarknetSwapModule.ts

@@ -1,17 +1,17 @@
-import {StarknetSwapContract} from "./StarknetSwapContract";
-import {TypedContractV2} from "starknet";
-import {EscrowManagerAbi} from "./EscrowManagerAbi";
-import {StarknetChainInterface} from "../chain/StarknetChainInterface";
-import {StarknetContractModule} from "../contract/StarknetContractModule";
-
-export class StarknetSwapModule extends StarknetContractModule<typeof EscrowManagerAbi> {
-
-    readonly contract: StarknetSwapContract;
-    readonly swapContract: TypedContractV2<typeof EscrowManagerAbi>;
-
-    constructor(chainInterface: StarknetChainInterface, contract: StarknetSwapContract) {
-        super(chainInterface, contract);
-        this.swapContract = contract.contract;
-    }
-
-}
+import {StarknetSwapContract} from "./StarknetSwapContract";
+import {TypedContractV2} from "starknet";
+import {EscrowManagerAbi} from "./EscrowManagerAbi";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {StarknetContractModule} from "../contract/StarknetContractModule";
+
+export class StarknetSwapModule extends StarknetContractModule<typeof EscrowManagerAbi> {
+
+    readonly contract: StarknetSwapContract;
+    readonly swapContract: TypedContractV2<typeof EscrowManagerAbi>;
+
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetSwapContract) {
+        super(chainInterface, contract);
+        this.swapContract = contract.contract;
+    }
+
+}

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

@@ -1,20 +1,20 @@
-import {StarknetSwapData} from "../StarknetSwapData";
-import {BigNumberish} from "starknet";
-import {StarknetTx} from "../../chain/modules/StarknetTransactions";
-import {StarknetGas} from "../../chain/modules/StarknetFees";
-
-
-export interface IHandler<TCommitmentData, TWitnessData> {
-
-    readonly address: string;
-
-    getCommitment(data: TCommitmentData): BigNumberish;
-
-    getWitness(signer: string, data: StarknetSwapData, witnessData: TWitnessData, feeRate?: string): Promise<{
-        initialTxns: StarknetTx[],
-        witness: BigNumberish[]
-    }>;
-
-    getGas(data: StarknetSwapData): StarknetGas;
-
-}
+import {StarknetSwapData} from "../StarknetSwapData";
+import {BigNumberish} from "starknet";
+import {StarknetTx} from "../../chain/modules/StarknetTransactions";
+import {StarknetGas} from "../../chain/modules/StarknetFees";
+
+
+export interface IHandler<TCommitmentData, TWitnessData> {
+
+    readonly address: string;
+
+    getCommitment(data: TCommitmentData): BigNumberish;
+
+    getWitness(signer: string, data: StarknetSwapData, witnessData: TWitnessData, feeRate?: string): Promise<{
+        initialTxns: StarknetTx[],
+        witness: BigNumberish[]
+    }>;
+
+    getGas(data: StarknetSwapData): StarknetGas;
+
+}

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

@@ -1,23 +1,23 @@
-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";
-import {BigNumberish} from "starknet";
-import {StarknetGas} from "../../../chain/modules/StarknetFees";
-
-export interface IClaimHandler<C, W> extends IHandler<C, W> {
-    getType(): ChainSwapType;
-    parseWitnessResult(result: BigNumberish[]): string;
-}
-
-export type ClaimHandlerType = {gas: StarknetGas, 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";
+import {BigNumberish} from "starknet";
+import {StarknetGas} from "../../../chain/modules/StarknetFees";
+
+export interface IClaimHandler<C, W> extends IHandler<C, W> {
+    getType(): ChainSwapType;
+    parseWitnessResult(result: BigNumberish[]): string;
+}
+
+export type ClaimHandlerType = {gas: StarknetGas, type: ChainSwapType} & (new (address: string) => IClaimHandler<any, any>);
+
+export const claimHandlersList: ClaimHandlerType[] = [
+    HashlockClaimHandler,
+    BitcoinTxIdClaimHandler,
+    BitcoinOutputClaimHandler,
+    BitcoinNoncedOutputClaimHandler
+];
+

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

@@ -1,54 +1,54 @@
-import {StarknetSwapData} from "../../StarknetSwapData";
-import {bufferToU32Array, toHex, u32ArrayToBuffer} from "../../../../utils/Utils";
-import {BigNumberish, hash} from "starknet";
-import {ChainSwapType} from "@atomiqlabs/base";
-import {Buffer} from "buffer";
-import {sha256} from "@noble/hashes/sha2";
-import {StarknetTx} from "../../../chain/modules/StarknetTransactions";
-import {IClaimHandler} from "./ClaimHandlers";
-import {StarknetGas} from "../../../chain/modules/StarknetFees";
-
-export class HashlockClaimHandler implements IClaimHandler<Buffer, string> {
-
-    public readonly address: string;
-    public static readonly type: ChainSwapType = ChainSwapType.HTLC;
-    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 800*40_000, l1Gas: 0};
-
-    constructor(address: string) {
-        this.address = address;
-    }
-
-    getCommitment(data: Buffer): BigNumberish {
-        if(data.length!==32) throw new Error("Invalid swap hash");
-        return hash.computePoseidonHashOnElements(bufferToU32Array(data));
-    }
-
-    public getWitness(signer: string, data: StarknetSwapData, witnessData: string): Promise<{
-        initialTxns: StarknetTx[],
-        witness: BigNumberish[]
-    }> {
-        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(toHex(this.getCommitment(witnessSha256)))) throw new Error("Invalid hash secret: poseidon hash doesn't match");
-
-        const witnessArray = bufferToU32Array(buffer);
-        return Promise.resolve({initialTxns: [], witness: witnessArray});
-    }
-
-    getGas(): StarknetGas {
-        return HashlockClaimHandler.gas;
-    }
-
-    getType(): ChainSwapType {
-        return HashlockClaimHandler.type;
-    }
-
-    parseWitnessResult(result: BigNumberish[]): string {
-        return u32ArrayToBuffer(result).toString("hex");
-    }
-
+import {StarknetSwapData} from "../../StarknetSwapData";
+import {bufferToU32Array, toHex, u32ArrayToBuffer} from "../../../../utils/Utils";
+import {BigNumberish, hash} from "starknet";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {Buffer} from "buffer";
+import {sha256} from "@noble/hashes/sha2";
+import {StarknetTx} from "../../../chain/modules/StarknetTransactions";
+import {IClaimHandler} from "./ClaimHandlers";
+import {StarknetGas} from "../../../chain/modules/StarknetFees";
+
+export class HashlockClaimHandler implements IClaimHandler<Buffer, string> {
+
+    public readonly address: string;
+    public static readonly type: ChainSwapType = ChainSwapType.HTLC;
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 800*40_000, l1Gas: 0};
+
+    constructor(address: string) {
+        this.address = address;
+    }
+
+    getCommitment(data: Buffer): BigNumberish {
+        if(data.length!==32) throw new Error("Invalid swap hash");
+        return hash.computePoseidonHashOnElements(bufferToU32Array(data));
+    }
+
+    public getWitness(signer: string, data: StarknetSwapData, witnessData: string): Promise<{
+        initialTxns: StarknetTx[],
+        witness: BigNumberish[]
+    }> {
+        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(toHex(this.getCommitment(witnessSha256)))) throw new Error("Invalid hash secret: poseidon hash doesn't match");
+
+        const witnessArray = bufferToU32Array(buffer);
+        return Promise.resolve({initialTxns: [], witness: witnessArray});
+    }
+
+    getGas(): StarknetGas {
+        return HashlockClaimHandler.gas;
+    }
+
+    getType(): ChainSwapType {
+        return HashlockClaimHandler.type;
+    }
+
+    parseWitnessResult(result: BigNumberish[]): string {
+        return u32ArrayToBuffer(result).toString("hex");
+    }
+
 }

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

@@ -1,73 +1,73 @@
-import {StarknetSwapData} from "../../../StarknetSwapData";
-import {ChainSwapType} from "@atomiqlabs/base";
-import {BigNumberish, hash} from "starknet";
-import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
-import {bufferToByteArray, getLogger, poseidonHashRange, toBigInt} from "../../../../../utils/Utils";
-import {BitcoinCommitmentData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
-import {BitcoinOutputWitnessData} from "./BitcoinOutputClaimHandler";
-import {Transaction} from "@scure/btc-signer";
-import {Buffer} from "buffer";
-import {StarknetGas} from "../../../../chain/modules/StarknetFees";
-
-export type BitcoinNoncedOutputCommitmentData = {
-    output: Buffer,
-    amount: bigint,
-    nonce: bigint
-};
-
-const logger = getLogger("BitcoinNoncedOutputClaimHandler: ");
-
-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: StarknetGas = {l1DataGas: 0, l2Gas: 20_000*40_000, l1Gas: 0};
-
-    protected serializeCommitment(data: BitcoinNoncedOutputCommitmentData & BitcoinCommitmentData): BigNumberish[] {
-        return [
-            hash.computePoseidonHashOnElements([toBigInt(data.nonce), toBigInt(data.amount), poseidonHashRange(data.output)]),
-            ...super.serializeCommitment(data)
-        ];
-    }
-
-    async getWitness(
-        signer: string,
-        swapData: StarknetSwapData,
-        witnessData: BitcoinOutputWitnessData,
-        feeRate?: string
-    ): Promise<{
-        initialTxns: StarknetTx[];
-        witness: BigNumberish[]
-    }> {
-        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
-
-        const parsedBtcTx = Transaction.fromRaw(Buffer.from(witnessData.tx.hex, "hex"));
-        const out = parsedBtcTx.getOutput(witnessData.vout);
-
-        const {initialTxns, witness} = await this._getWitness(signer, swapData, witnessData, {
-            output: Buffer.from(out.script),
-            amount: out.amount,
-            nonce: getTransactionNonce(parsedBtcTx)
-        });
-
-        witness.push(...bufferToByteArray(Buffer.from(witnessData.tx.hex, "hex")));
-        witness.push(BigInt(witnessData.vout));
-
-        return {initialTxns, witness};
-    }
-
-    getGas(data: StarknetSwapData): StarknetGas {
-        return BitcoinNoncedOutputClaimHandler.gas;
-    }
-
-    getType(): ChainSwapType {
-        return BitcoinNoncedOutputClaimHandler.type;
-    }
-
-}
+import {StarknetSwapData} from "../../../StarknetSwapData";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {BigNumberish, hash} from "starknet";
+import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
+import {bufferToByteArray, getLogger, poseidonHashRange, toBigInt} from "../../../../../utils/Utils";
+import {BitcoinCommitmentData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
+import {BitcoinOutputWitnessData} from "./BitcoinOutputClaimHandler";
+import {Transaction} from "@scure/btc-signer";
+import {Buffer} from "buffer";
+import {StarknetGas} from "../../../../chain/modules/StarknetFees";
+
+export type BitcoinNoncedOutputCommitmentData = {
+    output: Buffer,
+    amount: bigint,
+    nonce: bigint
+};
+
+const logger = getLogger("BitcoinNoncedOutputClaimHandler: ");
+
+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: StarknetGas = {l1DataGas: 0, l2Gas: 20_000*40_000, l1Gas: 0};
+
+    protected serializeCommitment(data: BitcoinNoncedOutputCommitmentData & BitcoinCommitmentData): BigNumberish[] {
+        return [
+            hash.computePoseidonHashOnElements([toBigInt(data.nonce), toBigInt(data.amount), poseidonHashRange(data.output)]),
+            ...super.serializeCommitment(data)
+        ];
+    }
+
+    async getWitness(
+        signer: string,
+        swapData: StarknetSwapData,
+        witnessData: BitcoinOutputWitnessData,
+        feeRate?: string
+    ): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[]
+    }> {
+        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
+
+        const parsedBtcTx = Transaction.fromRaw(Buffer.from(witnessData.tx.hex, "hex"));
+        const out = parsedBtcTx.getOutput(witnessData.vout);
+
+        const {initialTxns, witness} = await this._getWitness(signer, swapData, witnessData, {
+            output: Buffer.from(out.script),
+            amount: out.amount,
+            nonce: getTransactionNonce(parsedBtcTx)
+        });
+
+        witness.push(...bufferToByteArray(Buffer.from(witnessData.tx.hex, "hex")));
+        witness.push(BigInt(witnessData.vout));
+
+        return {initialTxns, witness};
+    }
+
+    getGas(data: StarknetSwapData): StarknetGas {
+        return BitcoinNoncedOutputClaimHandler.gas;
+    }
+
+    getType(): ChainSwapType {
+        return BitcoinNoncedOutputClaimHandler.type;
+    }
+
+}

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

@@ -1,67 +1,67 @@
-import {StarknetSwapData} from "../../../StarknetSwapData";
-import {ChainSwapType} from "@atomiqlabs/base";
-import {BigNumberish, hash} from "starknet";
-import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
-import {bufferToByteArray, getLogger, poseidonHashRange, toBigInt} from "../../../../../utils/Utils";
-import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
-import {Transaction} from "@scure/btc-signer";
-import {Buffer} from "buffer";
-import {StarknetGas} from "../../../../chain/modules/StarknetFees";
-
-export type BitcoinOutputCommitmentData = {
-    output: Buffer,
-    amount: bigint
-};
-
-export type BitcoinOutputWitnessData = BitcoinWitnessData & {
-    vout: number
-};
-
-const logger = getLogger("BitcoinOutputClaimHandler: ");
-
-export class BitcoinOutputClaimHandler extends IBitcoinClaimHandler<BitcoinOutputCommitmentData, BitcoinOutputWitnessData> {
-
-    public static readonly type: ChainSwapType = ChainSwapType.CHAIN;
-    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
-
-    protected serializeCommitment(data: BitcoinOutputCommitmentData & BitcoinCommitmentData): BigNumberish[] {
-        return [
-            hash.computePoseidonHashOnElements([toBigInt(data.amount), poseidonHashRange(data.output)]),
-            ...super.serializeCommitment(data)
-        ];
-    }
-
-    async getWitness(
-        signer: string,
-        swapData: StarknetSwapData,
-        witnessData: BitcoinOutputWitnessData,
-        feeRate?: string
-    ): Promise<{
-        initialTxns: StarknetTx[];
-        witness: BigNumberish[]
-    }> {
-        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
-
-        const parsedBtcTx = Transaction.fromRaw(Buffer.from(witnessData.tx.hex, "hex"));
-        const out = parsedBtcTx.getOutput(witnessData.vout);
-
-        const {initialTxns, witness} = await this._getWitness(signer, swapData, witnessData, {
-            output: Buffer.from(out.script),
-            amount: out.amount
-        });
-
-        witness.push(...bufferToByteArray(Buffer.from(witnessData.tx.hex, "hex")));
-        witness.push(BigInt(witnessData.vout));
-
-        return {initialTxns, witness};
-    }
-
-    getGas(data: StarknetSwapData): StarknetGas {
-        return BitcoinOutputClaimHandler.gas;
-    }
-
-    getType(): ChainSwapType {
-        return BitcoinOutputClaimHandler.type;
-    }
-
-}
+import {StarknetSwapData} from "../../../StarknetSwapData";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {BigNumberish, hash} from "starknet";
+import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
+import {bufferToByteArray, getLogger, poseidonHashRange, toBigInt} from "../../../../../utils/Utils";
+import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
+import {Transaction} from "@scure/btc-signer";
+import {Buffer} from "buffer";
+import {StarknetGas} from "../../../../chain/modules/StarknetFees";
+
+export type BitcoinOutputCommitmentData = {
+    output: Buffer,
+    amount: bigint
+};
+
+export type BitcoinOutputWitnessData = BitcoinWitnessData & {
+    vout: number
+};
+
+const logger = getLogger("BitcoinOutputClaimHandler: ");
+
+export class BitcoinOutputClaimHandler extends IBitcoinClaimHandler<BitcoinOutputCommitmentData, BitcoinOutputWitnessData> {
+
+    public static readonly type: ChainSwapType = ChainSwapType.CHAIN;
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
+
+    protected serializeCommitment(data: BitcoinOutputCommitmentData & BitcoinCommitmentData): BigNumberish[] {
+        return [
+            hash.computePoseidonHashOnElements([toBigInt(data.amount), poseidonHashRange(data.output)]),
+            ...super.serializeCommitment(data)
+        ];
+    }
+
+    async getWitness(
+        signer: string,
+        swapData: StarknetSwapData,
+        witnessData: BitcoinOutputWitnessData,
+        feeRate?: string
+    ): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[]
+    }> {
+        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
+
+        const parsedBtcTx = Transaction.fromRaw(Buffer.from(witnessData.tx.hex, "hex"));
+        const out = parsedBtcTx.getOutput(witnessData.vout);
+
+        const {initialTxns, witness} = await this._getWitness(signer, swapData, witnessData, {
+            output: Buffer.from(out.script),
+            amount: out.amount
+        });
+
+        witness.push(...bufferToByteArray(Buffer.from(witnessData.tx.hex, "hex")));
+        witness.push(BigInt(witnessData.vout));
+
+        return {initialTxns, witness};
+    }
+
+    getGas(data: StarknetSwapData): StarknetGas {
+        return BitcoinOutputClaimHandler.gas;
+    }
+
+    getType(): ChainSwapType {
+        return BitcoinOutputClaimHandler.type;
+    }
+
+}

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

@@ -1,50 +1,50 @@
-import {StarknetSwapData} from "../../../StarknetSwapData";
-import {ChainSwapType} from "@atomiqlabs/base";
-import {BigNumberish} from "starknet";
-import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
-import {bufferToU32Array, getLogger} from "../../../../../utils/Utils";
-import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
-import {Buffer} from "buffer";
-import {StarknetGas} from "../../../../chain/modules/StarknetFees";
-
-export type BitcoinTxIdCommitmentData = {
-    txId: string
-};
-
-const logger = getLogger("BitcoinTxIdClaimHandler: ");
-
-export class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler<BitcoinTxIdCommitmentData, BitcoinWitnessData> {
-
-    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
-    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
-
-    protected serializeCommitment(data: BitcoinTxIdCommitmentData & BitcoinCommitmentData): BigNumberish[] {
-        return [
-            ...bufferToU32Array(Buffer.from(data.txId, "hex").reverse()),
-            ...super.serializeCommitment(data)
-        ];
-    }
-
-    getWitness(
-        signer: string,
-        swapData: StarknetSwapData,
-        witnessData: BitcoinWitnessData,
-        feeRate?: string
-    ): Promise<{
-        initialTxns: StarknetTx[];
-        witness: BigNumberish[]
-    }> {
-        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
-
-        return this._getWitness(signer, swapData, witnessData, {txId: witnessData.tx.txid});
-    }
-
-    getGas(data: StarknetSwapData): StarknetGas {
-        return BitcoinTxIdClaimHandler.gas;
-    }
-
-    getType(): ChainSwapType {
-        return BitcoinTxIdClaimHandler.type;
-    }
-
-}
+import {StarknetSwapData} from "../../../StarknetSwapData";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {BigNumberish} from "starknet";
+import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
+import {bufferToU32Array, getLogger} from "../../../../../utils/Utils";
+import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
+import {Buffer} from "buffer";
+import {StarknetGas} from "../../../../chain/modules/StarknetFees";
+
+export type BitcoinTxIdCommitmentData = {
+    txId: string
+};
+
+const logger = getLogger("BitcoinTxIdClaimHandler: ");
+
+export class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler<BitcoinTxIdCommitmentData, BitcoinWitnessData> {
+
+    public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
+
+    protected serializeCommitment(data: BitcoinTxIdCommitmentData & BitcoinCommitmentData): BigNumberish[] {
+        return [
+            ...bufferToU32Array(Buffer.from(data.txId, "hex").reverse()),
+            ...super.serializeCommitment(data)
+        ];
+    }
+
+    getWitness(
+        signer: string,
+        swapData: StarknetSwapData,
+        witnessData: BitcoinWitnessData,
+        feeRate?: string
+    ): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[]
+    }> {
+        if(!swapData.isClaimHandler(this.address)) throw new Error("Invalid claim handler");
+
+        return this._getWitness(signer, swapData, witnessData, {txId: witnessData.tx.txid});
+    }
+
+    getGas(data: StarknetSwapData): StarknetGas {
+        return BitcoinTxIdClaimHandler.gas;
+    }
+
+    getType(): ChainSwapType {
+        return BitcoinTxIdClaimHandler.type;
+    }
+
+}