@atomiqlabs/chain-starknet 8.0.13 → 8.1.10

package/dist/starknet/swaps/modules/StarknetSwapRefund.js

@@ -1,126 +1,126 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetSwapRefund = void 0;
-const base_1 = require("@atomiqlabs/base");
-const Utils_1 = require("../../../utils/Utils");
-const StarknetSwapModule_1 = require("../StarknetSwapModule");
-const StarknetAction_1 = require("../../chain/StarknetAction");
-const StarknetFees_1 = require("../../chain/modules/StarknetFees");
-const Refund = [
-    { name: 'Swap hash', type: 'felt' },
-    { name: 'Timeout', type: 'timestamp' }
-];
-class StarknetSwapRefund extends StarknetSwapModule_1.StarknetSwapModule {
-    /**
-     * Action for generic Refund instruction
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param handlerGas
-     * @private
-     */
-    Refund(signer, swapData, witness, handlerGas) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness), (0, StarknetFees_1.starknetGasAdd)(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas));
-    }
-    /**
-     * Action for cooperative refunding with signature
-     *
-     * @param sender
-     * @param swapData
-     * @param timeout
-     * @param signature
-     * @private
-     */
-    RefundWithSignature(sender, swapData, timeout, signature) {
-        return new StarknetAction_1.StarknetAction(sender, this.root, this.swapContract.populateTransaction.cooperative_refund(swapData.toEscrowStruct(), signature, BigInt(timeout)), swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND);
-    }
-    async signSwapRefund(signer, swapData, authorizationTimeout) {
-        const authPrefix = "refund";
-        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
-        const signature = await this.root.Signatures.signTypedMessage(signer, Refund, "Refund", {
-            "Swap hash": "0x" + swapData.getEscrowHash(),
-            "Timeout": (0, Utils_1.toHex)(authTimeout)
-        });
-        return {
-            prefix: authPrefix,
-            timeout: authTimeout.toString(10),
-            signature: signature
-        };
-    }
-    async isSignatureValid(swapData, timeout, prefix, signature) {
-        if (prefix !== "refund")
-            throw new base_1.SignatureVerificationError("Invalid prefix");
-        const expiryTimestamp = BigInt(timeout);
-        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
-        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.contract.authGracePeriod);
-        if (isExpired)
-            throw new base_1.SignatureVerificationError("Authorization expired!");
-        const valid = await this.root.Signatures.isValidSignature(signature, swapData.claimer, Refund, "Refund", {
-            "Swap hash": "0x" + swapData.getEscrowHash(),
-            "Timeout": (0, Utils_1.toHex)(expiryTimestamp)
-        });
-        if (!valid) {
-            throw new base_1.SignatureVerificationError("Invalid signature!");
-        }
-        return null;
-    }
-    /**
-     * Creates transactions required for refunding timed out swap
-     *
-     * @param signer
-     * @param swapData swap data to refund
-     * @param check whether to check if swap is already expired and refundable
-     * @param feeRate fee rate to be used for the transactions
-     * @param witnessData
-     */
-    async txsRefund(signer, swapData, check, feeRate, witnessData) {
-        const refundHandler = this.contract.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
-        if (refundHandler == null)
-            throw new Error("Invalid refund handler");
-        if (check && !await this.contract.isRequestRefundable(swapData.offerer.toString(), swapData)) {
-            throw new base_1.SwapDataVerificationError("Not refundable yet!");
-        }
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        const { initialTxns, witness } = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
-        const action = this.Refund(signer, swapData, witness, refundHandler.getGas(swapData));
-        await action.addToTxs(initialTxns, feeRate);
-        this.logger.debug("txsRefund(): creating refund transaction, swap: " + swapData.getClaimHash());
-        return initialTxns;
-    }
-    /**
-     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
-     *
-     * @param signer
-     * @param swapData swap data to refund
-     * @param timeout signature timeout
-     * @param prefix signature prefix of the counterparty
-     * @param signature signature of the counterparty
-     * @param check whether to check if swap is committed before attempting refund
-     * @param feeRate fee rate to be used for the transactions
-     */
-    async txsRefundWithAuthorization(signer, swapData, timeout, prefix, signature, check, feeRate) {
-        if (check && !await this.contract.isCommited(swapData)) {
-            throw new base_1.SwapDataVerificationError("Not correctly committed");
-        }
-        await this.isSignatureValid(swapData, timeout, prefix, signature);
-        const action = this.RefundWithSignature(signer, swapData, timeout, JSON.parse(signature));
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: " + swapData.getClaimHash() +
-            " auth expiry: " + timeout + " signature: " + signature);
-        return [await action.tx(feeRate)];
-    }
-    /**
-     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
-     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
-     */
-    async getRefundFee(swapData, feeRate) {
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, feeRate);
-    }
-}
-exports.StarknetSwapRefund = StarknetSwapRefund;
-StarknetSwapRefund.GasCosts = {
-    REFUND: { l1DataGas: 750, l2Gas: 4000000, l1Gas: 0 },
-    REFUND_PAY_OUT: { l1DataGas: 900, l2Gas: 6000000, l1Gas: 0 }
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSwapRefund = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../../../utils/Utils");
+const StarknetSwapModule_1 = require("../StarknetSwapModule");
+const StarknetAction_1 = require("../../chain/StarknetAction");
+const StarknetFees_1 = require("../../chain/modules/StarknetFees");
+const Refund = [
+    { name: 'Swap hash', type: 'felt' },
+    { name: 'Timeout', type: 'timestamp' }
+];
+class StarknetSwapRefund extends StarknetSwapModule_1.StarknetSwapModule {
+    /**
+     * Action for generic Refund instruction
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param handlerGas
+     * @private
+     */
+    Refund(signer, swapData, witness, handlerGas) {
+        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness), (0, StarknetFees_1.starknetGasAdd)(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas));
+    }
+    /**
+     * Action for cooperative refunding with signature
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @private
+     */
+    RefundWithSignature(sender, swapData, timeout, signature) {
+        return new StarknetAction_1.StarknetAction(sender, this.root, this.swapContract.populateTransaction.cooperative_refund(swapData.toEscrowStruct(), signature, BigInt(timeout)), swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND);
+    }
+    async signSwapRefund(signer, swapData, authorizationTimeout) {
+        const authPrefix = "refund";
+        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
+        const signature = await this.root.Signatures.signTypedMessage(signer, Refund, "Refund", {
+            "Swap hash": "0x" + swapData.getEscrowHash(),
+            "Timeout": (0, Utils_1.toHex)(authTimeout)
+        });
+        return {
+            prefix: authPrefix,
+            timeout: authTimeout.toString(10),
+            signature: signature
+        };
+    }
+    async isSignatureValid(swapData, timeout, prefix, signature) {
+        if (prefix !== "refund")
+            throw new base_1.SignatureVerificationError("Invalid prefix");
+        const expiryTimestamp = BigInt(timeout);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.contract.authGracePeriod);
+        if (isExpired)
+            throw new base_1.SignatureVerificationError("Authorization expired!");
+        const valid = await this.root.Signatures.isValidSignature(signature, swapData.claimer, Refund, "Refund", {
+            "Swap hash": "0x" + swapData.getEscrowHash(),
+            "Timeout": (0, Utils_1.toHex)(expiryTimestamp)
+        });
+        if (!valid) {
+            throw new base_1.SignatureVerificationError("Invalid signature!");
+        }
+        return null;
+    }
+    /**
+     * Creates transactions required for refunding timed out swap
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param check whether to check if swap is already expired and refundable
+     * @param feeRate fee rate to be used for the transactions
+     * @param witnessData
+     */
+    async txsRefund(signer, swapData, check, feeRate, witnessData) {
+        const refundHandler = this.contract.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
+        if (refundHandler == null)
+            throw new Error("Invalid refund handler");
+        if (check && !await this.contract.isRequestRefundable(swapData.offerer.toString(), swapData)) {
+            throw new base_1.SwapDataVerificationError("Not refundable yet!");
+        }
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const { initialTxns, witness } = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
+        const action = this.Refund(signer, swapData, witness, refundHandler.getGas(swapData));
+        await action.addToTxs(initialTxns, feeRate);
+        this.logger.debug("txsRefund(): creating refund transaction, swap: " + swapData.getClaimHash());
+        return initialTxns;
+    }
+    /**
+     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param timeout signature timeout
+     * @param prefix signature prefix of the counterparty
+     * @param signature signature of the counterparty
+     * @param check whether to check if swap is committed before attempting refund
+     * @param feeRate fee rate to be used for the transactions
+     */
+    async txsRefundWithAuthorization(signer, swapData, timeout, prefix, signature, check, feeRate) {
+        if (check && !await this.contract.isCommited(swapData)) {
+            throw new base_1.SwapDataVerificationError("Not correctly committed");
+        }
+        await this.isSignatureValid(swapData, timeout, prefix, signature);
+        const action = this.RefundWithSignature(signer, swapData, timeout, JSON.parse(signature));
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: " + swapData.getClaimHash() +
+            " auth expiry: " + timeout + " signature: " + signature);
+        return [await action.tx(feeRate)];
+    }
+    /**
+     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
+     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
+     */
+    async getRefundFee(swapData, feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, feeRate);
+    }
+}
+exports.StarknetSwapRefund = StarknetSwapRefund;
+StarknetSwapRefund.GasCosts = {
+    REFUND: { l1DataGas: 750, l2Gas: 4000000, l1Gas: 0 },
+    REFUND_PAY_OUT: { l1DataGas: 900, l2Gas: 6000000, l1Gas: 0 }
+};

package/dist/starknet/wallet/StarknetBrowserSigner.d.ts

@@ -1,11 +1,11 @@
-import { StarknetSigner } from "./StarknetSigner";
-import { Account } from "starknet";
-/**
- * Browser-based Starknet signer, use with browser based signer accounts, this ensures that
- *  no signTransaction calls are made and only sendTransaction is supported!
- *
- * @category Wallets
- */
-export declare class StarknetBrowserSigner extends StarknetSigner {
-    constructor(account: Account);
-}
+import { StarknetSigner } from "./StarknetSigner";
+import { Account } from "starknet";
+/**
+ * Browser-based Starknet signer, use with browser based signer accounts, this ensures that
+ *  no signTransaction calls are made and only sendTransaction is supported!
+ *
+ * @category Wallets
+ */
+export declare class StarknetBrowserSigner extends StarknetSigner {
+    constructor(account: Account);
+}

package/dist/starknet/wallet/StarknetBrowserSigner.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetBrowserSigner = void 0;
-const StarknetSigner_1 = require("./StarknetSigner");
-/**
- * Browser-based Starknet signer, use with browser based signer accounts, this ensures that
- *  no signTransaction calls are made and only sendTransaction is supported!
- *
- * @category Wallets
- */
-class StarknetBrowserSigner extends StarknetSigner_1.StarknetSigner {
-    constructor(account) {
-        super(account, false);
-        this.signTransaction = undefined;
-    }
-}
-exports.StarknetBrowserSigner = StarknetBrowserSigner;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetBrowserSigner = void 0;
+const StarknetSigner_1 = require("./StarknetSigner");
+/**
+ * Browser-based Starknet signer, use with browser based signer accounts, this ensures that
+ *  no signTransaction calls are made and only sendTransaction is supported!
+ *
+ * @category Wallets
+ */
+class StarknetBrowserSigner extends StarknetSigner_1.StarknetSigner {
+    constructor(account) {
+        super(account, false);
+        this.signTransaction = undefined;
+    }
+}
+exports.StarknetBrowserSigner = StarknetBrowserSigner;

package/dist/starknet/wallet/StarknetPersistentSigner.d.ts

@@ -1,76 +1,76 @@
-import { StarknetSigner } from "./StarknetSigner";
-import { StarknetTx } from "../chain/modules/StarknetTransactions";
-import { StarknetChainInterface } from "../chain/StarknetChainInterface";
-import { Account } from "starknet";
-/**
- * Configuration for the persistent signer
- *
- * @category Wallets
- */
-export type StarknetPersistentSignerConfig = {
-    /**
-     * How long to wait for the transaction to confirm before bumping the fee (default 15,000ms = 15s)
-     */
-    waitBeforeBump?: number;
-    /**
-     * Minimum fee increment in absolute terms in base units of STRK token (default 1,000,000 = 0.001GFri)
-     */
-    minFeeIncreaseAbsolute?: bigint;
-    /**
-     * Minimum fee increase in PPM (parts per million, i.e. 10,000 = 1%) (default 110,000 = 11%)
-     */
-    minFeeIncreasePpm?: bigint;
-    /**
-     * Minimum tip increment in absolute terms in base units of STRK token (default 1,000,000,000 = 1GFri)
-     */
-    minTipIncreaseAbsolute?: bigint;
-    /**
-     * Minimum tip increase in PPM (parts per million, i.e. 10,000 = 1%) (default 110,000 = 11%)
-     */
-    minTipIncreasePpm?: bigint;
-};
-/**
- * A complex starknet signer implementation with internal nonce management, with race condition preventions,
- *  automatic transaction rebroadcasting and failovers. Uses the NodeJS `fs` library to persist transaction
- *  data across application restarts, hence this doesn't work on frontends and is intended to be used as a
- *  robust backend wallet implementation.
- *
- * @category Wallets
- */
-export declare class StarknetPersistentSigner extends StarknetSigner {
-    private pendingTxs;
-    private confirmedNonce;
-    private pendingNonce;
-    private feeBumper;
-    private stopped;
-    private readonly directory;
-    private readonly config;
-    private readonly chainInterface;
-    private readonly logger;
-    constructor(account: Account, chainInterface: StarknetChainInterface, directory: string, config?: StarknetPersistentSignerConfig);
-    private load;
-    private priorSavePromise?;
-    private saveCount;
-    private save;
-    private checkPastTransactions;
-    private startFeeBumper;
-    private syncNonceFromChain;
-    /**
-     * @inheritDoc
-     */
-    init(): Promise<void>;
-    /**
-     * @inheritDoc
-     */
-    stop(): Promise<void>;
-    private readonly sendTransactionQueue;
-    /**
-     * Signs and sends the starknet transaction, the `onBeforePublish` callback is called after the transaction
-     *  is signed and before it is broadcast. Ensures that transactions are always sent in order by using a
-     *  "single-threaded" promise queue, and no nonce collision happen.
-     *
-     * @param transaction A transaction to sign and send
-     * @param onBeforePublish A callback that is called before the transaction gets broadcasted
-     */
-    sendTransaction(transaction: StarknetTx, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string>;
-}
+import { StarknetSigner } from "./StarknetSigner";
+import { StarknetTx } from "../chain/modules/StarknetTransactions";
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
+import { Account } from "starknet";
+/**
+ * Configuration for the persistent signer
+ *
+ * @category Wallets
+ */
+export type StarknetPersistentSignerConfig = {
+    /**
+     * How long to wait for the transaction to confirm before bumping the fee (default 15,000ms = 15s)
+     */
+    waitBeforeBump?: number;
+    /**
+     * Minimum fee increment in absolute terms in base units of STRK token (default 1,000,000 = 0.001GFri)
+     */
+    minFeeIncreaseAbsolute?: bigint;
+    /**
+     * Minimum fee increase in PPM (parts per million, i.e. 10,000 = 1%) (default 110,000 = 11%)
+     */
+    minFeeIncreasePpm?: bigint;
+    /**
+     * Minimum tip increment in absolute terms in base units of STRK token (default 1,000,000,000 = 1GFri)
+     */
+    minTipIncreaseAbsolute?: bigint;
+    /**
+     * Minimum tip increase in PPM (parts per million, i.e. 10,000 = 1%) (default 110,000 = 11%)
+     */
+    minTipIncreasePpm?: bigint;
+};
+/**
+ * A complex starknet signer implementation with internal nonce management, with race condition preventions,
+ *  automatic transaction rebroadcasting and failovers. Uses the NodeJS `fs` library to persist transaction
+ *  data across application restarts, hence this doesn't work on frontends and is intended to be used as a
+ *  robust backend wallet implementation.
+ *
+ * @category Wallets
+ */
+export declare class StarknetPersistentSigner extends StarknetSigner {
+    private pendingTxs;
+    private confirmedNonce;
+    private pendingNonce;
+    private feeBumper;
+    private stopped;
+    private readonly directory;
+    private readonly config;
+    private readonly chainInterface;
+    private readonly logger;
+    constructor(account: Account, chainInterface: StarknetChainInterface, directory: string, config?: StarknetPersistentSignerConfig);
+    private load;
+    private priorSavePromise?;
+    private saveCount;
+    private save;
+    private checkPastTransactions;
+    private startFeeBumper;
+    private syncNonceFromChain;
+    /**
+     * @inheritDoc
+     */
+    init(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    stop(): Promise<void>;
+    private readonly sendTransactionQueue;
+    /**
+     * Signs and sends the starknet transaction, the `onBeforePublish` callback is called after the transaction
+     *  is signed and before it is broadcast. Ensures that transactions are always sent in order by using a
+     *  "single-threaded" promise queue, and no nonce collision happen.
+     *
+     * @param transaction A transaction to sign and send
+     * @param onBeforePublish A callback that is called before the transaction gets broadcasted
+     */
+    sendTransaction(transaction: StarknetTx, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string>;
+}