starknet 4.8.0 → 4.10.0

package/dist/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/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.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/dist/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/provider/default.d.ts

@@ -1,5 +1,6 @@
 import { StarknetChainId } from '../constants';
-import { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, ContractClass, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse } from '../types';
+import { DeclareContractTransaction, DeployAccountContractTransaction } from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { RpcProviderOptions } from './rpc';
@@ -16,7 +17,8 @@ export declare class Provider implements ProviderInterface {
     getChainId(): Promise<StarknetChainId>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
-    getEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getInvokeEstimateFee(invocationWithTxType: 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>;
@@ -24,7 +26,10 @@ export declare class Provider implements ProviderInterface {
     callContract(request: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
     invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
     deployContract(payload: DeployContractPayload): Promise<DeployContractResponse>;
-    declareContract(payload: DeclareContractPayload): Promise<DeclareContractResponse>;
+    deployAccountContract(payload: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
+    declareContract(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
+    getDeclareEstimateFee(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getDeployAccountEstimateFee(transaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
     waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }

package/dist/provider/default.js

@@ -84,11 +84,19 @@ var Provider = /** @class */ (function () {
             });
         });
     };
-    Provider.prototype.getEstimateFee = function (invocation, invocationDetails, blockIdentifier) {
+    Provider.prototype.getEstimateFee = function (invocationWithTxType, invocationDetails, blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.provider.getEstimateFee(invocation, invocationDetails, blockIdentifier)];
+                return [2 /*return*/, this.provider.getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier)];
+            });
+        });
+    };
+    Provider.prototype.getInvokeEstimateFee = function (invocationWithTxType, invocationDetails, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.provider.getInvokeEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier)];
             });
         });
     };
@@ -143,13 +151,32 @@ var Provider = /** @class */ (function () {
             });
         });
     };
-    Provider.prototype.declareContract = function (payload) {
+    Provider.prototype.deployAccountContract = function (payload, details) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.provider.declareContract(payload)];
+                return [2 /*return*/, this.provider.deployAccountContract(payload, details)];
             });
         });
     };
+    Provider.prototype.declareContract = function (transaction, details) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.provider.declareContract(transaction, details)];
+            });
+        });
+    };
+    Provider.prototype.getDeclareEstimateFee = function (transaction, details, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier)];
+            });
+        });
+    };
+    Provider.prototype.getDeployAccountEstimateFee = function (transaction, details, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return this.provider.getDeployAccountEstimateFee(transaction, details, blockIdentifier);
+    };
     Provider.prototype.getCode = function (contractAddress, blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {

package/dist/provider/interface.d.ts

@@ -1,5 +1,6 @@
 import { StarknetChainId } from '../constants';
-import type { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse } from '../types';
+import type { Call, CallContractResponse, ContractClass, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse } from '../types';
+import { DeclareContractTransaction, DeployAccountContractPayload, DeployAccountContractTransaction } from '../types/lib';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
 export declare abstract class ProviderInterface {
@@ -78,14 +79,15 @@ export declare abstract class ProviderInterface {
      */
     abstract deployContract(payload: DeployContractPayload): Promise<DeployContractResponse>;
     /**
-     * Declares a given compiled contract (json) to starknet
+     * Deploys a given compiled Account contract (json) to starknet
      *
      * @param payload payload to be deployed containing:
      * - compiled contract code
-     * - optional version
+     * - constructor calldata
+     * - address salt
      * @returns a confirmation of sending a transaction on the starknet contract
      */
-    abstract declareContract(payload: DeclareContractPayload): Promise<DeclareContractResponse>;
+    abstract deployAccountContract(payload: DeployAccountContractPayload, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
     /**
      * Invokes a function on starknet
      * @deprecated This method wont be supported as soon as fees are mandatory
@@ -103,7 +105,21 @@ export declare abstract class ProviderInterface {
      */
     abstract invokeFunction(invocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
     /**
-     * Estimates the fee for a given transaction
+     * Declares a given compiled contract (json) to starknet
+     * @param transaction transaction payload to be deployed containing:
+     * - compiled contract code
+     * - sender address
+     * - signature
+     * @param details Invocation Details containing:
+     * - nonce
+     * - optional version
+     * - optional maxFee
+     * @returns a confirmation of sending a transaction on the starknet contract
+     */
+    abstract declareContract(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
+    /**
+     * Estimates the fee for a given INVOKE transaction
+     * @deprecated Please use getInvokeEstimateFee or getDeclareEstimateFee instead
      *
      * @param invocation the invocation object containing:
      * - contractAddress - the address of the contract
@@ -117,6 +133,52 @@ export declare abstract class ProviderInterface {
      * @returns the estimated fee
      */
     abstract getEstimateFee(invocation: Invocation, details: InvocationsDetailsWithNonce, blockIdentifier: BlockIdentifier): Promise<EstimateFeeResponse>;
+    /**
+     * Estimates the fee for a given INVOKE transaction
+     *
+     * @param invocation the invocation object containing:
+     * - contractAddress - the address of the contract
+     * - entrypoint - the entrypoint of the contract
+     * - calldata - (defaults to []) the calldata
+     * - signature - (defaults to []) the signature
+     * @param blockIdentifier - block identifier
+     * @param details - optional details containing:
+     * - nonce - optional nonce
+     * - version - optional version
+     * @returns the estimated fee
+     */
+    abstract getInvokeEstimateFee(invocation: Invocation, details: InvocationsDetailsWithNonce, blockIdentifier: BlockIdentifier): Promise<EstimateFeeResponse>;
+    /**
+     * Estimates the fee for a given DECLARE transaction
+     *
+     * @param transaction transaction payload to be declared containing:
+     * - compiled contract code
+     * - sender address
+     * - signature - (defaults to []) the signature
+     * @param details - optional details containing:
+     * - nonce
+     * - version - optional version
+     * - optional maxFee
+     * @param blockIdentifier - block identifier
+     * @returns the estimated fee
+     */
+    abstract getDeclareEstimateFee(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier: BlockIdentifier): Promise<EstimateFeeResponse>;
+    /**
+     * Estimates the fee for a given DEPLOY_ACCOUNT transaction
+     *
+     * @param transaction transaction payload to be deployed containing:
+     * - classHash
+     * - constructorCalldata
+     * - addressSalt
+     * - signature - (defaults to []) the signature
+     * @param details - optional details containing:
+     * - nonce
+     * - version - optional version
+     * - optional maxFee
+     * @param blockIdentifier - block identifier
+     * @returns the estimated fee
+     */
+    abstract getDeployAccountEstimateFee(transaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier: BlockIdentifier): Promise<EstimateFeeResponse>;
     /**
      * Wait for the transaction to be accepted
      * @param txHash - transaction hash

package/dist/provider/rpc.d.ts

@@ -1,16 +1,19 @@
 import { StarknetChainId } from '../constants';
-import { Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetailsWithNonce, InvokeFunctionResponse } from '../types';
 import { RPC } from '../types/api';
+import { DeclareContractTransaction, DeployAccountContractPayload, DeployAccountContractTransaction } from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { BlockIdentifier } from './utils';
 export declare type RpcProviderOptions = {
     nodeUrl: string;
     retries?: number;
+    headers?: object;
 };
 export declare class RpcProvider implements ProviderInterface {
     nodeUrl: string;
     chainId: StarknetChainId;
+    headers: object;
     private responseParser;
     private retries;
     constructor(optionsOrProvider: RpcProviderOptions);
@@ -33,11 +36,15 @@ export declare class RpcProvider implements ProviderInterface {
     getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.GetTransactionByBlockIdAndIndex>;
     getTransactionReceipt(txHash: string): Promise<GetTransactionReceiptResponse>;
     getClass(classHash: RPC.Felt): Promise<RPC.ContractClass>;
-    getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): 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>;
+    getInvokeEstimateFee(invocation: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getDeclareEstimateFee({ senderAddress, contractDefinition, signature }: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    getDeployAccountEstimateFee({ classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
+    declareContract({ contractDefinition, signature, senderAddress }: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
     deployContract({ contract, constructorCalldata, addressSalt, }: DeployContractPayload): Promise<DeployContractResponse>;
+    deployAccountContract({ classHash, constructorCalldata, addressSalt, }: DeployAccountContractPayload): Promise<DeployContractResponse>;
     invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
     callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
     traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace>;