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

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

@@ -1,30 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitcoinTxIdClaimHandler = void 0;
-const base_1 = require("@atomiqlabs/base");
-const Utils_1 = require("../../../../../utils/Utils");
-const IBitcoinClaimHandler_1 = require("./IBitcoinClaimHandler");
-const buffer_1 = require("buffer");
-const logger = (0, Utils_1.getLogger)("BitcoinTxIdClaimHandler: ");
-class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler_1.IBitcoinClaimHandler {
-    serializeCommitment(data) {
-        return [
-            ...(0, Utils_1.bufferToU32Array)(buffer_1.Buffer.from(data.txId, "hex").reverse()),
-            ...super.serializeCommitment(data)
-        ];
-    }
-    getWitness(signer, swapData, witnessData, feeRate) {
-        if (!swapData.isClaimHandler(this.address))
-            throw new Error("Invalid claim handler");
-        return this._getWitness(signer, swapData, witnessData, { txId: witnessData.tx.txid });
-    }
-    getGas(data) {
-        return BitcoinTxIdClaimHandler.gas;
-    }
-    getType() {
-        return BitcoinTxIdClaimHandler.type;
-    }
-}
-exports.BitcoinTxIdClaimHandler = BitcoinTxIdClaimHandler;
-BitcoinTxIdClaimHandler.type = base_1.ChainSwapType.CHAIN_TXID;
-BitcoinTxIdClaimHandler.gas = { l1DataGas: 0, l2Gas: 20000 * 40000, l1Gas: 0 };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinTxIdClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../../../../../utils/Utils");
+const IBitcoinClaimHandler_1 = require("./IBitcoinClaimHandler");
+const buffer_1 = require("buffer");
+const logger = (0, Utils_1.getLogger)("BitcoinTxIdClaimHandler: ");
+class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler_1.IBitcoinClaimHandler {
+    serializeCommitment(data) {
+        return [
+            ...(0, Utils_1.bufferToU32Array)(buffer_1.Buffer.from(data.txId, "hex").reverse()),
+            ...super.serializeCommitment(data)
+        ];
+    }
+    getWitness(signer, swapData, witnessData, feeRate) {
+        if (!swapData.isClaimHandler(this.address))
+            throw new Error("Invalid claim handler");
+        return this._getWitness(signer, swapData, witnessData, { txId: witnessData.tx.txid });
+    }
+    getGas(data) {
+        return BitcoinTxIdClaimHandler.gas;
+    }
+    getType() {
+        return BitcoinTxIdClaimHandler.type;
+    }
+}
+exports.BitcoinTxIdClaimHandler = BitcoinTxIdClaimHandler;
+BitcoinTxIdClaimHandler.type = base_1.ChainSwapType.CHAIN_TXID;
+BitcoinTxIdClaimHandler.gas = { l1DataGas: 0, l2Gas: 20000 * 40000, l1Gas: 0 };

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

@@ -1,45 +1,45 @@
-import { IClaimHandler } from "../ClaimHandlers";
-import { StarknetSwapData } from "../../../StarknetSwapData";
-import { ChainSwapType, RelaySynchronizer } from "@atomiqlabs/base";
-import { BigNumberish } from "starknet";
-import { StarknetBtcStoredHeader } from "../../../../btcrelay/headers/StarknetBtcStoredHeader";
-import { StarknetTx } from "../../../../chain/modules/StarknetTransactions";
-import { StarknetBtcRelay } from "../../../../btcrelay/StarknetBtcRelay";
-import { StarknetGas } from "../../../../chain/modules/StarknetFees";
-export type BitcoinCommitmentData = {
-    btcRelay: StarknetBtcRelay<any>;
-    confirmations: number;
-};
-export type BitcoinWitnessData = {
-    tx: {
-        blockhash: string;
-        confirmations: number;
-        txid: string;
-        hex: string;
-        height: number;
-    };
-    requiredConfirmations: number;
-    commitedHeader?: StarknetBtcStoredHeader;
-    btcRelay?: StarknetBtcRelay<any>;
-    synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>;
-};
-export declare abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> implements IClaimHandler<C & BitcoinCommitmentData, W> {
-    readonly address: string;
-    constructor(address: string);
-    static readonly address = "";
-    static readonly type: ChainSwapType;
-    static readonly gas: StarknetGas;
-    protected serializeCommitment(data: BitcoinCommitmentData): BigNumberish[];
-    getCommitment(data: C & BitcoinCommitmentData): BigNumberish;
-    protected _getWitness(signer: string, swapData: StarknetSwapData, { tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations }: BitcoinWitnessData, commitment: C, feeRate?: string): Promise<{
-        initialTxns: StarknetTx[];
-        witness: BigNumberish[];
-    }>;
-    abstract getWitness(signer: string, data: StarknetSwapData, witnessData: W, feeRate?: string): Promise<{
-        initialTxns: StarknetTx[];
-        witness: BigNumberish[];
-    }>;
-    abstract getGas(data: StarknetSwapData): StarknetGas;
-    abstract getType(): ChainSwapType;
-    parseWitnessResult(result: BigNumberish[]): string;
-}
+import { IClaimHandler } from "../ClaimHandlers";
+import { StarknetSwapData } from "../../../StarknetSwapData";
+import { ChainSwapType, RelaySynchronizer } from "@atomiqlabs/base";
+import { BigNumberish } from "starknet";
+import { StarknetBtcStoredHeader } from "../../../../btcrelay/headers/StarknetBtcStoredHeader";
+import { StarknetTx } from "../../../../chain/modules/StarknetTransactions";
+import { StarknetBtcRelay } from "../../../../btcrelay/StarknetBtcRelay";
+import { StarknetGas } from "../../../../chain/modules/StarknetFees";
+export type BitcoinCommitmentData = {
+    btcRelay: StarknetBtcRelay<any>;
+    confirmations: number;
+};
+export type BitcoinWitnessData = {
+    tx: {
+        blockhash: string;
+        confirmations: number;
+        txid: string;
+        hex: string;
+        height: number;
+    };
+    requiredConfirmations: number;
+    commitedHeader?: StarknetBtcStoredHeader;
+    btcRelay?: StarknetBtcRelay<any>;
+    synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>;
+};
+export declare abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> implements IClaimHandler<C & BitcoinCommitmentData, W> {
+    readonly address: string;
+    constructor(address: string);
+    static readonly address = "";
+    static readonly type: ChainSwapType;
+    static readonly gas: StarknetGas;
+    protected serializeCommitment(data: BitcoinCommitmentData): BigNumberish[];
+    getCommitment(data: C & BitcoinCommitmentData): BigNumberish;
+    protected _getWitness(signer: string, swapData: StarknetSwapData, { tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations }: BitcoinWitnessData, commitment: C, feeRate?: string): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[];
+    }>;
+    abstract getWitness(signer: string, data: StarknetSwapData, witnessData: W, feeRate?: string): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[];
+    }>;
+    abstract getGas(data: StarknetSwapData): StarknetGas;
+    abstract getType(): ChainSwapType;
+    parseWitnessResult(result: BigNumberish[]): string;
+}

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

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IBitcoinClaimHandler = void 0;
-const base_1 = require("@atomiqlabs/base");
-const starknet_1 = require("starknet");
-const StarknetBtcRelay_1 = require("../../../../btcrelay/StarknetBtcRelay");
-const Utils_1 = require("../../../../../utils/Utils");
-const logger = (0, Utils_1.getLogger)("IBitcoinClaimHandler: ");
-class IBitcoinClaimHandler {
-    constructor(address) {
-        this.address = address;
-    }
-    serializeCommitment(data) {
-        return [
-            data.confirmations,
-            data.btcRelay.contract.address
-        ];
-    }
-    getCommitment(data) {
-        return starknet_1.hash.computePoseidonHashOnElements(this.serializeCommitment(data));
-    }
-    async _getWitness(signer, swapData, { tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations }, commitment, feeRate) {
-        const serializedData = this.serializeCommitment({
-            ...commitment,
-            btcRelay,
-            confirmations: requiredConfirmations
-        });
-        const commitmentHash = starknet_1.hash.computePoseidonHashOnElements(serializedData);
-        if (!swapData.isClaimData(commitmentHash))
-            throw new Error("Invalid commit data");
-        const merkleProof = await btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
-        logger.debug("getWitness(): merkle proof computed: ", merkleProof);
-        const txs = [];
-        if (commitedHeader == null) {
-            const headers = await StarknetBtcRelay_1.StarknetBtcRelay.getCommitedHeadersAndSynchronize(signer, btcRelay, [{ blockheight: tx.height, requiredConfirmations, blockhash: tx.blockhash }], txs, synchronizer, feeRate);
-            if (headers == null)
-                throw new Error("Cannot fetch committed header!");
-            commitedHeader = headers[tx.blockhash];
-        }
-        serializedData.push(...commitedHeader.serialize());
-        serializedData.push(merkleProof.merkle.length, ...merkleProof.merkle.map(Utils_1.bufferToU32Array).flat());
-        serializedData.push(merkleProof.pos);
-        return { initialTxns: txs, witness: serializedData };
-    }
-    parseWitnessResult(result) {
-        return (0, Utils_1.u32ArrayToBuffer)(result).toString("hex");
-    }
-}
-exports.IBitcoinClaimHandler = IBitcoinClaimHandler;
-IBitcoinClaimHandler.address = "";
-IBitcoinClaimHandler.type = base_1.ChainSwapType.CHAIN_TXID;
-IBitcoinClaimHandler.gas = { l1DataGas: 0, l2Gas: 20000 * 40000, l1Gas: 0 };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IBitcoinClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const starknet_1 = require("starknet");
+const StarknetBtcRelay_1 = require("../../../../btcrelay/StarknetBtcRelay");
+const Utils_1 = require("../../../../../utils/Utils");
+const logger = (0, Utils_1.getLogger)("IBitcoinClaimHandler: ");
+class IBitcoinClaimHandler {
+    constructor(address) {
+        this.address = address;
+    }
+    serializeCommitment(data) {
+        return [
+            data.confirmations,
+            data.btcRelay.contract.address
+        ];
+    }
+    getCommitment(data) {
+        return starknet_1.hash.computePoseidonHashOnElements(this.serializeCommitment(data));
+    }
+    async _getWitness(signer, swapData, { tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations }, commitment, feeRate) {
+        const serializedData = this.serializeCommitment({
+            ...commitment,
+            btcRelay,
+            confirmations: requiredConfirmations
+        });
+        const commitmentHash = starknet_1.hash.computePoseidonHashOnElements(serializedData);
+        if (!swapData.isClaimData(commitmentHash))
+            throw new Error("Invalid commit data");
+        const merkleProof = await btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
+        logger.debug("getWitness(): merkle proof computed: ", merkleProof);
+        const txs = [];
+        if (commitedHeader == null) {
+            const headers = await StarknetBtcRelay_1.StarknetBtcRelay.getCommitedHeadersAndSynchronize(signer, btcRelay, [{ blockheight: tx.height, requiredConfirmations, blockhash: tx.blockhash }], txs, synchronizer, feeRate);
+            if (headers == null)
+                throw new Error("Cannot fetch committed header!");
+            commitedHeader = headers[tx.blockhash];
+        }
+        serializedData.push(...commitedHeader.serialize());
+        serializedData.push(merkleProof.merkle.length, ...merkleProof.merkle.map(Utils_1.bufferToU32Array).flat());
+        serializedData.push(merkleProof.pos);
+        return { initialTxns: txs, witness: serializedData };
+    }
+    parseWitnessResult(result) {
+        return (0, Utils_1.u32ArrayToBuffer)(result).toString("hex");
+    }
+}
+exports.IBitcoinClaimHandler = IBitcoinClaimHandler;
+IBitcoinClaimHandler.address = "";
+IBitcoinClaimHandler.type = base_1.ChainSwapType.CHAIN_TXID;
+IBitcoinClaimHandler.gas = { l1DataGas: 0, l2Gas: 20000 * 40000, l1Gas: 0 };

package/dist/starknet/swaps/handlers/refund/TimelockRefundHandler.d.ts

@@ -1,17 +1,17 @@
-import { StarknetTx } from "../../../chain/modules/StarknetTransactions";
-import { StarknetSwapData } from "../../StarknetSwapData";
-import { BigNumberish } from "starknet";
-import { IHandler } from "../IHandler";
-import { StarknetGas } from "../../../chain/modules/StarknetFees";
-export declare class TimelockRefundHandler implements IHandler<bigint, never> {
-    readonly address: string;
-    static readonly gas: StarknetGas;
-    constructor(address: string);
-    getCommitment(data: bigint): BigNumberish;
-    getWitness(signer: string, data: StarknetSwapData): Promise<{
-        initialTxns: StarknetTx[];
-        witness: BigNumberish[];
-    }>;
-    getGas(): StarknetGas;
-    static getExpiry(data: StarknetSwapData): bigint;
-}
+import { StarknetTx } from "../../../chain/modules/StarknetTransactions";
+import { StarknetSwapData } from "../../StarknetSwapData";
+import { BigNumberish } from "starknet";
+import { IHandler } from "../IHandler";
+import { StarknetGas } from "../../../chain/modules/StarknetFees";
+export declare class TimelockRefundHandler implements IHandler<bigint, never> {
+    readonly address: string;
+    static readonly gas: StarknetGas;
+    constructor(address: string);
+    getCommitment(data: bigint): BigNumberish;
+    getWitness(signer: string, data: StarknetSwapData): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[];
+    }>;
+    getGas(): StarknetGas;
+    static getExpiry(data: StarknetSwapData): bigint;
+}

package/dist/starknet/swaps/handlers/refund/TimelockRefundHandler.js

@@ -1,27 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimelockRefundHandler = void 0;
-const Utils_1 = require("../../../../utils/Utils");
-class TimelockRefundHandler {
-    constructor(address) {
-        this.address = address;
-    }
-    getCommitment(data) {
-        return data;
-    }
-    getWitness(signer, data) {
-        const expiry = TimelockRefundHandler.getExpiry(data);
-        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
-        if (expiry > currentTimestamp)
-            throw new Error("Not expired yet!");
-        return Promise.resolve({ initialTxns: [], witness: [] });
-    }
-    getGas() {
-        return TimelockRefundHandler.gas;
-    }
-    static getExpiry(data) {
-        return (0, Utils_1.bigNumberishToBuffer)(data.refundData, 32).readBigUInt64BE(24).valueOf();
-    }
-}
-exports.TimelockRefundHandler = TimelockRefundHandler;
-TimelockRefundHandler.gas = { l1DataGas: 0, l2Gas: 4000000, l1Gas: 0 };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelockRefundHandler = void 0;
+const Utils_1 = require("../../../../utils/Utils");
+class TimelockRefundHandler {
+    constructor(address) {
+        this.address = address;
+    }
+    getCommitment(data) {
+        return data;
+    }
+    getWitness(signer, data) {
+        const expiry = TimelockRefundHandler.getExpiry(data);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        if (expiry > currentTimestamp)
+            throw new Error("Not expired yet!");
+        return Promise.resolve({ initialTxns: [], witness: [] });
+    }
+    getGas() {
+        return TimelockRefundHandler.gas;
+    }
+    static getExpiry(data) {
+        return (0, Utils_1.bigNumberishToBuffer)(data.refundData, 32).readBigUInt64BE(24).valueOf();
+    }
+}
+exports.TimelockRefundHandler = TimelockRefundHandler;
+TimelockRefundHandler.gas = { l1DataGas: 0, l2Gas: 4000000, l1Gas: 0 };

package/dist/starknet/swaps/modules/StarknetLpVault.d.ts

@@ -1,69 +1,69 @@
-import { IntermediaryReputationType } from "@atomiqlabs/base";
-import { StarknetSwapModule } from "../StarknetSwapModule";
-import { StarknetTx } from "../../chain/modules/StarknetTransactions";
-export declare class StarknetLpVault extends StarknetSwapModule {
-    private static readonly GasCosts;
-    /**
-     * Action for withdrawing funds from the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @constructor
-     * @private
-     */
-    private Withdraw;
-    /**
-     * Action for depositing funds to the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @constructor
-     * @private
-     */
-    private Deposit;
-    /**
-     * Returns intermediary's reputation & vault balance for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    getIntermediaryData(address: string, token: string): Promise<{
-        balance: bigint;
-        reputation: IntermediaryReputationType;
-    }>;
-    /**
-     * Returns intermediary's reputation for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType>;
-    /**
-     * Returns the balance of the token an intermediary has in his LP vault
-     *
-     * @param address
-     * @param token
-     */
-    getIntermediaryBalance(address: string, token: string): Promise<bigint>;
-    /**
-     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
-     *  WSOL to SOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]>;
-    /**
-     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]>;
-}
+import { IntermediaryReputationType } from "@atomiqlabs/base";
+import { StarknetSwapModule } from "../StarknetSwapModule";
+import { StarknetTx } from "../../chain/modules/StarknetTransactions";
+export declare class StarknetLpVault extends StarknetSwapModule {
+    private static readonly GasCosts;
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Withdraw;
+    /**
+     * Action for depositing funds to the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Deposit;
+    /**
+     * Returns intermediary's reputation & vault balance for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryData(address: string, token: string): Promise<{
+        balance: bigint;
+        reputation: IntermediaryReputationType;
+    }>;
+    /**
+     * Returns intermediary's reputation for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType>;
+    /**
+     * Returns the balance of the token an intermediary has in his LP vault
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryBalance(address: string, token: string): Promise<bigint>;
+    /**
+     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
+     *  WSOL to SOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]>;
+    /**
+     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]>;
+}