starknet 4.8.0 → 4.10.0

package/contract/default.d.ts

@@ -33,25 +33,22 @@ export declare class Contract implements ContractInterface {
      * @param providerOrAccount (optional) - Provider or Account to attach to
      */
     constructor(abi: Abi, address: string, providerOrAccount?: ProviderInterface | AccountInterface);
-    /**
-     * Saves the address of the contract deployed on network that will be used for interaction
-     *
-     * @param address - address of the contract
-     */
     attach(address: string): void;
-    /**
-     * Attaches to new Provider or Account
-     *
-     * @param providerOrAccount - new Provider or Account to attach to
-     */
     connect(providerOrAccount: ProviderInterface | AccountInterface): void;
+    deployed(): Promise<Contract>;
+    call(method: string, args?: Array<any>, { blockIdentifier, }?: {
+        blockIdentifier?: BlockIdentifier;
+    }): Promise<Result>;
+    invoke(method: string, args?: Array<any>, options?: Overrides): Promise<InvokeFunctionResponse>;
+    estimate(method: string, args?: Array<any>): Promise<import("../types").EstimateFeeResponse>;
+    populate(method: string, args?: Array<any>): Call;
     /**
-     * Resolves when contract is deployed on the network or when no deployment transaction is found
+     * Deep parse of the object that has been passed to the method
      *
-     * @returns Promise that resolves when contract is deployed on the network or when no deployment transaction is found
-     * @throws When deployment fails
+     * @param struct - struct that needs to be calculated
+     * @return {number} - number of members for the given struct
      */
-    deployed(): Promise<Contract>;
+    private calculateStructMembers;
     /**
      * Validates if all arguments that are passed to the method are corresponding to the ones in the abi
      *
@@ -60,13 +57,6 @@ export declare class Contract implements ContractInterface {
      * @param args - arguments that are passed to the method
      */
     protected validateMethodAndArgs(type: 'INVOKE' | 'CALL', method: string, args?: Array<any>): void;
-    /**
-     * Deep parse of the object that has been passed to the method
-     *
-     * @param struct - struct that needs to be calculated
-     * @return {number} - number of members for the given struct
-     */
-    private calculateStructMembers;
     /**
      * Deep parse of the object that has been passed to the method
      *
@@ -115,10 +105,4 @@ export declare class Contract implements ContractInterface {
      * @return - parsed response corresponding to the abi
      */
     protected parseResponse(method: string, response: string[]): Result;
-    invoke(method: string, args?: Array<any>, options?: Overrides): Promise<InvokeFunctionResponse>;
-    call(method: string, args?: Array<any>, { blockIdentifier, }?: {
-        blockIdentifier?: BlockIdentifier;
-    }): Promise<Result>;
-    estimate(method: string, args?: Array<any>): Promise<import("../types").EstimateFeeResponse>;
-    populate(method: string, args?: Array<any>): Call;
 }

package/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.toLowerCase();
+        this.address = address && address.toLowerCase();
         this.providerOrAccount = providerOrAccount;
         this.abi = abi;
         this.structs = abi
@@ -252,28 +252,12 @@ var Contract = /** @class */ (function () {
             }
         });
     }
-    /**
-     * Saves the address of the contract deployed on network that will be used for interaction
-     *
-     * @param address - address of the contract
-     */
     Contract.prototype.attach = function (address) {
         this.address = address;
     };
-    /**
-     * Attaches to new Provider or Account
-     *
-     * @param providerOrAccount - new Provider or Account to attach to
-     */
     Contract.prototype.connect = function (providerOrAccount) {
         this.providerOrAccount = providerOrAccount;
     };
-    /**
-     * Resolves when contract is deployed on the network or when no deployment transaction is found
-     *
-     * @returns Promise that resolves when contract is deployed on the network or when no deployment transaction is found
-     * @throws When deployment fails
-     */
     Contract.prototype.deployed = function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -290,6 +274,110 @@ var Contract = /** @class */ (function () {
             });
         });
     };
+    Contract.prototype.call = function (method, args, _a) {
+        if (args === void 0) { args = []; }
+        var _b = _a === void 0 ? {} : _a, _c = _b.blockIdentifier, blockIdentifier = _c === void 0 ? 'pending' : _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var inputs, calldata;
+            var _this = this;
+            return __generator(this, function (_d) {
+                // ensure contract is connected
+                (0, minimalistic_assert_1.default)(this.address !== null, 'contract is not connected to an address');
+                // validate method and args
+                this.validateMethodAndArgs('CALL', method, args);
+                inputs = this.abi.find(function (abi) { return abi.name === method; }).inputs;
+                calldata = this.compileCalldata(args, inputs);
+                return [2 /*return*/, this.providerOrAccount
+                        .callContract({
+                        contractAddress: this.address,
+                        calldata: calldata,
+                        entrypoint: method,
+                    }, blockIdentifier)
+                        .then(function (x) { return _this.parseResponse(method, x.result); })];
+            });
+        });
+    };
+    Contract.prototype.invoke = function (method, args, options) {
+        if (args === void 0) { args = []; }
+        if (options === void 0) { options = {}; }
+        // ensure contract is connected
+        (0, minimalistic_assert_1.default)(this.address !== null, 'contract is not connected to an address');
+        // validate method and args
+        this.validateMethodAndArgs('INVOKE', method, args);
+        var inputs = this.abi.find(function (abi) { return abi.name === method; }).inputs;
+        var inputsLength = inputs.reduce(function (acc, input) {
+            if (!/_len$/.test(input.name)) {
+                return acc + 1;
+            }
+            return acc;
+        }, 0);
+        if (args.length !== inputsLength) {
+            throw Error("Invalid number of arguments, expected ".concat(inputsLength, " arguments, but got ").concat(args.length));
+        }
+        // compile calldata
+        var calldata = this.compileCalldata(args, inputs);
+        var invocation = {
+            contractAddress: this.address,
+            calldata: calldata,
+            entrypoint: method,
+        };
+        if ('execute' in this.providerOrAccount) {
+            return this.providerOrAccount.execute(invocation, undefined, {
+                maxFee: options.maxFee,
+                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 || [] }), {
+            nonce: options.nonce,
+        });
+    };
+    Contract.prototype.estimate = function (method, args) {
+        if (args === void 0) { args = []; }
+        return __awaiter(this, void 0, void 0, function () {
+            var invocation;
+            var _a;
+            return __generator(this, function (_b) {
+                // ensure contract is connected
+                (0, minimalistic_assert_1.default)(this.address !== null, 'contract is not connected to an address');
+                // validate method and args
+                this.validateMethodAndArgs('INVOKE', method, args);
+                invocation = (_a = this.populateTransaction)[method].apply(_a, __spreadArray([], __read(args), false));
+                if ('estimateInvokeFee' in this.providerOrAccount) {
+                    return [2 /*return*/, this.providerOrAccount.estimateInvokeFee(invocation)];
+                }
+                throw Error('Contract must be connected to the account contract to estimate');
+            });
+        });
+    };
+    Contract.prototype.populate = function (method, args) {
+        if (args === void 0) { args = []; }
+        var inputs = this.abi.find(function (abi) { return abi.name === method; }).inputs;
+        return {
+            contractAddress: this.address,
+            entrypoint: method,
+            calldata: this.compileCalldata(args, inputs),
+        };
+    };
+    /**
+     * Deep parse of the object that has been passed to the method
+     *
+     * @param struct - struct that needs to be calculated
+     * @return {number} - number of members for the given struct
+     */
+    Contract.prototype.calculateStructMembers = function (struct) {
+        var _this = this;
+        return this.structs[struct].members.reduce(function (acc, member) {
+            if (member.type === 'felt') {
+                return acc + 1;
+            }
+            return acc + _this.calculateStructMembers(member.type);
+        }, 0);
+    };
     /**
      * Validates if all arguments that are passed to the method are corresponding to the ones in the abi
      *
@@ -371,21 +459,6 @@ var Contract = /** @class */ (function () {
             }
         });
     };
-    /**
-     * Deep parse of the object that has been passed to the method
-     *
-     * @param struct - struct that needs to be calculated
-     * @return {number} - number of members for the given struct
-     */
-    Contract.prototype.calculateStructMembers = function (struct) {
-        var _this = this;
-        return this.structs[struct].members.reduce(function (acc, member) {
-            if (member.type === 'felt') {
-                return acc + 1;
-            }
-            return acc + _this.calculateStructMembers(member.type);
-        }, 0);
-    };
     /**
      * Deep parse of the object that has been passed to the method
      *
@@ -562,95 +635,6 @@ var Contract = /** @class */ (function () {
             return acc;
         }, []);
     };
-    Contract.prototype.invoke = function (method, args, options) {
-        if (args === void 0) { args = []; }
-        if (options === void 0) { options = {}; }
-        // ensure contract is connected
-        (0, minimalistic_assert_1.default)(this.address !== null, 'contract isnt connected to an address');
-        // validate method and args
-        this.validateMethodAndArgs('INVOKE', method, args);
-        var inputs = this.abi.find(function (abi) { return abi.name === method; }).inputs;
-        var inputsLength = inputs.reduce(function (acc, input) {
-            if (!/_len$/.test(input.name)) {
-                return acc + 1;
-            }
-            return acc;
-        }, 0);
-        if (args.length !== inputsLength) {
-            throw Error("Invalid number of arguments, expected ".concat(inputsLength, " arguments, but got ").concat(args.length));
-        }
-        // compile calldata
-        var calldata = this.compileCalldata(args, inputs);
-        var invocation = {
-            contractAddress: this.address,
-            calldata: calldata,
-            entrypoint: method,
-        };
-        if ('execute' in this.providerOrAccount) {
-            return this.providerOrAccount.execute(invocation, undefined, {
-                maxFee: options.maxFee,
-                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 || [] }), {
-            nonce: options.nonce,
-        });
-    };
-    Contract.prototype.call = function (method, args, _a) {
-        if (args === void 0) { args = []; }
-        var _b = _a === void 0 ? {} : _a, _c = _b.blockIdentifier, blockIdentifier = _c === void 0 ? 'pending' : _c;
-        return __awaiter(this, void 0, void 0, function () {
-            var inputs, calldata;
-            var _this = this;
-            return __generator(this, function (_d) {
-                // ensure contract is connected
-                (0, minimalistic_assert_1.default)(this.address !== null, 'contract isnt connected to an address');
-                // validate method and args
-                this.validateMethodAndArgs('CALL', method, args);
-                inputs = this.abi.find(function (abi) { return abi.name === method; }).inputs;
-                calldata = this.compileCalldata(args, inputs);
-                return [2 /*return*/, this.providerOrAccount
-                        .callContract({
-                        contractAddress: this.address,
-                        calldata: calldata,
-                        entrypoint: method,
-                    }, blockIdentifier)
-                        .then(function (x) { return _this.parseResponse(method, x.result); })];
-            });
-        });
-    };
-    Contract.prototype.estimate = function (method, args) {
-        if (args === void 0) { args = []; }
-        return __awaiter(this, void 0, void 0, function () {
-            var invocation;
-            var _a;
-            return __generator(this, function (_b) {
-                // ensure contract is connected
-                (0, minimalistic_assert_1.default)(this.address !== null, 'contract isnt connected to an address');
-                // validate method and args
-                this.validateMethodAndArgs('INVOKE', method, args);
-                invocation = (_a = this.populateTransaction)[method].apply(_a, __spreadArray([], __read(args), false));
-                if ('estimateFee' in this.providerOrAccount) {
-                    return [2 /*return*/, this.providerOrAccount.estimateFee(invocation)];
-                }
-                throw Error('Contract must be connected to the account contract to estimate');
-            });
-        });
-    };
-    Contract.prototype.populate = function (method, args) {
-        if (args === void 0) { args = []; }
-        var inputs = this.abi.find(function (abi) { return abi.name === method; }).inputs;
-        return {
-            contractAddress: this.address,
-            entrypoint: method,
-            calldata: this.compileCalldata(args, inputs),
-        };
-    };
     return Contract;
 }());
 exports.Contract = Contract;

package/contract/interface.d.ts

@@ -44,6 +44,7 @@ export declare abstract class ContractInterface {
      *
      * @param method name of the method
      * @param args Array of the arguments for the call
+     * @param options optional blockIdentifier
      * @returns Result of the call as an array with key value pars
      */
     abstract call(method: string, args?: Array<any>, options?: {
@@ -54,14 +55,16 @@ export declare abstract class ContractInterface {
      *
      * @param method name of the method
      * @param args Array of the arguments for the invoke
+     * @param options
      * @returns Add Transaction Response
      */
     abstract invoke(method: string, args?: Array<any>, options?: Overrides): Promise<InvokeFunctionResponse>;
     /**
-     * Calls a method on a contract
+     * Estimates a method on a contract
      *
      * @param method name of the method
      * @param args Array of the arguments for the call
+     * @param options optional blockIdentifier
      */
     abstract estimate(method: string, args?: Array<any>, options?: {
         blockIdentifier?: BlockIdentifier;
@@ -71,7 +74,7 @@ export declare abstract class ContractInterface {
      *
      * @param method name of the method
      * @param args Array of the arguments for the call
-     * @returns Invocation objet
+     * @returns Invocation object
      */
     abstract populate(method: string, args?: Array<any>): Invocation;
 }

package/dist/account/default.d.ts

@@ -2,8 +2,9 @@ import { ProviderInterface, ProviderOptions } from '../provider';
 import { Provider } from '../provider/default';
 import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
-import { Abi, Call, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
+import { Abi, Call, DeclareContractResponse, DeployContractResponse, EstimateFeeAction, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
+import { AllowArray, DeclareContractPayload, DeployAccountContractPayload, UniversalDeployerContractPayload } from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -12,51 +13,18 @@ export declare class Account extends Provider implements AccountInterface {
     address: string;
     constructor(providerOrOptions: ProviderOptions | ProviderInterface, address: string, keyPairOrSigner: KeyPair | SignerInterface);
     getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
-    estimateFee(calls: Call | Call[], { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
-    /**
-     * Invoke execute function in account contract
-     *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
-     *
-     * @param calls - one or more calls to be executed
-     * @param abis - one or more abis which can be used to display the calls
-     * @param transactionsDetail - optional transaction details
-     * @returns a confirmation of invoking a function on the starknet contract
-     */
-    execute(calls: Call | Call[], abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
-    /**
-     * Sign an JSON object with the starknet private key and return the signature
-     *
-     * @param json - JSON object to be signed
-     * @returns the signature of the JSON object
-     * @throws {Error} if the JSON object is not a valid JSON
-     */
+    estimateFee(calls: AllowArray<Call>, estimateFeeDetails?: EstimateFeeDetails | undefined): Promise<EstimateFee>;
+    estimateInvokeFee(calls: AllowArray<Call>, { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
+    estimateDeclareFee({ classHash, contract }: DeclareContractPayload, { blockIdentifier, nonce: providedNonce }?: EstimateFeeDetails): Promise<EstimateFee>;
+    estimateAccountDeployFee({ classHash, addressSalt, constructorCalldata, contractAddress: providedContractAddress, }: DeployAccountContractPayload, { blockIdentifier, nonce: providedNonce }?: EstimateFeeDetails): Promise<EstimateFee>;
+    execute(calls: AllowArray<Call>, abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    declare({ classHash, contract }: DeclareContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeclareContractResponse>;
+    deploy({ classHash, salt, unique, constructorCalldata, isDevnet, }: UniversalDeployerContractPayload, additionalCalls?: AllowArray<Call>, // support multicall
+    transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    deployAccount({ classHash, constructorCalldata, addressSalt, contractAddress: providedContractAddress, }: DeployAccountContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeployContractResponse>;
     signMessage(typedData: TypedData): Promise<Signature>;
-    /**
-     * Hash a JSON object with pederson hash and return the hash
-     *
-     * @param json - JSON object to be hashed
-     * @returns the hash of the JSON object
-     * @throws {Error} if the JSON object is not a valid JSON
-     */
     hashMessage(typedData: TypedData): Promise<string>;
-    /**
-     * Verify a signature of a given hash
-     * @warning This method is not recommended, use verifyMessage instead
-     *
-     * @param hash - JSON object to be verified
-     * @param signature - signature of the JSON object
-     * @returns true if the signature is valid, false otherwise
-     * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature
-     */
     verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
-    /**
-     * Verify a signature of a JSON object
-     *
-     * @param hash - hash to be verified
-     * @param signature - signature of the hash
-     * @returns true if the signature is valid, false otherwise
-     * @throws {Error} if the signature is not a valid signature
-     */
     verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
+    getSuggestedMaxFee(estimateFeeAction: EstimateFeeAction, details: EstimateFeeDetails): Promise<string>;
 }