starknet 4.5.0 → 4.7.0

package/provider/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFormattedBlockIdentifier = exports.getBlockIdentifier = exports.BlockIdentifierClass = exports.txIdentifier = exports.formatHash = void 0;
+exports.Block = exports.txIdentifier = exports.formatHash = void 0;
 var number_1 = require("../utils/number");
 /**
  *
@@ -29,67 +29,56 @@ function txIdentifier(txHash, txId) {
     return "transactionHash=".concat(hashString);
 }
 exports.txIdentifier = txIdentifier;
-var BlockIdentifierClass = /** @class */ (function () {
-    function BlockIdentifierClass(blockIdentifier) {
-        this.blockIdentifier = blockIdentifier;
+var Block = /** @class */ (function () {
+    function Block(_identifier) {
+        var _this = this;
+        this.hash = null;
+        this.number = null;
+        this.tag = null;
+        this.valueOf = function () { return _this.number; };
+        this.toString = function () { return _this.hash; };
+        this.setIdentifier = function (__identifier) {
+            if (typeof __identifier === 'string' && (0, number_1.isHex)(__identifier)) {
+                this.hash = __identifier;
+            }
+            else if (typeof __identifier === 'number') {
+                this.number = __identifier;
+            }
+            else {
+                this.tag = __identifier;
+            }
+        };
+        this.setIdentifier(_identifier);
     }
-    BlockIdentifierClass.prototype.getIdentifier = function () {
-        if (typeof this.blockIdentifier === 'string' && (0, number_1.isHex)(this.blockIdentifier)) {
-            return { block_hash: this.blockIdentifier };
-        }
-        if (typeof this.blockIdentifier === 'number') {
-            return { block_number: this.blockIdentifier };
-        }
-        return this.blockIdentifier;
-    };
-    return BlockIdentifierClass;
+    Object.defineProperty(Block.prototype, "queryIdentifier", {
+        get: function () {
+            if (this.number !== null) {
+                return "blockNumber=".concat(this.number);
+            }
+            if (this.hash !== null) {
+                return "blockHash=".concat(this.hash);
+            }
+            return "blockNumber=".concat(this.tag);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Block.prototype, "identifier", {
+        get: function () {
+            if (this.number !== null) {
+                return { block_number: this.number };
+            }
+            if (this.hash !== null) {
+                return { block_hash: this.hash };
+            }
+            return this.tag;
+        },
+        set: function (_identifier) {
+            this.setIdentifier(_identifier);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Block;
 }());
-exports.BlockIdentifierClass = BlockIdentifierClass;
-/**
- * Identifies the block to be queried.
- *
- * @param blockIdentifier - block identifier
- * @returns block identifier object
- */
-function getBlockIdentifier(blockIdentifier) {
-    if (blockIdentifier === null || blockIdentifier === 'latest') {
-        return { type: 'BLOCK_NUMBER', data: 'latest' }; // default to latest block
-    }
-    if (blockIdentifier === 'pending') {
-        return { type: 'BLOCK_NUMBER', data: 'pending' };
-    }
-    if (typeof blockIdentifier === 'number' || typeof blockIdentifier === 'bigint') {
-        return { type: 'BLOCK_NUMBER', data: blockIdentifier };
-    }
-    if (typeof blockIdentifier === 'string' && blockIdentifier.startsWith('0x')) {
-        return { type: 'BLOCK_HASH', data: blockIdentifier };
-    }
-    if (typeof blockIdentifier === 'string' && !Number.isNaN(parseInt(blockIdentifier, 10))) {
-        return { type: 'BLOCK_NUMBER', data: parseInt(blockIdentifier, 10) };
-    }
-    if (typeof blockIdentifier === 'string') {
-        throw new Error("Invalid block identifier: ".concat(blockIdentifier));
-    }
-    return { type: 'BLOCK_HASH', data: blockIdentifier };
-}
-exports.getBlockIdentifier = getBlockIdentifier;
-/**
- * Gets the block identifier for API request
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L164-L173)
- *
- * @param blockIdentifier
- * @returns block identifier for API request
- */
-function getFormattedBlockIdentifier(blockIdentifier) {
-    if (blockIdentifier === void 0) { blockIdentifier = null; }
-    var blockIdentifierObject = getBlockIdentifier(blockIdentifier);
-    if (blockIdentifierObject.type === 'BLOCK_NUMBER' && blockIdentifierObject.data === null) {
-        return '';
-    }
-    if (blockIdentifierObject.type === 'BLOCK_NUMBER') {
-        return "blockNumber=".concat(blockIdentifierObject.data);
-    }
-    return "blockHash=".concat((0, number_1.toHex)((0, number_1.toBN)(blockIdentifierObject.data)));
-}
-exports.getFormattedBlockIdentifier = getFormattedBlockIdentifier;
+exports.Block = Block;

package/signer/default.d.ts

@@ -1,10 +1,10 @@
-import { Abi, Invocation, InvocationsSignerDetails, KeyPair, Signature } from '../types';
+import { Abi, Call, InvocationsSignerDetails, KeyPair, Signature } from '../types';
 import { TypedData } from '../utils/typedData';
 import { SignerInterface } from './interface';
 export declare class Signer implements SignerInterface {
     protected keyPair: KeyPair;
     constructor(keyPair?: KeyPair);
     getPubKey(): Promise<string>;
-    signTransaction(transactions: Invocation[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
+    signTransaction(transactions: Call[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
     signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
 }

package/signer/default.js

@@ -60,8 +60,8 @@ var Signer = /** @class */ (function () {
                 if (abis && abis.length !== transactions.length) {
                     throw new Error('ABI must be provided for each transaction or no transaction');
                 }
-                calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, transactionsDetail.nonce);
-                msgHash = (0, hash_1.calculcateTransactionHash)(transactionsDetail.walletAddress, transactionsDetail.version, (0, hash_1.getSelectorFromName)('__execute__'), calldata, transactionsDetail.maxFee, transactionsDetail.chainId);
+                calldata = (0, transaction_1.fromCallsToExecuteCalldata)(transactions);
+                msgHash = (0, hash_1.calculateTransactionHash)(transactionsDetail.walletAddress, transactionsDetail.version, calldata, transactionsDetail.maxFee, transactionsDetail.chainId, transactionsDetail.nonce);
                 return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
             });
         });

package/signer/interface.d.ts

@@ -1,4 +1,4 @@
-import { Abi, Invocation, InvocationsSignerDetails, Signature } from '../types';
+import { Abi, Call, InvocationsSignerDetails, Signature } from '../types';
 import { TypedData } from '../utils/typedData';
 export declare abstract class SignerInterface {
     /**
@@ -29,5 +29,5 @@ export declare abstract class SignerInterface {
      *
      * @returns signature
      */
-    abstract signTransaction(transactions: Invocation[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
+    abstract signTransaction(transactions: Call[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
 }

package/src/account/default.ts

@@ -1,6 +1,7 @@
 import { ZERO } from '../constants';
 import { ProviderInterface, ProviderOptions } from '../provider';
 import { Provider } from '../provider/default';
+import { BlockIdentifier } from '../provider/utils';
 import { Signer, SignerInterface } from '../signer';
 import {
   Abi,
@@ -12,32 +13,31 @@ import {
   Signature,
 } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
-import { feeTransactionVersion, transactionVersion } from '../utils/hash';
-import { BigNumberish, toBN, toHex } from '../utils/number';
+import { transactionVersion } from '../utils/hash';
+import { BigNumberish, toBN } from '../utils/number';
 import { compileCalldata, estimatedFeeToMaxFee } from '../utils/stark';
-import { fromCallsToExecuteCalldataWithNonce } from '../utils/transaction';
+import { fromCallsToExecuteCalldata } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { AccountInterface } from './interface';
 
 export class Account extends Provider implements AccountInterface {
   public signer: SignerInterface;
 
+  public address: string;
+
   constructor(
     providerOrOptions: ProviderOptions | ProviderInterface,
-    public address: string,
+    address: string,
     keyPairOrSigner: KeyPair | SignerInterface
   ) {
     super(providerOrOptions);
+    this.address = address.toLowerCase();
     this.signer =
       'getPubKey' in keyPairOrSigner ? keyPairOrSigner : new Signer(keyPairOrSigner as KeyPair);
   }
 
-  public async getNonce(): Promise<string> {
-    const { result } = await this.callContract({
-      contractAddress: this.address,
-      entrypoint: 'get_nonce',
-    });
-    return toHex(toBN(result[0]));
+  public async getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish> {
+    return super.getNonce(this.address, blockIdentifier);
   }
 
   public async estimateFee(
@@ -45,13 +45,13 @@ export class Account extends Provider implements AccountInterface {
     { nonce: providedNonce, blockIdentifier }: EstimateFeeDetails = {}
   ): Promise<EstimateFee> {
     const transactions = Array.isArray(calls) ? calls : [calls];
-    const nonce = providedNonce ?? (await this.getNonce());
-    const version = toBN(feeTransactionVersion);
+    const nonce = toBN(providedNonce ?? (await this.getNonce()));
+    const version = toBN(transactionVersion);
     const chainId = await this.getChainId();
 
     const signerDetails: InvocationsSignerDetails = {
       walletAddress: this.address,
-      nonce: toBN(nonce),
+      nonce,
       maxFee: ZERO,
       version,
       chainId,
@@ -59,11 +59,11 @@ export class Account extends Provider implements AccountInterface {
 
     const signature = await this.signer.signTransaction(transactions, signerDetails);
 
-    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
+    const calldata = fromCallsToExecuteCalldata(transactions);
     const response = await super.getEstimateFee(
-      { contractAddress: this.address, entrypoint: '__execute__', calldata, signature },
-      blockIdentifier,
-      { version }
+      { contractAddress: this.address, calldata, signature },
+      { version, nonce },
+      blockIdentifier
     );
 
     const suggestedMaxFee = estimatedFeeToMaxFee(response.overall_fee);
@@ -112,11 +112,12 @@ export class Account extends Provider implements AccountInterface {
 
     const signature = await this.signer.signTransaction(transactions, signerDetails, abis);
 
-    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
+    const calldata = fromCallsToExecuteCalldata(transactions);
 
     return this.invokeFunction(
-      { contractAddress: this.address, entrypoint: '__execute__', calldata, signature },
+      { contractAddress: this.address, calldata, signature },
       {
+        nonce,
         maxFee,
         version,
       }
@@ -158,7 +159,7 @@ export class Account extends Provider implements AccountInterface {
     try {
       await this.callContract({
         contractAddress: this.address,
-        entrypoint: 'is_valid_signature',
+        entrypoint: 'isValidSignature',
         calldata: compileCalldata({
           hash: toBN(hash).toString(),
           signature: signature.map((x) => toBN(x).toString()),

package/src/account/interface.ts

@@ -1,4 +1,5 @@
 import { ProviderInterface } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import {
   Abi,
@@ -92,5 +93,5 @@ export abstract class AccountInterface extends ProviderInterface {
    */
   public abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
 
-  public abstract getNonce(): Promise<string>;
+  public abstract getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
 }

package/src/contract/contractFactory.ts

@@ -3,7 +3,6 @@ import assert from 'minimalistic-assert';
 import { AccountInterface } from '../account';
 import { ProviderInterface, defaultProvider } from '../provider';
 import { Abi, CompiledContract, RawCalldata } from '../types';
-import { BigNumberish } from '../utils/number';
 import { Contract } from './default';
 
 export class ContractFactory {
@@ -32,7 +31,7 @@ export class ContractFactory {
    */
   public async deploy(
     constructorCalldata?: RawCalldata,
-    addressSalt?: BigNumberish
+    addressSalt?: string | undefined
   ): Promise<Contract> {
     const { contract_address, transaction_hash } = await this.providerOrAccount.deployContract({
       contract: this.compiledContract,

package/src/contract/default.ts

@@ -9,10 +9,10 @@ import {
   AbiEntry,
   Args,
   AsyncContractFunction,
+  Call,
   Calldata,
   ContractFunction,
   FunctionAbi,
-  Invocation,
   InvokeFunctionResponse,
   Overrides,
   ParsedStruct,
@@ -125,7 +125,7 @@ export class Contract implements ContractInterface {
     address: string,
     providerOrAccount: ProviderInterface | AccountInterface = defaultProvider
   ) {
-    this.address = address;
+    this.address = address.toLowerCase();
     this.providerOrAccount = providerOrAccount;
     this.abi = abi;
     this.structs = abi
@@ -578,13 +578,22 @@ export class Contract implements ContractInterface {
       });
     }
 
+    if (!options.nonce) {
+      throw new Error(`Nonce is required when invoking a function without an account`);
+    }
+
     // eslint-disable-next-line no-console
     console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
 
-    return this.providerOrAccount.invokeFunction({
-      ...invocation,
-      signature: options.signature || [],
-    });
+    return this.providerOrAccount.invokeFunction(
+      {
+        ...invocation,
+        signature: options.signature || [],
+      },
+      {
+        nonce: options.nonce,
+      }
+    );
   }
 
   public async call(
@@ -630,13 +639,12 @@ export class Contract implements ContractInterface {
     throw Error('Contract must be connected to the account contract to estimate');
   }
 
-  public populate(method: string, args: Array<any> = []): Invocation {
+  public populate(method: string, args: Array<any> = []): Call {
     const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
     return {
       contractAddress: this.address,
       entrypoint: method,
       calldata: this.compileCalldata(args, inputs),
-      signature: [],
     };
   }
 }

package/src/provider/default.ts

@@ -13,7 +13,7 @@ import {
   GetTransactionReceiptResponse,
   GetTransactionResponse,
   Invocation,
-  InvocationsDetails,
+  InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
 import { BigNumberish } from '../utils/number';
@@ -63,10 +63,17 @@ export class Provider implements ProviderInterface {
 
   public async getEstimateFee(
     invocation: Invocation,
-    blockIdentifier: BlockIdentifier = 'pending',
-    invocationDetails: InvocationsDetails = {}
+    invocationDetails: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<EstimateFeeResponse> {
-    return this.provider.getEstimateFee(invocation, blockIdentifier, invocationDetails);
+    return this.provider.getEstimateFee(invocation, invocationDetails, blockIdentifier);
+  }
+
+  public async getNonce(
+    contractAddress: string,
+    blockIdentifier?: BlockIdentifier
+  ): Promise<BigNumberish> {
+    return this.provider.getNonce(contractAddress, blockIdentifier);
   }
 
   public async getStorageAt(
@@ -94,7 +101,7 @@ export class Provider implements ProviderInterface {
 
   public async invokeFunction(
     functionInvocation: Invocation,
-    details: InvocationsDetails
+    details: InvocationsDetailsWithNonce
   ): Promise<InvokeFunctionResponse> {
     return this.provider.invokeFunction(functionInvocation, details);
   }

package/src/provider/interface.ts

@@ -13,7 +13,7 @@ import type {
   GetTransactionReceiptResponse,
   GetTransactionResponse,
   Invocation,
-  InvocationsDetails,
+  InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
 import type { BigNumberish } from '../utils/number';
@@ -69,6 +69,17 @@ export abstract class ProviderInterface {
     blockIdentifier?: BlockIdentifier
   ): Promise<ContractClass>;
 
+  /**
+   * Gets the nonce of a contract with respect to a specific block
+   *
+   * @param contractAddress - contract address
+   * @returns the hex nonce
+   */
+  public abstract getNonce(
+    contractAddress: string,
+    blockIdentifier?: BlockIdentifier
+  ): Promise<BigNumberish>;
+
   /**
    * Gets the contract's storage variable at a specific key.
    *
@@ -141,7 +152,7 @@ export abstract class ProviderInterface {
    */
   public abstract invokeFunction(
     invocation: Invocation,
-    details?: InvocationsDetails
+    details: InvocationsDetailsWithNonce
   ): Promise<InvokeFunctionResponse>;
 
   /**
@@ -160,8 +171,8 @@ export abstract class ProviderInterface {
    */
   public abstract getEstimateFee(
     invocation: Invocation,
-    blockIdentifier: BlockIdentifier,
-    details?: InvocationsDetails
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier
   ): Promise<EstimateFeeResponse>;
 
   /**