@atomiqlabs/chain-starknet 8.1.13 → 8.2.3

package/dist/starknet/btcrelay/StarknetBtcRelay.js

@@ -23,7 +23,7 @@ function serializeBlockHeader(e) {
     });
 }
 const GAS_PER_BLOCKHEADER = { l1DataGas: 600, l2Gas: 24000000, l1Gas: 0 };
-const GAS_PER_BLOCKHEADER_FORK = { l1DataGas: 1000, l2Gas: 40000000, l1Gas: 0 };
+const GAS_PER_BLOCKHEADER_FORK_REORG = { l1DataGas: 1000, l2Gas: 4000000, l1Gas: 0 };
 const btcRelayAddreses = {
     [base_1.BitcoinNetwork.TESTNET4]: "0x0099b63f39f0cabb767361de3d8d3e97212351a51540e2687c2571f4da490dbe",
     [base_1.BitcoinNetwork.TESTNET]: "0x068601c79da2231d21e015ccfd59c243861156fa523a12c9f987ec28eb8dbc8c",
@@ -94,7 +94,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
             contractAddress: this.contract.address,
             entrypoint: "submit_fork_blockheaders",
             calldata: serializeCalldata(forkHeaders, storedHeader, [(0, Utils_1.toHex)(forkId)])
-        }, StarknetFees_1.StarknetFees.starknetGasAdd(StarknetFees_1.StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length), StarknetFees_1.StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)));
+        }, StarknetFees_1.StarknetFees.starknetGasAdd(StarknetFees_1.StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length), StarknetFees_1.StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER_FORK_REORG, totalForkHeaders)));
     }
     constructor(chainInterface, bitcoinRpc, bitcoinNetwork, contractAddress = btcRelayAddreses[bitcoinNetwork], contractDeploymentHeight) {
         if (contractAddress == null)
@@ -104,7 +104,7 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
                 ? btcRelayDeploymentHeights[bitcoinNetwork]
                 : undefined));
         this.maxHeadersPerTx = 40;
-        this.maxForkHeadersPerTx = 30;
+        this.maxForkHeadersPerTx = 25;
         this.maxShortForkHeadersPerTx = 40;
         this._bitcoinRpc = bitcoinRpc;
     }

package/dist/starknet/chain/StarknetChainInterface.d.ts

@@ -117,6 +117,10 @@ export declare class StarknetChainInterface implements ChainInterface<StarknetTx
      * @inheritDoc
      */
     sendSignedAndConfirm(signedTxs: SignedStarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * @inheritDoc
+     */
+    prepareTxs(txs: StarknetTx[]): Promise<StarknetTx[]>;
     /**
      * @inheritDoc
      */

package/dist/starknet/chain/StarknetChainInterface.js

@@ -123,6 +123,13 @@ class StarknetChainInterface {
     sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
         return this.Transactions.sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
     }
+    /**
+     * @inheritDoc
+     */
+    async prepareTxs(txs) {
+        await this.Transactions.prepareTransactions(txs);
+        return txs;
+    }
     /**
      * @inheritDoc
      */

package/dist/starknet/chain/modules/StarknetTransactions.d.ts

@@ -90,13 +90,15 @@ export declare class StarknetTransactions extends StarknetModule {
      */
     private confirmTransaction;
     /**
-     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed
+     *  & calls beforeTxSigned callback (only if signer is passed!)
      *
      * @param signer
      * @param txs
-     * @private
      */
-    private prepareTransactions;
+    prepareTransactions(txs: (StarknetTx & {
+        addedInPrepare?: boolean;
+    })[], signer?: StarknetSigner): Promise<void>;
     /**
      * Sends out a signed transaction to the RPC
      *

package/dist/starknet/chain/modules/StarknetTransactions.js

@@ -214,29 +214,45 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
         return result.txId;
     }
     /**
-     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed
+     *  & calls beforeTxSigned callback (only if signer is passed!)
      *
      * @param signer
      * @param txs
-     * @private
      */
-    async prepareTransactions(signer, txs) {
-        let nonce = await this.getNonce(signer.getAddress());
-        const latestPendingNonce = this.latestPendingNonces[(0, Utils_1.toHex)(signer.getAddress())];
+    async prepareTransactions(txs, signer) {
+        if (txs.length === 0)
+            return;
+        const signerAddress = signer?.getAddress() ?? txs[0].details.walletAddress;
+        if (signerAddress == null)
+            throw new Error("Cannot get tx sender address!");
+        let nonce = await this.getNonce(signerAddress);
+        const latestPendingNonce = this.latestPendingNonces[(0, Utils_1.toHex)(signerAddress)];
         if (latestPendingNonce != null && latestPendingNonce > nonce) {
             this.logger.debug("prepareTransactions(): Using 'pending' nonce from local cache!");
             nonce = latestPendingNonce;
         }
         //Add deploy account tx
         if (nonce === 0n) {
-            const deployPayload = await signer.getDeployPayload();
-            if (deployPayload != null) {
-                const tx = await this.root.Accounts.getAccountDeployTransaction(deployPayload);
+            if (signer != null) {
+                const deployPayload = await signer.getDeployPayload();
+                if (deployPayload != null) {
+                    const tx = await this.root.Accounts.getAccountDeployTransaction(deployPayload);
+                    tx.addedInPrepare = true;
+                    txs.unshift(tx);
+                }
+            }
+            else {
+                // Use a 0x0 class hash to indicate that deployment is needed by external signer
+                const tx = await this.root.Accounts.getAccountDeployTransaction({
+                    classHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    contractAddress: signerAddress
+                });
                 tx.addedInPrepare = true;
                 txs.unshift(tx);
             }
         }
-        if (!signer.isManagingNoncesInternally) {
+        if (signer == null || !signer.isManagingNoncesInternally) {
             if (nonce === 0n) {
                 //Just increment the nonce by one and hope the wallet is smart enough to deploy account first
                 nonce = 1n;
@@ -246,18 +262,19 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
                 if (tx.details.nonce != null)
                     nonce = BigInt(tx.details.nonce); //Take the nonce from last tx
                 if (nonce == null)
-                    nonce = BigInt(await this.root.provider.getNonceForAddress(signer.getAddress())); //Fetch the nonce
+                    nonce = BigInt(await this.root.provider.getNonceForAddress(signerAddress)); //Fetch the nonce
                 if (tx.details.nonce == null)
                     tx.details.nonce = nonce;
                 this.logger.debug("prepareTransactions(): transaction prepared (" + (i + 1) + "/" + txs.length + "), nonce: " + tx.details.nonce);
                 nonce += BigInt(1);
             }
         }
-        for (let tx of txs) {
-            for (let callback of this.cbksBeforeTxSigned) {
-                await callback(tx);
+        if (signer != null)
+            for (let tx of txs) {
+                for (let callback of this.cbksBeforeTxSigned) {
+                    await callback(tx);
+                }
             }
-        }
     }
     /**
      * Sends out a signed transaction to the RPC
@@ -293,13 +310,14 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
      */
     async sendAndConfirm(signer, _txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
         const txs = _txs;
-        await this.prepareTransactions(signer, txs);
+        await this.prepareTransactions(txs, signer);
         const signedTxs = [];
         //Don't separate the signing process from the sending when using browser-based wallet
         if (signer.signTransaction != null)
             for (let i = 0; i < txs.length; i++) {
                 const tx = txs[i];
                 const signedTx = await signer.signTransaction(tx);
+                (0, Utils_1.calculateHash)(signedTx);
                 signedTx.addedInPrepare = tx.addedInPrepare;
                 signedTxs.push(signedTx);
                 this.logger.debug("sendAndConfirm(): transaction signed (" + (i + 1) + "/" + txs.length + "): " + signedTx.txId);
@@ -384,9 +402,10 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
         return txIds;
     }
     async sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
-        signedTxs.forEach(val => {
-            if (val.signed == null)
+        signedTxs.forEach(tx => {
+            if (tx.signed == null)
                 throw new Error("Transactions have to be signed!");
+            (0, Utils_1.calculateHash)(tx);
         });
         this.logger.debug("sendSignedAndConfirm(): sending transactions, count: " + signedTxs.length +
             " waitForConfirmation: " + waitForConfirmation + " parallel: " + parallel);

package/dist/utils/Utils.js

@@ -113,11 +113,11 @@ function calculateHash(tx) {
         case "DEPLOY_ACCOUNT":
             if (tx.signed.constructorCalldata == null ||
                 tx.signed.addressSalt == null ||
-                tx.tx.contractAddress == null)
+                tx.details.walletAddress == null)
                 throw new Error("TX not enough data to compute hash!");
             const deployAccountData = starknet_1.CallData.compile(tx.signed.constructorCalldata);
             return tx.txId = starknet_1.hash.calculateDeployAccountTransactionHash({
-                contractAddress: tx.tx.contractAddress,
+                contractAddress: tx.details.walletAddress,
                 classHash: tx.signed.classHash,
                 compiledConstructorCalldata: deployAccountData,
                 salt: tx.signed.addressSalt,

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "8.1.13",
+  "version": "8.2.3",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
+    "build": "npx -y -p typescript@4.9 tsc",
     "prepublishOnly": "npm run build",
     "test": "echo \"Error: no test specified\" && exit 1",
     "build:ts4": "npx -p typescript@4.9 tsc --noEmit",
@@ -31,7 +31,7 @@
     "url": "git+https://github.com/atomiqlabs/atomiq-chain-starknet.git"
   },
   "dependencies": {
-    "@atomiqlabs/base": "^13.1.14",
+    "@atomiqlabs/base": "^13.2.0",
     "@noble/hashes": "^1.7.1",
     "@scure/btc-signer": "^1.6.0",
     "abi-wan-kanabi": "2.2.4",

package/src/starknet/btcrelay/StarknetBtcRelay.ts

@@ -29,7 +29,7 @@ function serializeBlockHeader(e: BtcBlock): StarknetBtcHeader {
 }
 
 const GAS_PER_BLOCKHEADER = {l1DataGas: 600, l2Gas: 24_000_000, l1Gas: 0};
-const GAS_PER_BLOCKHEADER_FORK = {l1DataGas: 1000, l2Gas: 40_000_000, l1Gas: 0};
+const GAS_PER_BLOCKHEADER_FORK_REORG = {l1DataGas: 1000, l2Gas: 4_000_000, l1Gas: 0};
 
 const btcRelayAddreses: {[network in BitcoinNetwork]?: string} = {
     [BitcoinNetwork.TESTNET4]: "0x0099b63f39f0cabb767361de3d8d3e97212351a51540e2687c2571f4da490dbe",
@@ -121,7 +121,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
             },
             StarknetFees.starknetGasAdd(
                 StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length),
-                StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)
+                StarknetFees.starknetGasMul(GAS_PER_BLOCKHEADER_FORK_REORG, totalForkHeaders)
             )
         )
     }
@@ -132,7 +132,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
     readonly _bitcoinRpc: BitcoinRpc<B>;
 
     readonly maxHeadersPerTx: number = 40;
-    readonly maxForkHeadersPerTx: number = 30;
+    readonly maxForkHeadersPerTx: number = 25;
     readonly maxShortForkHeadersPerTx: number = 40;
 
     constructor(

package/src/starknet/chain/StarknetChainInterface.ts

@@ -211,6 +211,14 @@ export class StarknetChainInterface implements ChainInterface<StarknetTx, Signed
         return this.Transactions.sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
     }
 
+    /**
+     * @inheritDoc
+     */
+    async prepareTxs(txs: StarknetTx[]): Promise<StarknetTx[]> {
+        await this.Transactions.prepareTransactions(txs);
+        return txs;
+    }
+
     /**
      * @inheritDoc
      */

package/src/starknet/chain/modules/StarknetTransactions.ts

@@ -13,10 +13,11 @@ import {
     CallData,
     Calldata,
     ResourceBounds,
-    ResourceBoundsBN
+    ResourceBoundsBN, RawArgs
 } from "starknet";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
 import {
+    calculateHash,
     deserializeResourceBounds,
     deserializeSignature,
     NoBigInt,
@@ -304,15 +305,19 @@ export class StarknetTransactions extends StarknetModule {
     }
 
     /**
-     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed
+     *  & calls beforeTxSigned callback (only if signer is passed!)
      *
      * @param signer
      * @param txs
-     * @private
      */
-    private async prepareTransactions(signer: StarknetSigner, txs: (StarknetTx & {addedInPrepare?: boolean})[]): Promise<void> {
-        let nonce: bigint = await this.getNonce(signer.getAddress());
-        const latestPendingNonce = this.latestPendingNonces[toHex(signer.getAddress())];
+    public async prepareTransactions(txs: (StarknetTx & {addedInPrepare?: boolean})[], signer?: StarknetSigner): Promise<void> {
+        if(txs.length===0) return;
+        const signerAddress = signer?.getAddress() ?? txs[0].details.walletAddress;
+        if(signerAddress==null) throw new Error("Cannot get tx sender address!");
+
+        let nonce: bigint = await this.getNonce(signerAddress);
+        const latestPendingNonce = this.latestPendingNonces[toHex(signerAddress)];
         if(latestPendingNonce!=null && latestPendingNonce > nonce) {
             this.logger.debug("prepareTransactions(): Using 'pending' nonce from local cache!");
             nonce = latestPendingNonce;
@@ -320,15 +325,25 @@ export class StarknetTransactions extends StarknetModule {
 
         //Add deploy account tx
         if(nonce===0n) {
-            const deployPayload = await signer.getDeployPayload();
-            if(deployPayload!=null) {
-                const tx: (StarknetTx & {addedInPrepare?: boolean}) = await this.root.Accounts.getAccountDeployTransaction(deployPayload);
+            if(signer!=null) {
+                const deployPayload = await signer.getDeployPayload();
+                if(deployPayload!=null) {
+                    const tx: (StarknetTx & {addedInPrepare?: boolean}) = await this.root.Accounts.getAccountDeployTransaction(deployPayload);
+                    tx.addedInPrepare = true;
+                    txs.unshift(tx);
+                }
+            } else {
+                // Use a 0x0 class hash to indicate that deployment is needed by external signer
+                const tx: (StarknetTx & {addedInPrepare?: boolean}) = await this.root.Accounts.getAccountDeployTransaction({
+                    classHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    contractAddress: signerAddress
+                });
                 tx.addedInPrepare = true;
                 txs.unshift(tx);
             }
         }
 
-        if(!signer.isManagingNoncesInternally) {
+        if(signer==null || !signer.isManagingNoncesInternally) {
             if(nonce===0n) {
                 //Just increment the nonce by one and hope the wallet is smart enough to deploy account first
                 nonce = 1n;
@@ -337,7 +352,7 @@ export class StarknetTransactions extends StarknetModule {
             for(let i=0;i<txs.length;i++) {
                 const tx = txs[i];
                 if(tx.details.nonce!=null) nonce = BigInt(tx.details.nonce); //Take the nonce from last tx
-                if(nonce==null) nonce = BigInt(await this.root.provider.getNonceForAddress(signer.getAddress())); //Fetch the nonce
+                if(nonce==null) nonce = BigInt(await this.root.provider.getNonceForAddress(signerAddress)); //Fetch the nonce
                 if(tx.details.nonce==null) tx.details.nonce = nonce;
 
                 this.logger.debug("prepareTransactions(): transaction prepared ("+(i+1)+"/"+txs.length+"), nonce: "+tx.details.nonce);
@@ -346,7 +361,7 @@ export class StarknetTransactions extends StarknetModule {
             }
         }
 
-        for(let tx of txs) {
+        if(signer!=null) for(let tx of txs) {
             for(let callback of this.cbksBeforeTxSigned) {
                 await callback(tx);
             }
@@ -389,13 +404,14 @@ export class StarknetTransactions extends StarknetModule {
      */
     public async sendAndConfirm(signer: StarknetSigner, _txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]> {
         const txs: (StarknetTx & {addedInPrepare?: boolean})[] = _txs;
-        await this.prepareTransactions(signer, txs);
+        await this.prepareTransactions(txs, signer);
         const signedTxs: (StarknetTx & {addedInPrepare?: boolean})[] = [];
 
         //Don't separate the signing process from the sending when using browser-based wallet
         if(signer.signTransaction!=null) for(let i=0;i<txs.length;i++) {
             const tx = txs[i];
             const signedTx: (StarknetTx & {addedInPrepare?: boolean}) = await signer.signTransaction(tx);
+            calculateHash(signedTx);
             signedTx.addedInPrepare = tx.addedInPrepare;
             signedTxs.push(signedTx);
             this.logger.debug("sendAndConfirm(): transaction signed ("+(i+1)+"/"+txs.length+"): "+signedTx.txId);
@@ -486,8 +502,9 @@ export class StarknetTransactions extends StarknetModule {
         signedTxs: SignedStarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal,
         parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>
     ): Promise<string[]> {
-        signedTxs.forEach(val => {
-            if(val.signed==null) throw new Error("Transactions have to be signed!");
+        signedTxs.forEach(tx => {
+            if(tx.signed==null) throw new Error("Transactions have to be signed!");
+            calculateHash(tx);
         });
 
         this.logger.debug("sendSignedAndConfirm(): sending transactions, count: "+signedTxs.length+

package/src/utils/Utils.ts

@@ -155,12 +155,12 @@ export function calculateHash(tx: StarknetTx): string {
             if(
                 tx.signed.constructorCalldata==null ||
                 tx.signed.addressSalt==null ||
-                tx.tx.contractAddress==null
+                tx.details.walletAddress==null
             ) throw new Error("TX not enough data to compute hash!");
 
             const deployAccountData = CallData.compile(tx.signed.constructorCalldata);
             return tx.txId = hash.calculateDeployAccountTransactionHash({
-                contractAddress: tx.tx.contractAddress,
+                contractAddress: tx.details.walletAddress,
                 classHash: tx.signed.classHash,
                 compiledConstructorCalldata: deployAccountData,
                 salt: tx.signed.addressSalt,