@atomiqlabs/chain-starknet 4.0.0-dev.3 → 4.0.0-dev.31

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

@@ -1,128 +1,128 @@
-"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
-     * @constructor
-     * @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
-     * @constructor
-     * @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 (0, Utils_1.tryWithRetries)(() => this.contract.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
-            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 (0, Utils_1.tryWithRetries)(() => this.contract.isCommited(swapData), this.retryPolicy)) {
-            throw new base_1.SwapDataVerificationError("Not correctly committed");
-        }
-        await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
-        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
+     * @constructor
+     * @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
+     * @constructor
+     * @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 (0, Utils_1.tryWithRetries)(() => this.contract.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
+            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 (0, Utils_1.tryWithRetries)(() => this.contract.isCommited(swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not correctly committed");
+        }
+        await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
+        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

@@ -0,0 +1,5 @@
+import { StarknetSigner } from "./StarknetSigner";
+import { Account } from "starknet";
+export declare class StarknetBrowserSigner extends StarknetSigner {
+    constructor(account: Account);
+}

package/dist/starknet/wallet/StarknetBrowserSigner.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetBrowserSigner = void 0;
+const StarknetSigner_1 = require("./StarknetSigner");
+class StarknetBrowserSigner extends StarknetSigner_1.StarknetSigner {
+    constructor(account) {
+        super(account, false);
+        this.signTransaction = null;
+    }
+}
+exports.StarknetBrowserSigner = StarknetBrowserSigner;

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

@@ -1,7 +1,7 @@
-import { Account, DeployAccountContractPayload, Provider } from "starknet";
-export declare class StarknetKeypairWallet extends Account {
-    readonly publicKey: string;
-    constructor(provider: Provider, privateKey: string);
-    getDeploymentData(): DeployAccountContractPayload;
-    static generateRandomPrivateKey(): string;
-}
+import { Account, DeployAccountContractPayload, Provider } from "starknet";
+export declare class StarknetKeypairWallet extends Account {
+    readonly publicKey: string;
+    constructor(provider: Provider, privateKey: string);
+    getDeploymentData(): DeployAccountContractPayload;
+    static generateRandomPrivateKey(): string;
+}

package/dist/starknet/wallet/StarknetKeypairWallet.js

@@ -1,30 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetKeypairWallet = void 0;
-const starknet_1 = require("starknet");
-const Utils_1 = require("../../utils/Utils");
-const buffer_1 = require("buffer");
-const OZaccountClassHash = '0x00261c293c8084cd79086214176b33e5911677cec55104fddc8d25b0b736dcad';
-//Openzeppelin Account wallet
-class StarknetKeypairWallet extends starknet_1.Account {
-    constructor(provider, privateKey) {
-        const publicKey = starknet_1.ec.starkCurve.getStarkKey((0, Utils_1.toHex)(privateKey));
-        // Calculate future address of the account
-        const OZaccountConstructorCallData = starknet_1.CallData.compile({ publicKey });
-        const OZcontractAddress = starknet_1.hash.calculateContractAddressFromHash(publicKey, OZaccountClassHash, OZaccountConstructorCallData, 0);
-        super(provider, OZcontractAddress, privateKey, "1");
-        this.publicKey = publicKey;
-    }
-    getDeploymentData() {
-        return {
-            classHash: OZaccountClassHash,
-            constructorCalldata: starknet_1.CallData.compile({ publicKey: this.publicKey }),
-            addressSalt: this.publicKey,
-            contractAddress: this.address
-        };
-    }
-    static generateRandomPrivateKey() {
-        return "0x" + buffer_1.Buffer.from(starknet_1.ec.starkCurve.utils.randomPrivateKey()).toString("hex");
-    }
-}
-exports.StarknetKeypairWallet = StarknetKeypairWallet;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetKeypairWallet = void 0;
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../utils/Utils");
+const buffer_1 = require("buffer");
+const OZaccountClassHash = '0x00261c293c8084cd79086214176b33e5911677cec55104fddc8d25b0b736dcad';
+//Openzeppelin Account wallet
+class StarknetKeypairWallet extends starknet_1.Account {
+    constructor(provider, privateKey) {
+        const publicKey = starknet_1.ec.starkCurve.getStarkKey((0, Utils_1.toHex)(privateKey));
+        // Calculate future address of the account
+        const OZaccountConstructorCallData = starknet_1.CallData.compile({ publicKey });
+        const OZcontractAddress = starknet_1.hash.calculateContractAddressFromHash(publicKey, OZaccountClassHash, OZaccountConstructorCallData, 0);
+        super({
+            provider,
+            address: OZcontractAddress,
+            signer: privateKey,
+            cairoVersion: "1"
+        });
+        this.publicKey = publicKey;
+    }
+    getDeploymentData() {
+        return {
+            classHash: OZaccountClassHash,
+            constructorCalldata: starknet_1.CallData.compile({ publicKey: this.publicKey }),
+            addressSalt: this.publicKey,
+            contractAddress: this.address
+        };
+    }
+    static generateRandomPrivateKey() {
+        return "0x" + buffer_1.Buffer.from(starknet_1.ec.starkCurve.utils.randomPrivateKey()).toString("hex");
+    }
+}
+exports.StarknetKeypairWallet = StarknetKeypairWallet;

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

@@ -0,0 +1,33 @@
+import { StarknetSigner } from "./StarknetSigner";
+import { StarknetTx } from "../chain/modules/StarknetTransactions";
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
+import { Account } from "starknet";
+export type StarknetPersistentSignerConfig = {
+    waitBeforeBump?: number;
+    minFeeIncreaseAbsolute?: bigint;
+    minFeeIncreasePpm?: bigint;
+    minTipIncreaseAbsolute?: bigint;
+    minTipIncreasePpm?: bigint;
+};
+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;
+    init(): Promise<void>;
+    stop(): Promise<void>;
+    private readonly sendTransactionQueue;
+    sendTransaction(transaction: StarknetTx, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string>;
+}

package/dist/starknet/wallet/StarknetPersistentSigner.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetPersistentSigner = void 0;
+const StarknetSigner_1 = require("./StarknetSigner");
+const StarknetTransactions_1 = require("../chain/modules/StarknetTransactions");
+const Utils_1 = require("../../utils/Utils");
+const starknet_1 = require("starknet");
+const promises_1 = require("fs/promises");
+const StarknetFees_1 = require("../chain/modules/StarknetFees");
+const transaction_1 = require("@scure/btc-signer/transaction");
+const promise_queue_ts_1 = require("promise-queue-ts");
+const WAIT_BEFORE_BUMP = 15 * 1000;
+const MIN_FEE_INCREASE_ABSOLUTE = 1n * 1000000n; //0.001GWei
+const MIN_FEE_INCREASE_PPM = 110000n; // +11%
+const MIN_TIP_INCREASE_ABSOLUTE = 1n * 1000000000n; //1GWei
+const MIN_TIP_INCREASE_PPM = 110000n; // +11%
+class StarknetPersistentSigner extends StarknetSigner_1.StarknetSigner {
+    constructor(account, chainInterface, directory, config) {
+        var _a, _b, _c, _d, _e;
+        super(account, true);
+        this.pendingTxs = new Map();
+        this.stopped = false;
+        this.saveCount = 0;
+        this.sendTransactionQueue = new promise_queue_ts_1.PromiseQueue();
+        this.signTransaction = null;
+        this.chainInterface = chainInterface;
+        this.directory = directory;
+        this.config = config ?? {};
+        (_a = this.config).minFeeIncreaseAbsolute ?? (_a.minFeeIncreaseAbsolute = MIN_FEE_INCREASE_ABSOLUTE);
+        (_b = this.config).minFeeIncreasePpm ?? (_b.minFeeIncreasePpm = MIN_FEE_INCREASE_PPM);
+        (_c = this.config).minTipIncreaseAbsolute ?? (_c.minTipIncreaseAbsolute = MIN_TIP_INCREASE_ABSOLUTE);
+        (_d = this.config).minTipIncreasePpm ?? (_d.minTipIncreasePpm = MIN_TIP_INCREASE_PPM);
+        (_e = this.config).waitBeforeBump ?? (_e.waitBeforeBump = WAIT_BEFORE_BUMP);
+        this.logger = (0, Utils_1.getLogger)("StarknetPersistentSigner(" + this.account.address + "): ");
+    }
+    async load() {
+        const fileExists = await (0, promises_1.access)(this.directory + "/txs.json", promises_1.constants.F_OK).then(() => true).catch(() => false);
+        if (!fileExists)
+            return;
+        const res = await (0, promises_1.readFile)(this.directory + "/txs.json");
+        if (res != null) {
+            const pendingTxs = JSON.parse(res.toString());
+            for (let nonceStr in pendingTxs) {
+                const nonceData = pendingTxs[nonceStr];
+                const nonce = BigInt(nonceStr);
+                if (this.confirmedNonce >= nonce)
+                    continue; //Already confirmed
+                if (this.pendingNonce < nonce) {
+                    this.pendingNonce = nonce;
+                }
+                const parsedPendingTxns = nonceData.txs.map(StarknetTransactions_1.StarknetTransactions.deserializeTx);
+                this.pendingTxs.set(nonce, {
+                    txs: parsedPendingTxns,
+                    lastBumped: nonceData.lastBumped
+                });
+                for (let tx of parsedPendingTxns) {
+                    this.chainInterface.Transactions._knownTxSet.add(tx.txId);
+                }
+            }
+        }
+    }
+    async save() {
+        const pendingTxs = {};
+        for (let [nonce, data] of this.pendingTxs) {
+            pendingTxs[nonce.toString(10)] = {
+                lastBumped: data.lastBumped,
+                txs: data.txs.map(StarknetTransactions_1.StarknetTransactions.serializeTx)
+            };
+        }
+        const requiredSaveCount = ++this.saveCount;
+        if (this.priorSavePromise != null) {
+            await this.priorSavePromise;
+        }
+        if (requiredSaveCount === this.saveCount) {
+            this.priorSavePromise = (0, promises_1.writeFile)(this.directory + "/txs.json", JSON.stringify(pendingTxs));
+            await this.priorSavePromise;
+        }
+    }
+    async checkPastTransactions() {
+        let _gasPrice = null;
+        let _safeBlockNonce = null;
+        for (let [nonce, data] of this.pendingTxs) {
+            if (!data.sending && data.lastBumped < Date.now() - this.config.waitBeforeBump) {
+                _safeBlockNonce = await this.chainInterface.Transactions.getNonce(this.account.address, starknet_1.BlockTag.LATEST);
+                this.confirmedNonce = _safeBlockNonce;
+                if (_safeBlockNonce > nonce) {
+                    this.pendingTxs.delete(nonce);
+                    data.txs.forEach(tx => this.chainInterface.Transactions._knownTxSet.delete(tx.txId));
+                    this.logger.info("checkPastTransactions(): Tx confirmed, required fee bumps: ", data.txs.length);
+                    this.save();
+                    continue;
+                }
+                const lastTx = data.txs[data.txs.length - 1];
+                if (_gasPrice == null) {
+                    const feeRate = await this.chainInterface.Fees.getFeeRate();
+                    _gasPrice = StarknetFees_1.StarknetFees.extractFromFeeRateString(feeRate);
+                }
+                let l1GasCost = BigInt(lastTx.details.resourceBounds.l1_gas.max_price_per_unit);
+                let l2GasCost = BigInt(lastTx.details.resourceBounds.l2_gas.max_price_per_unit);
+                let l1DataGasCost = BigInt(lastTx.details.resourceBounds.l1_data_gas.max_price_per_unit);
+                let tip = BigInt(lastTx.details.tip);
+                let feeBumped = false;
+                if (_gasPrice.l1GasCost > l1GasCost) {
+                    //Bump by minimum allowed or to the actual _gasPrice.l1GasCost
+                    l1GasCost = (0, Utils_1.bigIntMax)(_gasPrice.l1GasCost, this.config.minFeeIncreaseAbsolute + (l1GasCost * (1000000n + this.config.minFeeIncreasePpm) / 1000000n));
+                    feeBumped = true;
+                }
+                if (_gasPrice.l1DataGasCost > l1DataGasCost) {
+                    //Bump by minimum allowed or to the actual _gasPrice.l1GasCost
+                    l1DataGasCost = (0, Utils_1.bigIntMax)(_gasPrice.l1DataGasCost, this.config.minFeeIncreaseAbsolute + (l1DataGasCost * (1000000n + this.config.minFeeIncreasePpm) / 1000000n));
+                    feeBumped = true;
+                }
+                if (_gasPrice.l2GasCost > l2GasCost || feeBumped) { //In case the fees for l1 and l1Data were bumped, we also need to bump the l2GasFee regardless
+                    l2GasCost = (0, Utils_1.bigIntMax)(_gasPrice.l2GasCost, this.config.minFeeIncreaseAbsolute + (l2GasCost * (1000000n + this.config.minFeeIncreasePpm) / 1000000n));
+                    feeBumped = true;
+                }
+                if (feeBumped)
+                    tip = this.config.minTipIncreaseAbsolute + (tip * (1000000n + this.config.minTipIncreasePpm) / 1000000n);
+                if (!feeBumped) {
+                    //Not fee bumped
+                    this.logger.debug("checkPastTransactions(): Tx yet unconfirmed but not increasing fee for ", lastTx.txId);
+                    //Rebroadcast the tx
+                    await this.chainInterface.Transactions.sendTransaction(lastTx).catch(e => {
+                        if (e.baseError?.code === 52) { //Invalid transaction nonce
+                            this.logger.debug("checkPastTransactions(): Tx re-broadcast success, tx already confirmed: ", lastTx.txId);
+                            return;
+                        }
+                        if (e.baseError?.code === 59) { //Transaction already in the mempool
+                            this.logger.debug("checkPastTransactions(): Tx re-broadcast success, tx already known to the RPC: ", lastTx.txId);
+                            return;
+                        }
+                        this.logger.error("checkPastTransactions(): Tx re-broadcast error", e);
+                    });
+                    data.lastBumped = Date.now();
+                    continue;
+                }
+                const newTx = (0, transaction_1.cloneDeep)(lastTx);
+                delete newTx.signed;
+                delete newTx.txId;
+                newTx.details.tip = tip;
+                newTx.details.resourceBounds.l1_gas.max_price_per_unit = l1GasCost;
+                newTx.details.resourceBounds.l2_gas.max_price_per_unit = l2GasCost;
+                newTx.details.resourceBounds.l1_data_gas.max_price_per_unit = l1DataGasCost;
+                await this._signTransaction(newTx);
+                this.logger.info(`checkPastTransactions(): Bump fee for tx ${lastTx.txId} -> ${newTx.txId}`);
+                //Double check pending txns still has nonce after async signTransaction was called
+                if (!this.pendingTxs.has(nonce))
+                    continue;
+                for (let callback of this.chainInterface.Transactions._cbksBeforeTxReplace) {
+                    try {
+                        await callback(StarknetTransactions_1.StarknetTransactions.serializeTx(lastTx), lastTx.txId, StarknetTransactions_1.StarknetTransactions.serializeTx(newTx), newTx.txId);
+                    }
+                    catch (e) {
+                        this.logger.error("checkPastTransactions(): beforeTxReplace callback error: ", e);
+                    }
+                }
+                data.txs.push(newTx);
+                data.lastBumped = Date.now();
+                this.save();
+                this.chainInterface.Transactions._knownTxSet.add(newTx.txId);
+                //TODO: Better error handling when sending tx
+                await this.chainInterface.Transactions.sendTransaction(newTx).catch(e => {
+                    if (e.baseError?.code === 52) { //Invalid transaction nonce
+                        return;
+                    }
+                    this.logger.error("checkPastTransactions(): Fee-bumped tx broadcast error", e);
+                });
+            }
+        }
+    }
+    startFeeBumper() {
+        let func;
+        func = async () => {
+            try {
+                await this.checkPastTransactions();
+            }
+            catch (e) {
+                this.logger.error("startFeeBumper(): Error when check past transactions: ", e);
+            }
+            if (this.stopped)
+                return;
+            this.feeBumper = setTimeout(func, 1000);
+        };
+        func();
+    }
+    async init() {
+        try {
+            await (0, promises_1.mkdir)(this.directory);
+        }
+        catch (e) { }
+        const nonce = await this.chainInterface.Transactions.getNonce(this.account.address, starknet_1.BlockTag.LATEST);
+        this.confirmedNonce = nonce - 1n;
+        this.pendingNonce = nonce - 1n;
+        await this.load();
+        this.startFeeBumper();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.feeBumper != null) {
+            clearTimeout(this.feeBumper);
+            this.feeBumper = null;
+        }
+        return Promise.resolve();
+    }
+    sendTransaction(transaction, onBeforePublish) {
+        return this.sendTransactionQueue.enqueue(async () => {
+            if (transaction.details.nonce != null) {
+                if (transaction.details.nonce !== this.pendingNonce + 1n)
+                    throw new Error("Invalid transaction nonce!");
+            }
+            else {
+                transaction.details.nonce = this.pendingNonce + 1n;
+            }
+            const signedTx = await this._signTransaction(transaction);
+            if (onBeforePublish != null) {
+                try {
+                    await onBeforePublish(signedTx.txId, StarknetTransactions_1.StarknetTransactions.serializeTx(signedTx));
+                }
+                catch (e) {
+                    this.logger.error("sendTransaction(): Error when calling onBeforePublish function: ", e);
+                }
+            }
+            const pendingTxObject = { txs: [signedTx], lastBumped: Date.now(), sending: true };
+            this.pendingNonce++;
+            this.logger.debug("sendTransaction(): Incrementing pending nonce to: ", this.pendingNonce);
+            this.pendingTxs.set(transaction.details.nonce, pendingTxObject);
+            this.save();
+            this.chainInterface.Transactions._knownTxSet.add(signedTx.txId);
+            try {
+                const result = await this.chainInterface.Transactions.sendTransaction(signedTx);
+                pendingTxObject.sending = false;
+                return result;
+            }
+            catch (e) {
+                this.chainInterface.Transactions._knownTxSet.delete(signedTx.txId);
+                this.pendingTxs.delete(transaction.details.nonce);
+                this.pendingNonce--;
+                this.logger.debug("sendTransaction(): Error when broadcasting transaction, reverting pending nonce to: ", this.pendingNonce);
+                throw e;
+            }
+        });
+    }
+}
+exports.StarknetPersistentSigner = StarknetPersistentSigner;