starknet 4.5.0 → 4.7.0

package/dist/account/default.js

@@ -75,62 +75,54 @@ var Account = /** @class */ (function (_super) {
     __extends(Account, _super);
     function Account(providerOrOptions, address, keyPairOrSigner) {
         var _this = _super.call(this, providerOrOptions) || this;
-        _this.address = address;
+        _this.address = address.toLowerCase();
         _this.signer =
             'getPubKey' in keyPairOrSigner ? keyPairOrSigner : new signer_1.Signer(keyPairOrSigner);
         return _this;
     }
-    Account.prototype.getNonce = function () {
+    Account.prototype.getNonce = function (blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
-            var result;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.callContract({
-                            contractAddress: this.address,
-                            entrypoint: 'get_nonce',
-                        })];
-                    case 1:
-                        result = (_a.sent()).result;
-                        return [2 /*return*/, (0, number_1.toHex)((0, number_1.toBN)(result[0]))];
-                }
+                return [2 /*return*/, _super.prototype.getNonce.call(this, this.address, blockIdentifier)];
             });
         });
     };
     Account.prototype.estimateFee = function (calls, _a) {
         var _b = _a === void 0 ? {} : _a, providedNonce = _b.nonce, blockIdentifier = _b.blockIdentifier;
         return __awaiter(this, void 0, void 0, function () {
-            var transactions, nonce, _c, version, chainId, signerDetails, signature, calldata, response, suggestedMaxFee;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var transactions, nonce, _c, _d, version, chainId, signerDetails, signature, calldata, response, suggestedMaxFee;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         transactions = Array.isArray(calls) ? calls : [calls];
+                        _c = number_1.toBN;
                         if (!(providedNonce !== null && providedNonce !== void 0)) return [3 /*break*/, 1];
-                        _c = providedNonce;
+                        _d = providedNonce;
                         return [3 /*break*/, 3];
                     case 1: return [4 /*yield*/, this.getNonce()];
                     case 2:
-                        _c = (_d.sent());
-                        _d.label = 3;
+                        _d = (_e.sent());
+                        _e.label = 3;
                     case 3:
-                        nonce = _c;
-                        version = (0, number_1.toBN)(hash_1.feeTransactionVersion);
+                        nonce = _c.apply(void 0, [_d]);
+                        version = (0, number_1.toBN)(hash_1.transactionVersion);
                         return [4 /*yield*/, this.getChainId()];
                     case 4:
-                        chainId = _d.sent();
+                        chainId = _e.sent();
                         signerDetails = {
                             walletAddress: this.address,
-                            nonce: (0, number_1.toBN)(nonce),
+                            nonce: nonce,
                             maxFee: constants_1.ZERO,
                             version: version,
                             chainId: chainId,
                         };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails)];
                     case 5:
-                        signature = _d.sent();
-                        calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, nonce);
-                        return [4 /*yield*/, _super.prototype.getEstimateFee.call(this, { contractAddress: this.address, entrypoint: '__execute__', calldata: calldata, signature: signature }, blockIdentifier, { version: version })];
+                        signature = _e.sent();
+                        calldata = (0, transaction_1.fromCallsToExecuteCalldata)(transactions);
+                        return [4 /*yield*/, _super.prototype.getEstimateFee.call(this, { contractAddress: this.address, calldata: calldata, signature: signature }, { version: version, nonce: nonce }, blockIdentifier)];
                     case 6:
-                        response = _d.sent();
+                        response = _e.sent();
                         suggestedMaxFee = (0, stark_1.estimatedFeeToMaxFee)(response.overall_fee);
                         return [2 /*return*/, __assign(__assign({}, response), { suggestedMaxFee: suggestedMaxFee })];
                 }
@@ -191,8 +183,9 @@ var Account = /** @class */ (function (_super) {
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
                     case 8:
                         signature = _d.sent();
-                        calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, nonce);
-                        return [2 /*return*/, this.invokeFunction({ contractAddress: this.address, entrypoint: '__execute__', calldata: calldata, signature: signature }, {
+                        calldata = (0, transaction_1.fromCallsToExecuteCalldata)(transactions);
+                        return [2 /*return*/, this.invokeFunction({ contractAddress: this.address, calldata: calldata, signature: signature }, {
+                                nonce: nonce,
                                 maxFee: maxFee,
                                 version: version,
                             })];
@@ -246,7 +239,7 @@ var Account = /** @class */ (function (_super) {
                         _b.trys.push([0, 2, , 3]);
                         return [4 /*yield*/, this.callContract({
                                 contractAddress: this.address,
-                                entrypoint: 'is_valid_signature',
+                                entrypoint: 'isValidSignature',
                                 calldata: (0, stark_1.compileCalldata)({
                                     hash: (0, number_1.toBN)(hash).toString(),
                                     signature: signature.map(function (x) { return (0, number_1.toBN)(x).toString(); }),

package/dist/account/interface.d.ts

@@ -1,4 +1,5 @@
 import { ProviderInterface } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import { Abi, Call, EstimateFeeDetails, EstimateFeeResponse, InvocationsDetails, InvokeFunctionResponse, Signature } from '../types';
 import { BigNumberish } from '../utils/number';
@@ -68,5 +69,5 @@ export declare abstract class AccountInterface extends ProviderInterface {
      * @throws {Error} if the signature is not a valid signature
      */
     abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
-    abstract getNonce(): Promise<string>;
+    abstract getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
 }

package/dist/contract/contractFactory.d.ts

@@ -1,7 +1,6 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
 import { Abi, CompiledContract, RawCalldata } from '../types';
-import { BigNumberish } from '../utils/number';
 import { Contract } from './default';
 export declare class ContractFactory {
     abi: Abi;
@@ -15,7 +14,7 @@ export declare class ContractFactory {
      * @param addressSalt (optional) - Address Salt for deployment
      * @returns deployed Contract
      */
-    deploy(constructorCalldata?: RawCalldata, addressSalt?: BigNumberish): Promise<Contract>;
+    deploy(constructorCalldata?: RawCalldata, addressSalt?: string | undefined): Promise<Contract>;
     /**
      * Attaches to new Provider or Account
      *

package/dist/contract/default.d.ts

@@ -1,7 +1,7 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
 import { BlockIdentifier } from '../provider/utils';
-import { Abi, AbiEntry, Args, AsyncContractFunction, Calldata, ContractFunction, Invocation, InvokeFunctionResponse, Overrides, ParsedStruct, Result, StructAbi } from '../types';
+import { Abi, AbiEntry, Args, AsyncContractFunction, Call, Calldata, ContractFunction, InvokeFunctionResponse, Overrides, ParsedStruct, Result, StructAbi } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ContractInterface } from './interface';
 export declare class Contract implements ContractInterface {
@@ -120,5 +120,5 @@ export declare class Contract implements ContractInterface {
         blockIdentifier?: BlockIdentifier;
     }): Promise<Result>;
     estimate(method: string, args?: Array<any>): Promise<import("../types").EstimateFeeResponse>;
-    populate(method: string, args?: Array<any>): Invocation;
+    populate(method: string, args?: Array<any>): Call;
 }

package/dist/contract/default.js

@@ -181,7 +181,7 @@ var Contract = /** @class */ (function () {
     function Contract(abi, address, providerOrAccount) {
         if (providerOrAccount === void 0) { providerOrAccount = provider_1.defaultProvider; }
         var _this = this;
-        this.address = address;
+        this.address = address.toLowerCase();
         this.providerOrAccount = providerOrAccount;
         this.abi = abi;
         this.structs = abi
@@ -592,9 +592,14 @@ var Contract = /** @class */ (function () {
                 nonce: options.nonce,
             });
         }
+        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 ".concat(method, " without an account. This will not work on a public node."));
-        return this.providerOrAccount.invokeFunction(__assign(__assign({}, invocation), { signature: options.signature || [] }));
+        return this.providerOrAccount.invokeFunction(__assign(__assign({}, invocation), { signature: options.signature || [] }), {
+            nonce: options.nonce,
+        });
     };
     Contract.prototype.call = function (method, args, _a) {
         if (args === void 0) { args = []; }
@@ -644,7 +649,6 @@ var Contract = /** @class */ (function () {
             contractAddress: this.address,
             entrypoint: method,
             calldata: this.compileCalldata(args, inputs),
-            signature: [],
         };
     };
     return Contract;

package/dist/provider/default.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { RpcProviderOptions } from './rpc';
@@ -16,12 +16,13 @@ export declare class Provider implements ProviderInterface {
     getChainId(): Promise<StarknetChainId>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
-    getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;
+    getEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getNonce(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     callContract(request: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
-    invokeFunction(functionInvocation: Invocation, details: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
     deployContract(payload: DeployContractPayload): Promise<DeployContractResponse>;
     declareContract(payload: DeclareContractPayload): Promise<DeclareContractResponse>;
     getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;

package/dist/provider/default.js

@@ -84,12 +84,18 @@ var Provider = /** @class */ (function () {
             });
         });
     };
-    Provider.prototype.getEstimateFee = function (invocation, blockIdentifier, invocationDetails) {
+    Provider.prototype.getEstimateFee = function (invocation, invocationDetails, blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
-        if (invocationDetails === void 0) { invocationDetails = {}; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.provider.getEstimateFee(invocation, blockIdentifier, invocationDetails)];
+                return [2 /*return*/, this.provider.getEstimateFee(invocation, invocationDetails, blockIdentifier)];
+            });
+        });
+    };
+    Provider.prototype.getNonce = function (contractAddress, blockIdentifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.provider.getNonce(contractAddress, blockIdentifier)];
             });
         });
     };

package/dist/provider/interface.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import type { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import type { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse } from '../types';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
 export declare abstract class ProviderInterface {
@@ -37,6 +37,13 @@ export declare abstract class ProviderInterface {
      * @returns Contract class of compiled contract
      */
     abstract getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
+    /**
+     * Gets the nonce of a contract with respect to a specific block
+     *
+     * @param contractAddress - contract address
+     * @returns the hex nonce
+     */
+    abstract getNonce(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     /**
      * Gets the contract's storage variable at a specific key.
      *
@@ -94,7 +101,7 @@ export declare abstract class ProviderInterface {
      * - maxFee - optional maxFee
      * @returns response from addTransaction
      */
-    abstract invokeFunction(invocation: Invocation, details?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    abstract invokeFunction(invocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
     /**
      * Estimates the fee for a given transaction
      *
@@ -109,7 +116,7 @@ export declare abstract class ProviderInterface {
      * - version - optional version
      * @returns the estimated fee
      */
-    abstract getEstimateFee(invocation: Invocation, blockIdentifier: BlockIdentifier, details?: InvocationsDetails): Promise<EstimateFeeResponse>;
+    abstract getEstimateFee(invocation: Invocation, details: InvocationsDetailsWithNonce, blockIdentifier: BlockIdentifier): Promise<EstimateFeeResponse>;
     /**
      * Wait for the transaction to be accepted
      * @param txHash - transaction hash

package/dist/provider/rpc.d.ts

@@ -1,36 +1,48 @@
 import { StarknetChainId } from '../constants';
-import { Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse } from '../types';
 import { RPC } from '../types/api';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { BlockIdentifier } from './utils';
 export declare type RpcProviderOptions = {
     nodeUrl: string;
+    retries?: number;
 };
 export declare class RpcProvider implements ProviderInterface {
     nodeUrl: string;
     chainId: StarknetChainId;
     private responseParser;
+    private retries;
     constructor(optionsOrProvider: RpcProviderOptions);
-    protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, request?: RPC.Methods[T]['REQUEST']): Promise<RPC.Methods[T]['RESPONSE']>;
-    getChainId(): Promise<StarknetChainId>;
+    fetch(method: any, params: any): Promise<any>;
+    protected errorHandler(error: any): void;
+    protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, params?: RPC.Methods[T]['params']): Promise<RPC.Methods[T]['result']>;
+    getChainId(): Promise<any>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
+    getBlockHashAndNumber(): Promise<RPC.BlockHashAndNumber>;
     getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxHashesResponse>;
     getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxs>;
-    getNonce(contractAddress: string): Promise<any>;
+    getClassHashAt(blockIdentifier: BlockIdentifier, contractAddress: RPC.ContractAddress): Promise<RPC.Felt>;
+    getNonce(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<RPC.Nonce>;
+    getPendingTransactions(): Promise<RPC.PendingTransactions>;
+    getProtocolVersion(): Promise<Error>;
+    getStateUpdate(blockIdentifier: BlockIdentifier): Promise<RPC.StateUpdate>;
     getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
-    getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
-    getTransactionByHash(txHash: BigNumberish): Promise<RPC.GetTransactionByHashResponse>;
+    getTransaction(txHash: string): Promise<GetTransactionResponse>;
+    getTransactionByHash(txHash: string): Promise<RPC.GetTransactionByHashResponse>;
     getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.GetTransactionByBlockIdAndIndex>;
-    getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
-    getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<any>;
-    getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;
+    getTransactionReceipt(txHash: string): Promise<GetTransactionReceiptResponse>;
+    getClass(classHash: RPC.Felt): Promise<RPC.ContractClass>;
+    getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<RPC.ContractClass>;
+    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
+    getEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     declareContract({ contract, version, }: DeclareContractPayload): Promise<DeclareContractResponse>;
     deployContract({ contract, constructorCalldata, addressSalt, }: DeployContractPayload): Promise<DeployContractResponse>;
-    invokeFunction(functionInvocation: Invocation, details: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
     callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
-    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
-    waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace>;
+    traceBlockTransactions(blockHash: RPC.BlockHash): Promise<RPC.Traces>;
+    waitForTransaction(txHash: string, retryInterval?: number): Promise<void>;
     /**
      * Gets the transaction count from a block.
      *