@atomiqlabs/chain-starknet 1.0.0-beta.0

package/src/starknet/swaps/StarknetSwapData.ts

@@ -0,0 +1,441 @@
+import {SwapData, ChainSwapType} from "@atomiqlabs/base";
+import {TimelockRefundHandler} from "./handlers/refund/TimelockRefundHandler";
+import {BigNumberish, cairo, hash} from "starknet";
+import {toBigInt, toHex} from "../../utils/Utils";
+import {
+    StringToPrimitiveType
+} from "abi-wan-kanabi/dist/kanabi";
+import {EscrowManagerAbi} from "./EscrowManagerAbi";
+import {IClaimHandler} from "./handlers/claim/ClaimHandlers";
+
+const FLAG_PAY_OUT: bigint = 0x01n;
+const FLAG_PAY_IN: bigint = 0x02n;
+const FLAG_REPUTATION: bigint = 0x04n;
+
+export type StarknetSwapDataType = StringToPrimitiveType<typeof EscrowManagerAbi, "escrow_manager::structs::escrow::EscrowData">;
+
+type SerializedContractCall = {
+    address: string,
+    entrypoint: string,
+    calldata: string[]
+};
+
+function deserializeContractCalls(span: BigNumberish[]): SerializedContractCall[] {
+    const successActionsLen = Number(toBigInt(span.shift()));
+    const successActions: SerializedContractCall[] = [];
+    for(let i=0; i<successActionsLen; i++) {
+        const address = toHex(span.shift());
+        const entrypoint = toHex(span.shift());
+        const calldataLen = Number(toBigInt(span.shift()));
+        const calldata = span.splice(0, calldataLen).map(toHex);
+        successActions.push({
+            address,
+            entrypoint,
+            calldata
+        });
+    }
+    return successActions;
+}
+
+function serializeContractCalls(calls: SerializedContractCall[], span: BigNumberish[]): BigNumberish[] {
+    span.push(toHex(calls.length));
+    calls.forEach((call) => {
+        span.push(call.address);
+        span.push(call.entrypoint);
+        span.push(toHex(call.calldata.length));
+        span.push(...call.calldata);
+    });
+    return span;
+}
+
+export class StarknetSwapData extends SwapData {
+
+    static toFlags(value: number | bigint | string): {payOut: boolean, payIn: boolean, reputation: boolean, sequence: bigint} {
+        const val = toBigInt(value);
+        return {
+            sequence: val >> 64n,
+            payOut: (val & FLAG_PAY_OUT) === FLAG_PAY_OUT,
+            payIn: (val & FLAG_PAY_IN) === FLAG_PAY_IN,
+            reputation: (val & FLAG_REPUTATION) === FLAG_REPUTATION
+        }
+    }
+
+    private getFlags(): bigint {
+        return (this.sequence << 64n) +
+            (this.payOut ? FLAG_PAY_OUT : 0n) +
+            (this.payIn ? FLAG_PAY_IN : 0n) +
+            (this.reputation ? FLAG_REPUTATION : 0n);
+    }
+
+    offerer: string;
+    claimer: string;
+    token: string;
+
+    refundHandler: string;
+    claimHandler: string;
+
+    //Flags
+    payOut: boolean;
+    payIn: boolean;
+    reputation: boolean;
+    sequence: bigint;
+
+    claimData: string;
+    refundData: string;
+
+    amount: bigint;
+
+    feeToken: string;
+    securityDeposit: bigint;
+    claimerBounty: bigint;
+
+    successAction: SerializedContractCall[];
+
+    extraData: string;
+
+    kind: ChainSwapType;
+
+    constructor(
+        offerer: string,
+        claimer: string,
+        token: string,
+        refundHandler: string,
+        claimHandler: string,
+        payOut: boolean,
+        payIn: boolean,
+        reputation: boolean,
+        sequence: bigint,
+        claimData: string,
+        refundData: string,
+        amount: bigint,
+        feeToken: string,
+        securityDeposit: bigint,
+        claimerBounty: bigint,
+        kind: ChainSwapType,
+        extraData: string,
+        successAction: SerializedContractCall[]
+    );
+
+    constructor(data: any);
+
+    constructor(
+        offererOrData: string | any,
+        claimer?: string,
+        token?: string,
+        refundHandler?: string,
+        claimHandler?: string,
+        payOut?: boolean,
+        payIn?: boolean,
+        reputation?: boolean,
+        sequence?: bigint,
+        claimData?: string,
+        refundData?: string,
+        amount?: bigint,
+        feeToken?: string,
+        securityDeposit?: bigint,
+        claimerBounty?: bigint,
+        kind?: ChainSwapType,
+        extraData?: string,
+        successAction?: SerializedContractCall[]
+    ) {
+        super();
+        if(claimer!=null || token!=null || refundHandler!=null || claimHandler!=null ||
+            payOut!=null || payIn!=null || reputation!=null || sequence!=null || claimData!=null || refundData!=null ||
+            amount!=null || feeToken!=null || securityDeposit!=null || claimerBounty!=null) {
+            this.offerer = offererOrData;
+            this.claimer = claimer;
+            this.token = token;
+            this.refundHandler = refundHandler;
+            this.claimHandler = claimHandler;
+            this.payOut = payOut;
+            this.payIn = payIn;
+            this.reputation = reputation;
+            this.sequence = sequence;
+            this.claimData = claimData;
+            this.refundData = refundData;
+            this.amount = amount;
+            this.feeToken = feeToken;
+            this.securityDeposit = securityDeposit;
+            this.claimerBounty = claimerBounty;
+            this.kind = kind;
+            this.extraData = extraData;
+            this.successAction = successAction;
+        } else {
+            this.offerer = offererOrData.offerer;
+            this.claimer = offererOrData.claimer;
+            this.token = offererOrData.token;
+            this.refundHandler = offererOrData.refundHandler;
+            this.claimHandler = offererOrData.claimHandler;
+            this.payOut = offererOrData.payOut;
+            this.payIn = offererOrData.payIn;
+            this.reputation = offererOrData.reputation;
+            this.sequence = offererOrData.sequence==null ? null : BigInt(offererOrData.sequence);
+            this.claimData = offererOrData.claimData;
+            this.refundData = offererOrData.refundData;
+            this.amount = offererOrData.amount==null ? null : BigInt(offererOrData.amount);
+            this.feeToken = offererOrData.feeToken;
+            this.securityDeposit = offererOrData.securityDeposit==null ? null : BigInt(offererOrData.securityDeposit);
+            this.claimerBounty = offererOrData.claimerBounty==null ? null : BigInt(offererOrData.claimerBounty);
+            this.kind = offererOrData.kind;
+            this.extraData = offererOrData.extraData;
+            this.successAction = offererOrData.successAction;
+        }
+        //For now we disallow usage of success actions
+        if(this.successAction.length>0) throw new Error("Success actions are not supported yet!");
+    }
+
+    getOfferer(): string {
+        return this.offerer;
+    }
+
+    setOfferer(newOfferer: string) {
+        this.offerer = newOfferer;
+        this.payIn = true;
+    }
+
+    getClaimer(): string {
+        return this.claimer;
+    }
+
+    setClaimer(newClaimer: string) {
+        this.claimer = newClaimer;
+        this.payIn = false;
+        this.payOut = true;
+        this.reputation = false;
+    }
+
+    serialize(): any {
+        return {
+            type: "strk",
+            offerer: this.offerer,
+            claimer: this.claimer,
+            token: this.token,
+            refundHandler: this.refundHandler,
+            claimHandler: this.claimHandler,
+            payOut: this.payOut,
+            payIn: this.payIn,
+            reputation: this.reputation,
+            sequence: this.sequence==null ? null : this.sequence.toString(10),
+            claimData: this.claimData,
+            refundData: this.refundData,
+            amount: this.amount==null ? null : this.amount.toString(10),
+            feeToken: this.feeToken,
+            securityDeposit: this.securityDeposit==null ? null : this.securityDeposit.toString(10),
+            claimerBounty: this.claimerBounty==null ? null : this.claimerBounty.toString(10),
+            kind: this.kind,
+            extraData: this.extraData,
+            successAction: this.successAction
+        }
+    }
+
+    getAmount(): bigint {
+        return this.amount;
+    }
+
+    getToken(): string {
+        return this.token;
+    }
+
+    isToken(token: string): boolean {
+        return this.token.toLowerCase()===token.toLowerCase();
+    }
+
+    getType(): ChainSwapType {
+        return this.kind;
+    }
+
+    getExpiry(): bigint {
+        return TimelockRefundHandler.getExpiry(this);
+    }
+
+    isPayIn(): boolean {
+        return this.payIn;
+    }
+
+    isPayOut(): boolean {
+        return this.payOut;
+    }
+
+    getEscrowHash(): string {
+        const amountValue = cairo.uint256("0x"+this.amount.toString(16));
+        const securityDepositValue = cairo.uint256("0x"+this.securityDeposit.toString(16));
+        const claimerBountyValue = cairo.uint256("0x"+this.claimerBounty.toString(16));
+        let escrowHash = hash.computePoseidonHashOnElements([
+            this.offerer,
+            this.claimer,
+            this.token,
+            this.refundHandler,
+            this.claimHandler,
+            this.getFlags(),
+            this.claimData,
+            this.refundData,
+            amountValue.low,
+            amountValue.high,
+            this.feeToken,
+            securityDepositValue.low,
+            securityDepositValue.high,
+            claimerBountyValue.low,
+            claimerBountyValue.high,
+            ...serializeContractCalls(this.successAction, []).slice(1) //Remove length prefix
+        ]);
+        if(escrowHash.startsWith("0x")) escrowHash = escrowHash.slice(2);
+        return escrowHash.padStart(64, "0");
+    }
+
+    getClaimHash(): string {
+        let hash = this.claimData;
+        if(hash.startsWith("0x")) hash = hash.slice(2);
+        return hash.padStart(64, "0");
+    }
+
+    getSequence(): bigint {
+        return this.sequence;
+    }
+
+    getConfirmationsHint(): number {
+        if(this.extraData==null) return null;
+        if(this.extraData.length!=84) return null;
+        return parseInt(this.extraData.slice(80), 16);
+    }
+
+    getNonceHint(): bigint {
+        if(this.extraData==null) return null;
+        if(this.extraData.length!=84) return null;
+        return BigInt("0x"+this.extraData.slice(64, 80));
+    }
+
+    getTxoHashHint(): string {
+        if(this.extraData==null) return null;
+        if(this.extraData.length!=84) return null;
+        return this.extraData.slice(0, 64);
+    }
+
+    getExtraData(): string {
+        return this.extraData;
+    }
+
+    setExtraData(extraData: string): void {
+        this.extraData = extraData;
+    }
+
+    getSecurityDeposit() {
+        return this.securityDeposit;
+    }
+
+    getClaimerBounty() {
+        return this.claimerBounty;
+    }
+
+    getTotalDeposit() {
+        return this.claimerBounty < this.securityDeposit ? this.securityDeposit : this.claimerBounty;
+    }
+
+    getDepositToken() {
+        return this.feeToken;
+    }
+
+    isDepositToken(token: string): boolean {
+        if(!token.startsWith("0x")) token = "0x"+token;
+        return toHex(this.feeToken)===toHex(token);
+    }
+
+    isClaimer(address: string) {
+        if(!address.startsWith("0x")) address = "0x"+address;
+        return toHex(this.claimer)===toHex(address);
+    }
+
+    isOfferer(address: string) {
+        if(!address.startsWith("0x")) address = "0x"+address;
+        return toHex(this.offerer)===toHex(address);
+    }
+
+    isRefundHandler(address: string): boolean {
+        if(!address.startsWith("0x")) address = "0x"+address;
+        return toHex(this.refundHandler)===toHex(address);
+    }
+
+    isClaimHandler(address: string): boolean {
+        if(!address.startsWith("0x")) address = "0x"+address;
+        return toHex(this.claimHandler)===toHex(address);
+    }
+
+    isClaimData(data: string): boolean {
+        if(!data.startsWith("0x")) data = "0x"+data;
+        return toHex(this.claimData)===toHex(data);
+    }
+
+    equals(other: StarknetSwapData): boolean {
+        return other.offerer.toLowerCase()===this.offerer.toLowerCase() &&
+            other.claimer.toLowerCase()===this.claimer.toLowerCase() &&
+            other.token.toLowerCase()===this.token.toLowerCase() &&
+            other.refundHandler.toLowerCase()===this.refundHandler.toLowerCase() &&
+            other.claimHandler.toLowerCase()===this.claimHandler.toLowerCase() &&
+            other.payIn===this.payIn &&
+            other.payOut===this.payOut &&
+            other.reputation===this.reputation &&
+            this.sequence === other.sequence &&
+            other.claimData.toLowerCase()===this.claimData.toLowerCase() &&
+            other.refundData.toLowerCase()===this.refundData.toLowerCase() &&
+            other.amount === this.amount &&
+            other.securityDeposit === this.securityDeposit &&
+            other.claimerBounty === this.claimerBounty
+    }
+
+    toEscrowStruct(): StarknetSwapDataType {
+        return {
+            offerer: this.offerer,
+            claimer: this.claimer,
+            token: this.token,
+            refund_handler: this.refundHandler,
+            claim_handler: this.claimHandler,
+            flags: this.getFlags(),
+            claim_data: this.claimData,
+            refund_data: this.refundData,
+            amount: cairo.uint256(toBigInt(this.amount)),
+            fee_token: this.feeToken,
+            security_deposit: cairo.uint256(toBigInt(this.securityDeposit)),
+            claimer_bounty: cairo.uint256(toBigInt(this.claimerBounty)),
+            success_action: this.successAction
+        }
+    }
+
+    static fromSerializedFeltArray(span: BigNumberish[], claimHandlerImpl: IClaimHandler<any, any>) {
+        const offerer = toHex(span.shift());
+        const claimer = toHex(span.shift());
+        const token = toHex(span.shift());
+        const refundHandler = toHex(span.shift());
+        const claimHandler = toHex(span.shift());
+        const {payOut, payIn, reputation, sequence} = StarknetSwapData.toFlags(span.shift());
+        const claimData = toHex(span.shift());
+        const refundData = toHex(span.shift());
+        const amount = toBigInt({low: span.shift(), high: span.shift()});
+        const feeToken = toHex(span.shift());
+        const securityDeposit = toBigInt({low: span.shift(), high: span.shift()});
+        const claimerBounty = toBigInt({low: span.shift(), high: span.shift()});
+        const successActions: SerializedContractCall[] = deserializeContractCalls(span)
+
+        return new StarknetSwapData(
+            offerer,
+            claimer,
+            token,
+            refundHandler,
+            claimHandler,
+            payOut,
+            payIn,
+            reputation,
+            sequence,
+            claimData,
+            refundData,
+            amount,
+            feeToken,
+            securityDeposit,
+            claimerBounty,
+            claimHandlerImpl.getType(),
+            null,
+            successActions
+        );
+    }
+
+}
+
+SwapData.deserializers["strk"] = StarknetSwapData;

package/src/starknet/swaps/StarknetSwapModule.ts

@@ -0,0 +1,17 @@
+import {StarknetModule} from "../base/StarknetModule";
+import {StarknetSwapContract} from "./StarknetSwapContract";
+import {TypedContractV2} from "starknet";
+import {EscrowManagerAbi} from "./EscrowManagerAbi";
+
+export class StarknetSwapModule extends StarknetModule {
+
+    readonly root: StarknetSwapContract;
+    readonly contract: TypedContractV2<typeof EscrowManagerAbi>;
+
+    constructor(root: StarknetSwapContract) {
+        super(root);
+        this.root = root;
+        this.contract = root.contract;
+    }
+
+}

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

@@ -0,0 +1,20 @@
+import {StarknetSwapData} from "../StarknetSwapData";
+import {BigNumberish} from "starknet";
+import {StarknetGas} from "../../base/StarknetAction";
+import {StarknetTx} from "../../base/modules/StarknetTransactions";
+
+
+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

@@ -0,0 +1,23 @@
+import {HashlockClaimHandler} from "./HashlockClaimHandler";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {StarknetGas} from "../../../base/StarknetAction";
+import {IHandler} from "../IHandler";
+import {BitcoinTxIdClaimHandler} from "./btc/BitcoinTxIdClaimHandler";
+import {BitcoinOutputClaimHandler} from "./btc/BitcoinOutputClaimHandler";
+import {BitcoinNoncedOutputClaimHandler} from "./btc/BitcoinNoncedOutputClaimHandler";
+import {BigNumberish} from "starknet";
+
+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

@@ -0,0 +1,54 @@
+import {StarknetSwapData} from "../../StarknetSwapData";
+import {bufferToU32Array, toHex, u32ArrayToBuffer} from "../../../../utils/Utils";
+import {BigNumberish, hash} from "starknet";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {StarknetGas} from "../../../base/StarknetAction";
+import {Buffer} from "buffer";
+import * as createHash from "create-hash";
+import {StarknetTx} from "../../../base/modules/StarknetTransactions";
+import {IClaimHandler} from "./ClaimHandlers";
+
+export class HashlockClaimHandler implements IClaimHandler<Buffer, string> {
+
+    public readonly address: string;
+    public static readonly type: ChainSwapType = ChainSwapType.HTLC;
+    public static readonly gas: StarknetGas = {l1: 750};
+
+    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 = createHash("sha256").update(buffer).digest()
+        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

@@ -0,0 +1,73 @@
+import {StarknetSwapData} from "../../../StarknetSwapData";
+import {StarknetGas} from "../../../../base/StarknetAction";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {BigNumberish, hash} from "starknet";
+import {StarknetTx} from "../../../../base/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";
+
+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 = {l1: 20000};
+
+    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

@@ -0,0 +1,67 @@
+import {StarknetSwapData} from "../../../StarknetSwapData";
+import {StarknetGas} from "../../../../base/StarknetAction";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {BigNumberish, hash} from "starknet";
+import {StarknetTx} from "../../../../base/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";
+
+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 = {l1: 20000};
+
+    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;
+    }
+
+}