@atomiqlabs/chain-starknet 1.0.9 → 2.0.0-beta.0

package/src/starknet/btcrelay/StarknetBtcRelay.ts

@@ -1,21 +1,21 @@
 import {Buffer} from "buffer";
 import {StarknetBtcHeader} from "./headers/StarknetBtcHeader";
-import {BigIntBufferUtils, BitcoinRpc, BtcBlock, BtcRelay, StatePredictorUtils} from "@atomiqlabs/base";
+import {BitcoinRpc, BtcBlock, BtcRelay, RelaySynchronizer, StatePredictorUtils} from "@atomiqlabs/base";
 import {
     bigNumberishToBuffer,
-    bufferToU32Array,
-    toHex,
+    bufferToU32Array, getLogger,
+    toHex, tryWithRetries,
     u32ReverseEndianness
 } from "../../utils/Utils";
 import {StarknetContractBase} from "../contract/StarknetContractBase";
 import {StarknetBtcStoredHeader} from "./headers/StarknetBtcStoredHeader";
-import {StarknetTx} from "../base/modules/StarknetTransactions";
+import {StarknetTx} from "../chain/modules/StarknetTransactions";
 import {StarknetSigner} from "../wallet/StarknetSigner";
 import {BtcRelayAbi} from "./BtcRelayAbi";
-import {BigNumberish, constants, hash, Provider} from "starknet";
-import {StarknetFees} from "../base/modules/StarknetFees";
-import {StarknetRetryPolicy} from "../base/StarknetBase";
-import {StarknetAction} from "../base/StarknetAction";
+import {BigNumberish, constants, hash} from "starknet";
+import {StarknetFees} from "../chain/modules/StarknetFees";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {StarknetAction} from "../chain/StarknetAction";
 
 function serializeBlockHeader(e: BtcBlock): StarknetBtcHeader {
     return new StarknetBtcHeader({
@@ -29,8 +29,8 @@ function serializeBlockHeader(e: BtcBlock): StarknetBtcHeader {
     });
 }
 
-const GAS_PER_BLOCKHEADER = 750;
-const GAS_PER_BLOCKHEADER_FORK = 750;
+const GAS_PER_BLOCKHEADER = 850;
+const GAS_PER_BLOCKHEADER_FORK = 1000;
 
 const btcRelayAddreses = {
     [constants.StarknetChainId.SN_SEPOLIA]: "0x068601c79da2231d21e015ccfd59c243861156fa523a12c9f987ec28eb8dbc8c",
@@ -46,13 +46,16 @@ function serializeCalldata(headers: StarknetBtcHeader[], storedHeader: StarknetB
     return span;
 }
 
+const logger = getLogger("StarknetBtcRelay: ");
+
 export class StarknetBtcRelay<B extends BtcBlock>
     extends StarknetContractBase<typeof BtcRelayAbi>
     implements BtcRelay<StarknetBtcStoredHeader, StarknetTx, B, StarknetSigner> {
 
+
     public SaveMainHeaders(signer: string, mainHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction {
 
-        return new StarknetAction(signer, this,
+        return new StarknetAction(signer, this.Chain,
             {
                 contractAddress: this.contract.address,
                 entrypoint: "submit_main_blockheaders",
@@ -63,7 +66,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
     }
 
     public SaveShortForkHeaders(signer: string, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction {
-        return new StarknetAction(signer, this,
+        return new StarknetAction(signer, this.Chain,
             {
                 contractAddress: this.contract.address,
                 entrypoint: "submit_short_fork_blockheaders",
@@ -74,7 +77,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
     }
 
     public SaveLongForkHeaders(signer: string, forkId: number, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader, totalForkHeaders: number = 100): StarknetAction {
-        return new StarknetAction(signer, this,
+        return new StarknetAction(signer, this.Chain,
             {
                 contractAddress: this.contract.address,
                 entrypoint: "submit_fork_blockheaders",
@@ -91,14 +94,11 @@ export class StarknetBtcRelay<B extends BtcBlock>
     readonly maxShortForkHeadersPerTx: number = 100;
 
     constructor(
-        chainId: constants.StarknetChainId,
-        provider: Provider,
+        chainInterface: StarknetChainInterface,
         bitcoinRpc: BitcoinRpc<B>,
-        contractAddress: string = btcRelayAddreses[chainId],
-        retryPolicy?: StarknetRetryPolicy,
-        solanaFeeEstimator: StarknetFees = new StarknetFees(provider)
+        contractAddress: string = btcRelayAddreses[chainInterface.starknetChainId],
     ) {
-        super(chainId, provider, contractAddress, BtcRelayAbi, retryPolicy, solanaFeeEstimator);
+        super(chainInterface, contractAddress, BtcRelayAbi);
         this.bitcoinRpc = bitcoinRpc;
     }
 
@@ -232,7 +232,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
         const chainCommitment = await this.contract.get_commit_hash(storedBlockHeader.block_height);
         if(BigInt(chainCommitment)!==BigInt(commitHash)) return null;
 
-        this.logger.debug("retrieveLogAndBlockheight(): block found," +
+        logger.debug("retrieveLogAndBlockheight(): block found," +
             " commit hash: "+toHex(commitHash)+" blockhash: "+blockData.blockhash+" current btc relay height: "+blockHeight);
 
         return {header: storedBlockHeader, height: blockHeight};
@@ -254,7 +254,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
         const chainCommitment = await this.contract.get_commit_hash(storedBlockHeader.block_height);
         if(BigInt(chainCommitment)!==BigInt(commitHash)) return null;
 
-        this.logger.debug("retrieveLogByCommitHash(): block found," +
+        logger.debug("retrieveLogByCommitHash(): block found," +
             " commit hash: "+commitmentHashStr+" blockhash: "+blockData.blockhash+" height: "+storedBlockHeader.block_height);
 
         return storedBlockHeader;
@@ -292,7 +292,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
             }
         )
 
-        if(data!=null) this.logger.debug("retrieveLatestKnownBlockLog(): block found," +
+        if(data!=null) logger.debug("retrieveLatestKnownBlockLog(): block found," +
             " commit hash: "+toHex(data.commitHash)+" blockhash: "+data.resultBitcoinHeader.getHash()+
             " height: "+data.resultStoredHeader.getBlockheight());
 
@@ -308,7 +308,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
      * @param feeRate
      */
     public saveMainHeaders(signer: string, mainHeaders: BtcBlock[], storedHeader: StarknetBtcStoredHeader, feeRate?: string) {
-        this.logger.debug("saveMainHeaders(): submitting main blockheaders, count: "+mainHeaders.length);
+        logger.debug("saveMainHeaders(): submitting main blockheaders, count: "+mainHeaders.length);
         return this._saveHeaders(signer, mainHeaders, storedHeader, null, 0, feeRate);
     }
 
@@ -324,7 +324,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
     public async saveNewForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: StarknetBtcStoredHeader, tipWork: Buffer, feeRate?: string) {
         let forkId: number = Math.floor(Math.random() * 0xFFFFFFFFFFFF);
 
-        this.logger.debug("saveNewForkHeaders(): submitting new fork & blockheaders," +
+        logger.debug("saveNewForkHeaders(): submitting new fork & blockheaders," +
             " count: "+forkHeaders.length+" forkId: 0x"+forkId.toString(16));
 
         return await this._saveHeaders(signer, forkHeaders, storedHeader, tipWork, forkId, feeRate);
@@ -341,7 +341,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
      * @param feeRate
      */
     public saveForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: StarknetBtcStoredHeader, forkId: number, tipWork: Buffer, feeRate?: string) {
-        this.logger.debug("saveForkHeaders(): submitting blockheaders to existing fork," +
+        logger.debug("saveForkHeaders(): submitting blockheaders to existing fork," +
             " count: "+forkHeaders.length+" forkId: 0x"+forkId.toString(16));
 
         return this._saveHeaders(signer, forkHeaders, storedHeader, tipWork, forkId, feeRate);
@@ -357,7 +357,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
      * @param feeRate
      */
     public saveShortForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: StarknetBtcStoredHeader, tipWork: Buffer, feeRate?: string) {
-        this.logger.debug("saveShortForkHeaders(): submitting short fork blockheaders," +
+        logger.debug("saveShortForkHeaders(): submitting short fork blockheaders," +
             " count: "+forkHeaders.length);
 
         return this._saveHeaders(signer, forkHeaders, storedHeader, tipWork, -1, feeRate);
@@ -378,7 +378,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
         if(blockheightDelta<=0) return 0n;
 
         const synchronizationFee = BigInt(blockheightDelta) * await this.getFeePerBlock(feeRate);
-        this.logger.debug("estimateSynchronizeFee(): required blockheight: "+requiredBlockheight+
+        logger.debug("estimateSynchronizeFee(): required blockheight: "+requiredBlockheight+
             " blockheight delta: "+blockheightDelta+" fee: "+synchronizationFee.toString(10));
 
         return synchronizationFee;
@@ -390,7 +390,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
      * @param feeRate
      */
     public async getFeePerBlock(feeRate?: string): Promise<bigint> {
-        feeRate ??= await this.Fees.getFeeRate();
+        feeRate ??= await this.Chain.Fees.getFeeRate();
         return StarknetFees.getGasFee(GAS_PER_BLOCKHEADER, feeRate);
     }
 
@@ -398,18 +398,92 @@ export class StarknetBtcRelay<B extends BtcBlock>
      * Gets fee rate required for submitting blockheaders to the main chain
      */
     public getMainFeeRate(signer: string | null): Promise<string> {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
 
     /**
      * Gets fee rate required for submitting blockheaders to the specific fork
      */
     public getForkFeeRate(signer: string, forkId: number): Promise<string> {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
 
     saveInitialHeader(signer: string, header: B, epochStart: number, pastBlocksTimestamps: number[], feeRate?: string): Promise<StarknetTx> {
         throw new Error("Not supported, starknet contract is initialized with constructor!");
     }
 
+    /**
+     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
+     *  requiredConfirmations
+     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
+     *  current chain tip & adds them to the txs array
+     *
+     * @param signer
+     * @param btcRelay
+     * @param btcTxs
+     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
+     *  txns are added here
+     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
+     *  to the required blockheight
+     * @param feeRate Fee rate to use for synchronization transactions
+     * @private
+     */
+    static async getCommitedHeadersAndSynchronize(
+        signer: string,
+        btcRelay: StarknetBtcRelay<any>,
+        btcTxs: {blockheight: number, requiredConfirmations: number, blockhash: string}[],
+        txs: StarknetTx[],
+        synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>,
+        feeRate?: string
+    ): Promise<{
+        [blockhash: string]: StarknetBtcStoredHeader
+    }> {
+        const leavesTxs: {blockheight: number, requiredConfirmations: number, blockhash: string}[] = [];
+
+        const blockheaders: {
+            [blockhash: string]: StarknetBtcStoredHeader
+        } = {};
+
+        for(let btcTx of btcTxs) {
+            const requiredBlockheight = btcTx.blockheight+btcTx.requiredConfirmations-1;
+
+            const result = await tryWithRetries(
+                () => btcRelay.retrieveLogAndBlockheight({
+                    blockhash: btcTx.blockhash
+                }, requiredBlockheight)
+            );
+
+            if(result!=null) {
+                blockheaders[result.header.getBlockHash().toString("hex")] = result.header;
+            } else {
+                leavesTxs.push(btcTx);
+            }
+        }
+
+        if(leavesTxs.length===0) return blockheaders;
+
+        //Need to synchronize
+        if(synchronizer==null) return null;
+
+        //TODO: We don't have to synchronize to tip, only to our required blockheight
+        const resp = await synchronizer.syncToLatestTxs(signer.toString(), feeRate);
+        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay not synchronized to required blockheight, "+
+            "synchronizing ourselves in "+resp.txs.length+" txs");
+        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay computed header map: ",resp.computedHeaderMap);
+        txs.push(...resp.txs);
+
+        for(let key in resp.computedHeaderMap) {
+            const header = resp.computedHeaderMap[key];
+            blockheaders[header.getBlockHash().toString("hex")] = header;
+        }
+
+        //Check that blockhashes of all the rest txs are included
+        for(let btcTx of leavesTxs) {
+            if(blockheaders[btcTx.blockhash]==null) return null;
+        }
+
+        //Retrieve computed headers
+        return blockheaders;
+    }
+
 }

package/src/starknet/{base → chain}/StarknetAction.ts

@@ -1,5 +1,5 @@
 import {Call} from "starknet";
-import {StarknetBase} from "./StarknetBase";
+import {StarknetChainInterface} from "./StarknetChainInterface";
 import {StarknetTx} from "./modules/StarknetTransactions";
 
 export type StarknetGas = {l1?: number, l2?: number};
@@ -16,13 +16,13 @@ export class StarknetAction {
     L1GasLimit: number;
     L2GasLimit: number;
     readonly mainSigner: string;
-    private readonly root: StarknetBase;
+    private readonly root: StarknetChainInterface;
     private readonly instructions: Call[];
     private feeRate: string;
 
     constructor(
         mainSigner: string,
-        root: StarknetBase,
+        root: StarknetChainInterface,
         instructions: Call[] | Call = [],
         gasLimit?: StarknetGas,
         feeRate?: string

package/src/starknet/chain/StarknetChainInterface.ts

@@ -0,0 +1,149 @@
+import {Provider, constants, stark, ec} from "starknet";
+import {getLogger, toHex} from "../../utils/Utils";
+import {StarknetTransactions, StarknetTx} from "./modules/StarknetTransactions";
+import {StarknetFees} from "./modules/StarknetFees";
+import {StarknetAddresses} from "./modules/StarknetAddresses";
+import {StarknetTokens} from "./modules/StarknetTokens";
+import {StarknetEvents} from "./modules/StarknetEvents";
+import {StarknetSignatures} from "./modules/StarknetSignatures";
+import {StarknetAccounts} from "./modules/StarknetAccounts";
+import {StarknetBlocks} from "./modules/StarknetBlocks";
+import {ChainInterface, TransactionConfirmationOptions} from "@atomiqlabs/base";
+import {StarknetSigner} from "../wallet/StarknetSigner";
+import {Buffer} from "buffer";
+import {StarknetKeypairWallet} from "../wallet/StarknetKeypairWallet";
+
+export type StarknetRetryPolicy = {
+    maxRetries?: number,
+    delay?: number,
+    exponential?: boolean
+}
+
+export class StarknetChainInterface implements ChainInterface {
+
+    readonly chainId = "STARKNET";
+
+    readonly provider: Provider;
+    readonly retryPolicy: StarknetRetryPolicy;
+
+    public readonly starknetChainId: constants.StarknetChainId;
+
+    public Fees: StarknetFees;
+    public readonly Tokens: StarknetTokens;
+    public readonly Transactions: StarknetTransactions;
+    public readonly Signatures: StarknetSignatures;
+    public readonly Events: StarknetEvents;
+    public readonly Accounts: StarknetAccounts;
+    public readonly Blocks: StarknetBlocks;
+
+    protected readonly logger = getLogger("StarknetChainInterface: ");
+
+    constructor(
+        chainId: constants.StarknetChainId,
+        provider: Provider,
+        retryPolicy?: StarknetRetryPolicy,
+        solanaFeeEstimator: StarknetFees = new StarknetFees(provider)
+    ) {
+        this.starknetChainId = chainId;
+        this.provider = provider;
+        this.retryPolicy = retryPolicy;
+
+        this.Fees = solanaFeeEstimator;
+        this.Tokens = new StarknetTokens(this);
+        this.Transactions = new StarknetTransactions(this);
+
+        this.Signatures = new StarknetSignatures(this);
+        this.Events = new StarknetEvents(this);
+        this.Accounts = new StarknetAccounts(this);
+        this.Blocks = new StarknetBlocks(this);
+    }
+
+    async getBalance(signer: string, tokenAddress: string): Promise<bigint> {
+        //TODO: For native token we should discount the cost of deploying an account if it is not deployed yet
+        return await this.Tokens.getTokenBalance(signer, tokenAddress);
+    }
+
+    getNativeCurrencyAddress(): string {
+        return this.Tokens.getNativeCurrencyAddress();
+    }
+
+    isValidToken(tokenIdentifier: string): boolean {
+        return this.Tokens.isValidToken(tokenIdentifier);
+    }
+
+    isValidAddress(address: string): boolean {
+        return StarknetAddresses.isValidAddress(address);
+    }
+
+    ///////////////////////////////////
+    //// Callbacks & handlers
+    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean {
+        return true;
+    }
+
+    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void {}
+
+    onBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): void {
+        this.Transactions.onBeforeTxSigned(callback);
+    }
+
+    offBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): boolean {
+        return this.Transactions.offBeforeTxSigned(callback);
+    }
+
+    randomAddress(): string {
+        return toHex(stark.randomAddress());
+    }
+
+    randomSigner(): StarknetSigner {
+        const privateKey = "0x"+Buffer.from(ec.starkCurve.utils.randomPrivateKey()).toString("hex");
+        const wallet = new StarknetKeypairWallet(this.provider, privateKey);
+        return new StarknetSigner(wallet);
+    }
+
+    ////////////////////////////////////////////
+    //// Transactions
+    sendAndConfirm(
+        signer: StarknetSigner,
+        txs: StarknetTx[],
+        waitForConfirmation?: boolean,
+        abortSignal?: AbortSignal,
+        parallel?: boolean,
+        onBeforePublish?: (txId: string, rawTx: string) => Promise<void>
+    ): Promise<string[]> {
+        return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
+    }
+
+    serializeTx(tx: StarknetTx): Promise<string> {
+        return this.Transactions.serializeTx(tx);
+    }
+
+    deserializeTx(txData: string): Promise<StarknetTx> {
+        return this.Transactions.deserializeTx(txData);
+    }
+
+    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
+        return this.Transactions.getTxIdStatus(txId);
+    }
+
+    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
+        return this.Transactions.getTxStatus(tx);
+    }
+
+    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<StarknetTx[]> {
+        return this.Tokens.txsTransfer(signer, token, amount, dstAddress, feeRate);
+    }
+
+    async transfer(
+        signer: StarknetSigner,
+        token: string,
+        amount: bigint,
+        dstAddress: string,
+        txOptions?: TransactionConfirmationOptions
+    ): Promise<string> {
+        const txs = await this.Tokens.txsTransfer(signer.getAddress(), token, amount, dstAddress, txOptions?.feeRate);
+        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
+        return txId;
+    }
+
+}

package/src/starknet/{base → chain}/StarknetModule.ts

@@ -1,16 +1,16 @@
 import {Provider} from "starknet";
-import {StarknetBase, StarknetRetryPolicy} from "./StarknetBase";
+import {StarknetChainInterface, StarknetRetryPolicy} from "./StarknetChainInterface";
 import {getLogger} from "../../utils/Utils";
 
 export class StarknetModule {
     protected readonly provider: Provider;
     protected readonly retryPolicy: StarknetRetryPolicy;
-    protected readonly root: StarknetBase;
+    protected readonly root: StarknetChainInterface;
 
     protected readonly logger = getLogger(this.constructor.name+": ");
 
     constructor(
-        root: StarknetBase
+        root: StarknetChainInterface
     ) {
         this.provider = root.provider;
         this.retryPolicy = root.retryPolicy;

package/src/starknet/{base → chain}/modules/StarknetAddresses.ts

@@ -10,7 +10,7 @@ export class StarknetAddresses extends StarknetModule {
      *
      * @param value
      */
-    isValidAddress(value: string): boolean {
+    static isValidAddress(value: string): boolean {
         if(value.length!==66) return false;
         try {
             validateAndParseAddress(value);

package/src/starknet/{base → chain}/modules/StarknetSignatures.ts

@@ -8,7 +8,7 @@ import {
     StarknetDomain, StarknetType,
     TypedData
 } from "starknet";
-import {StarknetBase} from "../StarknetBase";
+import {StarknetChainInterface} from "../StarknetChainInterface";
 import {toHex} from "../../../utils/Utils";
 import {sha256} from "@noble/hashes/sha2";
 
@@ -27,7 +27,7 @@ export class StarknetSignatures extends StarknetModule {
 
     private readonly domain: StarknetDomain;
 
-    constructor(root: StarknetBase, domainName: string = "atomiq.exchange") {
+    constructor(root: StarknetChainInterface, domainName: string = "atomiq.exchange") {
         super(root);
         this.domain = {
             name: domainName,

package/src/starknet/{base → chain}/modules/StarknetTokens.ts

@@ -3,6 +3,7 @@ import {StarknetAction} from "../StarknetAction";
 import {ERC20Abi} from "./ERC20Abi";
 import { Contract } from "starknet";
 import {toBigInt} from "../../../utils/Utils";
+import {StarknetAddresses} from "./StarknetAddresses";
 
 
 export class StarknetTokens extends StarknetModule {
@@ -63,7 +64,7 @@ export class StarknetTokens extends StarknetModule {
      * @param token
      */
     public isValidToken(token: string) {
-        return this.root.Addresses.isValidAddress(token);
+        return StarknetAddresses.isValidAddress(token);
     }
 
     /**

package/src/starknet/{base → chain}/modules/StarknetTransactions.ts

@@ -6,7 +6,7 @@ import {
     BigNumberish
 } from "starknet";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
-import {calculateHash, timeoutPromise, toHex, tryWithRetries} from "../../../utils/Utils";
+import {calculateHash, timeoutPromise, toBigInt, toHex, tryWithRetries} from "../../../utils/Utils";
 
 export type StarknetTx = ({
     type: "DEPLOY_ACCOUNT",
@@ -23,6 +23,8 @@ export type StarknetTx = ({
 
 export class StarknetTransactions extends StarknetModule {
 
+    private readonly latestConfirmedNonces: {[address: string]: bigint} = {};
+
     private cbkBeforeTxSigned: (tx: StarknetTx) => Promise<void>;
 
     /**
@@ -37,12 +39,19 @@ export class StarknetTransactions extends StarknetModule {
         let state = "pending";
         while(state==="pending" || state==="not_found") {
             await timeoutPromise(3000, abortSignal);
-            state = await this.getTxIdStatus(tx.txId);
-            if(state==="not_found" && tx.signed!=null) await this.sendSignedTransaction(tx, undefined, undefined, false).catch(e => {
+            state = await this._getTxIdStatus(tx.txId);
+            if(state==="not_found" && tx.signed!=null) await this.sendSignedTransaction(tx).catch(e => {
                 if(e.baseError?.code === 59) return; //Transaction already in the mempool
                 console.error("Error on transaction re-send: ", e);
             });
         }
+        if(state!=="rejected") {
+            const nextAccountNonce = toBigInt(tx.details.nonce) + 1n;
+            const currentNonce = this.latestConfirmedNonces[tx.details.walletAddress];
+            if(currentNonce==null || nextAccountNonce > currentNonce) {
+                this.latestConfirmedNonces[tx.details.walletAddress] = nextAccountNonce;
+            }
+        }
         if(state==="reverted") throw new Error("Transaction reverted!");
     }
 
@@ -55,6 +64,11 @@ export class StarknetTransactions extends StarknetModule {
      */
     private async prepareTransactions(signer: StarknetSigner, txs: StarknetTx[]): Promise<void> {
         let nonce: bigint = await signer.getNonce();
+        const latestConfirmedNonce = this.latestConfirmedNonces[signer.getAddress()];
+        if(latestConfirmedNonce!=null && latestConfirmedNonce > nonce) {
+            console.debug("StarknetTransactions: prepareTransactions(): Using nonce from local cache!");
+            nonce = latestConfirmedNonce;
+        }
         if(nonce===BigInt(0) && signer.isWalletAccount()) {
             //Just increment the nonce by one and hope the wallet is smart enough to deploy account first
             nonce = BigInt(1);
@@ -84,14 +98,12 @@ export class StarknetTransactions extends StarknetModule {
      * @param tx Starknet tx to send
      * @param onBeforePublish a callback called before every transaction is published
      * @param signer
-     * @param retryOnSubmissionFailure
      * @private
      */
     private async sendSignedTransaction(
         tx: StarknetTx,
         onBeforePublish?: (txId: string, rawTx: string) => Promise<void>,
-        signer?: StarknetSigner,
-        retryOnSubmissionFailure: boolean = true
+        signer?: StarknetSigner
     ): Promise<string> {
         if(onBeforePublish!=null) await onBeforePublish(tx.txId, await this.serializeTx(tx));
         this.logger.debug("sendSignedTransaction(): sending transaction: ", tx);
@@ -112,16 +124,17 @@ export class StarknetTransactions extends StarknetModule {
             return txHash;
         }
 
-        const txResult = await tryWithRetries(() => {
-            switch(tx.type) {
-                case "INVOKE":
-                    return this.provider.channel.invoke(tx.signed, tx.details).then(res => res.transaction_hash);
-                case "DEPLOY_ACCOUNT":
-                    return this.provider.channel.deployAccount(tx.signed, tx.details).then((res: any) => res.transaction_hash);
-                default:
-                    throw new Error("Unsupported tx type!");
-            }
-        }, retryOnSubmissionFailure ? this.retryPolicy : {maxRetries: 1});
+        let txResult: string;
+        switch(tx.type) {
+            case "INVOKE":
+                txResult = await this.provider.channel.invoke(tx.signed, tx.details).then(res => res.transaction_hash);
+                break;
+            case "DEPLOY_ACCOUNT":
+                txResult = await this.provider.channel.deployAccount(tx.signed, tx.details).then((res: any) => res.transaction_hash);
+                break;
+            default:
+                throw new Error("Unsupported tx type!");
+        }
         if(tx.txId!==txResult) this.logger.warn("sendSignedTransaction(): sent tx hash not matching the precomputed hash!");
         this.logger.info("sendSignedTransaction(): tx sent, expected txHash: "+tx.txId+", txHash: "+txResult);
         return txResult;
@@ -229,19 +242,31 @@ export class StarknetTransactions extends StarknetModule {
      *
      * @param txId
      */
-    public async getTxIdStatus(txId: string): Promise<"pending" | "success" | "not_found" | "reverted"> {
+    public async _getTxIdStatus(txId: string): Promise<"pending" | "success" | "not_found" | "reverted" | "rejected"> {
         const status = await this.provider.getTransactionStatus(txId).catch(e => {
             if(e.message!=null && e.message.includes("29: Transaction hash not found")) return null;
             throw e;
         });
         if(status==null) return "not_found";
         if(status.finality_status==="RECEIVED") return "pending";
-        if(status.finality_status!=="REJECTED" && status.execution_status==="SUCCEEDED"){
+        if(status.finality_status==="REJECTED") return "rejected";
+        if(status.execution_status==="SUCCEEDED"){
             return "success";
         }
         return "reverted";
     }
 
+    /**
+     * Gets the status of the starknet transaction with a specific txId
+     *
+     * @param txId
+     */
+    public async getTxIdStatus(txId: string): Promise<"pending" | "success" | "not_found" | "reverted"> {
+        const status = await this._getTxIdStatus(txId);
+        if(status==="rejected") return "reverted";
+        return status;
+    }
+
     public onBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): void {
         this.cbkBeforeTxSigned = callback;
     }