@atomiqlabs/chain-starknet 1.0.0-beta.0

package/dist/starknet/swaps/StarknetSwapData.d.ts

@@ -0,0 +1,74 @@
+import { SwapData, ChainSwapType } from "@atomiqlabs/base";
+import { BigNumberish } from "starknet";
+import { StringToPrimitiveType } from "abi-wan-kanabi/dist/kanabi";
+import { EscrowManagerAbi } from "./EscrowManagerAbi";
+import { IClaimHandler } from "./handlers/claim/ClaimHandlers";
+export type StarknetSwapDataType = StringToPrimitiveType<typeof EscrowManagerAbi, "escrow_manager::structs::escrow::EscrowData">;
+type SerializedContractCall = {
+    address: string;
+    entrypoint: string;
+    calldata: string[];
+};
+export declare class StarknetSwapData extends SwapData {
+    static toFlags(value: number | bigint | string): {
+        payOut: boolean;
+        payIn: boolean;
+        reputation: boolean;
+        sequence: bigint;
+    };
+    private getFlags;
+    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;
+    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);
+    getOfferer(): string;
+    setOfferer(newOfferer: string): void;
+    getClaimer(): string;
+    setClaimer(newClaimer: string): void;
+    serialize(): any;
+    getAmount(): bigint;
+    getToken(): string;
+    isToken(token: string): boolean;
+    getType(): ChainSwapType;
+    getExpiry(): bigint;
+    isPayIn(): boolean;
+    isPayOut(): boolean;
+    getEscrowHash(): string;
+    getClaimHash(): string;
+    getSequence(): bigint;
+    getConfirmationsHint(): number;
+    getNonceHint(): bigint;
+    getTxoHashHint(): string;
+    getExtraData(): string;
+    setExtraData(extraData: string): void;
+    getSecurityDeposit(): bigint;
+    getClaimerBounty(): bigint;
+    getTotalDeposit(): bigint;
+    getDepositToken(): string;
+    isDepositToken(token: string): boolean;
+    isClaimer(address: string): boolean;
+    isOfferer(address: string): boolean;
+    isRefundHandler(address: string): boolean;
+    isClaimHandler(address: string): boolean;
+    isClaimData(data: string): boolean;
+    equals(other: StarknetSwapData): boolean;
+    toEscrowStruct(): StarknetSwapDataType;
+    static fromSerializedFeltArray(span: BigNumberish[], claimHandlerImpl: IClaimHandler<any, any>): StarknetSwapData;
+}
+export {};

package/dist/starknet/swaps/StarknetSwapData.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSwapData = void 0;
+const base_1 = require("@atomiqlabs/base");
+const TimelockRefundHandler_1 = require("./handlers/refund/TimelockRefundHandler");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../utils/Utils");
+const FLAG_PAY_OUT = 0x01n;
+const FLAG_PAY_IN = 0x02n;
+const FLAG_REPUTATION = 0x04n;
+function deserializeContractCalls(span) {
+    const successActionsLen = Number((0, Utils_1.toBigInt)(span.shift()));
+    const successActions = [];
+    for (let i = 0; i < successActionsLen; i++) {
+        const address = (0, Utils_1.toHex)(span.shift());
+        const entrypoint = (0, Utils_1.toHex)(span.shift());
+        const calldataLen = Number((0, Utils_1.toBigInt)(span.shift()));
+        const calldata = span.splice(0, calldataLen).map(Utils_1.toHex);
+        successActions.push({
+            address,
+            entrypoint,
+            calldata
+        });
+    }
+    return successActions;
+}
+function serializeContractCalls(calls, span) {
+    span.push((0, Utils_1.toHex)(calls.length));
+    calls.forEach((call) => {
+        span.push(call.address);
+        span.push(call.entrypoint);
+        span.push((0, Utils_1.toHex)(call.calldata.length));
+        span.push(...call.calldata);
+    });
+    return span;
+}
+class StarknetSwapData extends base_1.SwapData {
+    static toFlags(value) {
+        const val = (0, Utils_1.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
+        };
+    }
+    getFlags() {
+        return (this.sequence << 64n) +
+            (this.payOut ? FLAG_PAY_OUT : 0n) +
+            (this.payIn ? FLAG_PAY_IN : 0n) +
+            (this.reputation ? FLAG_REPUTATION : 0n);
+    }
+    constructor(offererOrData, claimer, token, refundHandler, claimHandler, payOut, payIn, reputation, sequence, claimData, refundData, amount, feeToken, securityDeposit, claimerBounty, kind, extraData, successAction) {
+        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() {
+        return this.offerer;
+    }
+    setOfferer(newOfferer) {
+        this.offerer = newOfferer;
+        this.payIn = true;
+    }
+    getClaimer() {
+        return this.claimer;
+    }
+    setClaimer(newClaimer) {
+        this.claimer = newClaimer;
+        this.payIn = false;
+        this.payOut = true;
+        this.reputation = false;
+    }
+    serialize() {
+        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() {
+        return this.amount;
+    }
+    getToken() {
+        return this.token;
+    }
+    isToken(token) {
+        return this.token.toLowerCase() === token.toLowerCase();
+    }
+    getType() {
+        return this.kind;
+    }
+    getExpiry() {
+        return TimelockRefundHandler_1.TimelockRefundHandler.getExpiry(this);
+    }
+    isPayIn() {
+        return this.payIn;
+    }
+    isPayOut() {
+        return this.payOut;
+    }
+    getEscrowHash() {
+        const amountValue = starknet_1.cairo.uint256("0x" + this.amount.toString(16));
+        const securityDepositValue = starknet_1.cairo.uint256("0x" + this.securityDeposit.toString(16));
+        const claimerBountyValue = starknet_1.cairo.uint256("0x" + this.claimerBounty.toString(16));
+        let escrowHash = starknet_1.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() {
+        let hash = this.claimData;
+        if (hash.startsWith("0x"))
+            hash = hash.slice(2);
+        return hash.padStart(64, "0");
+    }
+    getSequence() {
+        return this.sequence;
+    }
+    getConfirmationsHint() {
+        if (this.extraData == null)
+            return null;
+        if (this.extraData.length != 84)
+            return null;
+        return parseInt(this.extraData.slice(80), 16);
+    }
+    getNonceHint() {
+        if (this.extraData == null)
+            return null;
+        if (this.extraData.length != 84)
+            return null;
+        return BigInt("0x" + this.extraData.slice(64, 80));
+    }
+    getTxoHashHint() {
+        if (this.extraData == null)
+            return null;
+        if (this.extraData.length != 84)
+            return null;
+        return this.extraData.slice(0, 64);
+    }
+    getExtraData() {
+        return this.extraData;
+    }
+    setExtraData(extraData) {
+        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) {
+        if (!token.startsWith("0x"))
+            token = "0x" + token;
+        return (0, Utils_1.toHex)(this.feeToken) === (0, Utils_1.toHex)(token);
+    }
+    isClaimer(address) {
+        if (!address.startsWith("0x"))
+            address = "0x" + address;
+        return (0, Utils_1.toHex)(this.claimer) === (0, Utils_1.toHex)(address);
+    }
+    isOfferer(address) {
+        if (!address.startsWith("0x"))
+            address = "0x" + address;
+        return (0, Utils_1.toHex)(this.offerer) === (0, Utils_1.toHex)(address);
+    }
+    isRefundHandler(address) {
+        if (!address.startsWith("0x"))
+            address = "0x" + address;
+        return (0, Utils_1.toHex)(this.refundHandler) === (0, Utils_1.toHex)(address);
+    }
+    isClaimHandler(address) {
+        if (!address.startsWith("0x"))
+            address = "0x" + address;
+        return (0, Utils_1.toHex)(this.claimHandler) === (0, Utils_1.toHex)(address);
+    }
+    isClaimData(data) {
+        if (!data.startsWith("0x"))
+            data = "0x" + data;
+        return (0, Utils_1.toHex)(this.claimData) === (0, Utils_1.toHex)(data);
+    }
+    equals(other) {
+        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() {
+        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: starknet_1.cairo.uint256((0, Utils_1.toBigInt)(this.amount)),
+            fee_token: this.feeToken,
+            security_deposit: starknet_1.cairo.uint256((0, Utils_1.toBigInt)(this.securityDeposit)),
+            claimer_bounty: starknet_1.cairo.uint256((0, Utils_1.toBigInt)(this.claimerBounty)),
+            success_action: this.successAction
+        };
+    }
+    static fromSerializedFeltArray(span, claimHandlerImpl) {
+        const offerer = (0, Utils_1.toHex)(span.shift());
+        const claimer = (0, Utils_1.toHex)(span.shift());
+        const token = (0, Utils_1.toHex)(span.shift());
+        const refundHandler = (0, Utils_1.toHex)(span.shift());
+        const claimHandler = (0, Utils_1.toHex)(span.shift());
+        const { payOut, payIn, reputation, sequence } = StarknetSwapData.toFlags(span.shift());
+        const claimData = (0, Utils_1.toHex)(span.shift());
+        const refundData = (0, Utils_1.toHex)(span.shift());
+        const amount = (0, Utils_1.toBigInt)({ low: span.shift(), high: span.shift() });
+        const feeToken = (0, Utils_1.toHex)(span.shift());
+        const securityDeposit = (0, Utils_1.toBigInt)({ low: span.shift(), high: span.shift() });
+        const claimerBounty = (0, Utils_1.toBigInt)({ low: span.shift(), high: span.shift() });
+        const successActions = deserializeContractCalls(span);
+        return new StarknetSwapData(offerer, claimer, token, refundHandler, claimHandler, payOut, payIn, reputation, sequence, claimData, refundData, amount, feeToken, securityDeposit, claimerBounty, claimHandlerImpl.getType(), null, successActions);
+    }
+}
+exports.StarknetSwapData = StarknetSwapData;
+base_1.SwapData.deserializers["strk"] = StarknetSwapData;

package/dist/starknet/swaps/StarknetSwapModule.d.ts

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

package/dist/starknet/swaps/StarknetSwapModule.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSwapModule = void 0;
+const StarknetModule_1 = require("../base/StarknetModule");
+class StarknetSwapModule extends StarknetModule_1.StarknetModule {
+    constructor(root) {
+        super(root);
+        this.root = root;
+        this.contract = root.contract;
+    }
+}
+exports.StarknetSwapModule = StarknetSwapModule;

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

@@ -0,0 +1,13 @@
+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/dist/starknet/swaps/handlers/IHandler.js

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

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

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

package/dist/starknet/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/starknet/swaps/handlers/claim/HashlockClaimHandler.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { StarknetSwapData } from "../../StarknetSwapData";
+import { BigNumberish } from "starknet";
+import { ChainSwapType } from "@atomiqlabs/base";
+import { StarknetGas } from "../../../base/StarknetAction";
+import { Buffer } from "buffer";
+import { StarknetTx } from "../../../base/modules/StarknetTransactions";
+import { IClaimHandler } from "./ClaimHandlers";
+export declare class HashlockClaimHandler implements IClaimHandler<Buffer, string> {
+    readonly address: string;
+    static readonly type: ChainSwapType;
+    static readonly gas: StarknetGas;
+    constructor(address: string);
+    getCommitment(data: Buffer): BigNumberish;
+    getWitness(signer: string, data: StarknetSwapData, witnessData: string): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[];
+    }>;
+    getGas(): StarknetGas;
+    getType(): ChainSwapType;
+    parseWitnessResult(result: BigNumberish[]): string;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashlockClaimHandler = void 0;
+const Utils_1 = require("../../../../utils/Utils");
+const starknet_1 = require("starknet");
+const base_1 = require("@atomiqlabs/base");
+const buffer_1 = require("buffer");
+const createHash = require("create-hash");
+class HashlockClaimHandler {
+    constructor(address) {
+        this.address = address;
+    }
+    getCommitment(data) {
+        if (data.length !== 32)
+            throw new Error("Invalid swap hash");
+        return starknet_1.hash.computePoseidonHashOnElements((0, Utils_1.bufferToU32Array)(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 = createHash("sha256").update(buffer).digest();
+        if (!data.isClaimData((0, Utils_1.toHex)(this.getCommitment(witnessSha256))))
+            throw new Error("Invalid hash secret: poseidon hash doesn't match");
+        const witnessArray = (0, Utils_1.bufferToU32Array)(buffer);
+        return Promise.resolve({ initialTxns: [], witness: witnessArray });
+    }
+    getGas() {
+        return HashlockClaimHandler.gas;
+    }
+    getType() {
+        return HashlockClaimHandler.type;
+    }
+    parseWitnessResult(result) {
+        return (0, Utils_1.u32ArrayToBuffer)(result).toString("hex");
+    }
+}
+exports.HashlockClaimHandler = HashlockClaimHandler;
+HashlockClaimHandler.type = base_1.ChainSwapType.HTLC;
+HashlockClaimHandler.gas = { l1: 750 };

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

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

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinNoncedOutputClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../../../utils/Utils");
+const IBitcoinClaimHandler_1 = require("./IBitcoinClaimHandler");
+const btc_signer_1 = require("@scure/btc-signer");
+const buffer_1 = require("buffer");
+const logger = (0, Utils_1.getLogger)("BitcoinNoncedOutputClaimHandler: ");
+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) {
+        return [
+            starknet_1.hash.computePoseidonHashOnElements([(0, Utils_1.toBigInt)(data.nonce), (0, Utils_1.toBigInt)(data.amount), (0, Utils_1.poseidonHashRange)(data.output)]),
+            ...super.serializeCommitment(data)
+        ];
+    }
+    async getWitness(signer, swapData, witnessData, feeRate) {
+        if (!swapData.isClaimHandler(this.address))
+            throw new Error("Invalid claim handler");
+        const parsedBtcTx = btc_signer_1.Transaction.fromRaw(buffer_1.Buffer.from(witnessData.tx.hex, "hex"));
+        const out = parsedBtcTx.getOutput(witnessData.vout);
+        const { initialTxns, witness } = await this._getWitness(signer, swapData, witnessData, {
+            output: buffer_1.Buffer.from(out.script),
+            amount: out.amount,
+            nonce: getTransactionNonce(parsedBtcTx)
+        });
+        witness.push(...(0, Utils_1.bufferToByteArray)(buffer_1.Buffer.from(witnessData.tx.hex, "hex")));
+        witness.push(BigInt(witnessData.vout));
+        return { initialTxns, witness };
+    }
+    getGas(data) {
+        return BitcoinNoncedOutputClaimHandler.gas;
+    }
+    getType() {
+        return BitcoinNoncedOutputClaimHandler.type;
+    }
+}
+exports.BitcoinNoncedOutputClaimHandler = BitcoinNoncedOutputClaimHandler;
+BitcoinNoncedOutputClaimHandler.type = base_1.ChainSwapType.CHAIN_NONCED;
+BitcoinNoncedOutputClaimHandler.gas = { l1: 20000 };

package/dist/starknet/swaps/handlers/claim/btc/BitcoinOutputClaimHandler.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { StarknetSwapData } from "../../../StarknetSwapData";
+import { StarknetGas } from "../../../../base/StarknetAction";
+import { ChainSwapType } from "@atomiqlabs/base";
+import { BigNumberish } from "starknet";
+import { StarknetTx } from "../../../../base/modules/StarknetTransactions";
+import { BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler } from "./IBitcoinClaimHandler";
+import { Buffer } from "buffer";
+export type BitcoinOutputCommitmentData = {
+    output: Buffer;
+    amount: bigint;
+};
+export type BitcoinOutputWitnessData = BitcoinWitnessData & {
+    vout: number;
+};
+export declare class BitcoinOutputClaimHandler extends IBitcoinClaimHandler<BitcoinOutputCommitmentData, BitcoinOutputWitnessData> {
+    static readonly type: ChainSwapType;
+    static readonly gas: StarknetGas;
+    protected serializeCommitment(data: BitcoinOutputCommitmentData & BitcoinCommitmentData): BigNumberish[];
+    getWitness(signer: string, swapData: StarknetSwapData, witnessData: BitcoinOutputWitnessData, feeRate?: string): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[];
+    }>;
+    getGas(data: StarknetSwapData): StarknetGas;
+    getType(): ChainSwapType;
+}

package/dist/starknet/swaps/handlers/claim/btc/BitcoinOutputClaimHandler.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinOutputClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../../../utils/Utils");
+const IBitcoinClaimHandler_1 = require("./IBitcoinClaimHandler");
+const btc_signer_1 = require("@scure/btc-signer");
+const buffer_1 = require("buffer");
+const logger = (0, Utils_1.getLogger)("BitcoinOutputClaimHandler: ");
+class BitcoinOutputClaimHandler extends IBitcoinClaimHandler_1.IBitcoinClaimHandler {
+    serializeCommitment(data) {
+        return [
+            starknet_1.hash.computePoseidonHashOnElements([(0, Utils_1.toBigInt)(data.amount), (0, Utils_1.poseidonHashRange)(data.output)]),
+            ...super.serializeCommitment(data)
+        ];
+    }
+    async getWitness(signer, swapData, witnessData, feeRate) {
+        if (!swapData.isClaimHandler(this.address))
+            throw new Error("Invalid claim handler");
+        const parsedBtcTx = btc_signer_1.Transaction.fromRaw(buffer_1.Buffer.from(witnessData.tx.hex, "hex"));
+        const out = parsedBtcTx.getOutput(witnessData.vout);
+        const { initialTxns, witness } = await this._getWitness(signer, swapData, witnessData, {
+            output: buffer_1.Buffer.from(out.script),
+            amount: out.amount
+        });
+        witness.push(...(0, Utils_1.bufferToByteArray)(buffer_1.Buffer.from(witnessData.tx.hex, "hex")));
+        witness.push(BigInt(witnessData.vout));
+        return { initialTxns, witness };
+    }
+    getGas(data) {
+        return BitcoinOutputClaimHandler.gas;
+    }
+    getType() {
+        return BitcoinOutputClaimHandler.type;
+    }
+}
+exports.BitcoinOutputClaimHandler = BitcoinOutputClaimHandler;
+BitcoinOutputClaimHandler.type = base_1.ChainSwapType.CHAIN;
+BitcoinOutputClaimHandler.gas = { l1: 20000 };