starknet 3.18.2 → 4.0.1

package/dist/provider/interface.d.ts

@@ -1,88 +1,55 @@
 import { StarknetChainId } from '../constants';
-import type { AddTransactionResponse, Call, CallContractResponse, DeployContractPayload, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionResponse, GetTransactionStatusResponse, Invocation, TransactionReceiptResponse } from '../types';
+import type { BlockTag, Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
 export declare abstract class ProviderInterface {
-    abstract baseUrl: string;
-    abstract feederGatewayUrl: string;
-    abstract gatewayUrl: string;
     abstract chainId: StarknetChainId;
-    /**
-     * Gets the smart contract address on the goerli testnet.
-     *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L13-L15)
-     * @returns starknet smart contract addresses
-     */
-    abstract getContractAddresses(): Promise<GetContractAddressesResponse>;
     /**
      * Calls a function on the StarkNet contract.
      *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L25-L39)
-     *
-     * @param invokeTransaction transaction to be invoked
+     * @param call transaction to be called
      * @param blockIdentifier block identifier
      * @returns the result of the function on the smart contract.
      */
-    abstract callContract(invokeTransaction: Call, options: {
-        blockIdentifier: BlockIdentifier;
-    }): Promise<CallContractResponse>;
+    abstract callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
     /**
      * Gets the block information
      *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L41-L53)
-     *
      * @param blockIdentifier block identifier
-     * @returns the block object { block_number, previous_block_number, state_root, status, timestamp, transaction_receipts, transactions }
+     * @returns the block object
      */
-    abstract getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
+    abstract getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
     /**
-     * Gets the code of the deployed contract.
-     *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L55-L68)
+     * Gets the contract class of the deployed contract.
      *
      * @param contractAddress - contract address
      * @param blockIdentifier - block identifier
-     * @returns Bytecode and ABI of compiled contract
+     * @returns Contract class of compiled contract
      */
-    abstract getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
+    abstract getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     /**
      * Gets the contract's storage variable at a specific key.
      *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L70-L85)
-     *
      * @param contractAddress
      * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-     * @param blockIdentifier - block identifier
+     * @param blockHashOrTag - block hash or tag (pending, latest)
      * @returns the value of the storage variable
      */
-    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<object>;
-    /**
-     * Gets the status of a transaction.
-     *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L48-L52)
-     *
-     * @param txHash
-     * @returns the transaction status object { block_number, tx_status: NOT_RECEIVED | RECEIVED | PENDING | REJECTED | ACCEPTED_ONCHAIN }
-     */
-    abstract getTransactionStatus(txHash: BigNumberish): Promise<GetTransactionStatusResponse>;
+    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
     /**
      * Gets the transaction information from a tx id.
      *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L54-L58)
-     *
      * @param txHash
      * @returns the transacton object { transaction_id, status, transaction, block_number?, block_number?, transaction_index?, transaction_failure_reason? }
      */
-    abstract getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
+    abstract getTransaction(transactionHash: BigNumberish): Promise<GetTransactionResponse>;
     /**
      * Gets the transaction receipt from a tx hash.
      *
-     * [Reference] (https://github.com/starkware-libs/cairo-lang/blob/167b28bcd940fd25ea3816204fa882a0b0a49603/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L183)
-     *
      * @param txHash
      * @returns the transaction receipt object
      */
-    abstract getTransactionReceipt(txHash: BigNumberish): Promise<TransactionReceiptResponse>;
+    abstract getTransactionReceipt(transactionHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     /**
      * Deploys a given compiled contract (json) to starknet
      *
@@ -92,7 +59,16 @@ export declare abstract class ProviderInterface {
      * - address salt
      * @returns a confirmation of sending a transaction on the starknet contract
      */
-    abstract deployContract(payload: DeployContractPayload): Promise<AddTransactionResponse>;
+    abstract deployContract(payload: DeployContractPayload): Promise<DeployContractResponse>;
+    /**
+     * Declares a given compiled contract (json) to starknet
+     *
+     * @param payload payload to be deployed containing:
+     * - compiled contract code
+     * - optional version
+     * @returns a confirmation of sending a transaction on the starknet contract
+     */
+    abstract declareContract(payload: DeclareContractPayload): Promise<DeclareContractResponse>;
     /**
      * Invokes a function on starknet
      * @deprecated This method wont be supported as soon as fees are mandatory
@@ -102,13 +78,32 @@ export declare abstract class ProviderInterface {
      * - entrypoint - the entrypoint of the contract
      * - calldata - (defaults to []) the calldata
      * - signature - (defaults to []) the signature
-     *
+     * @param details - optional details containing:
+     * - nonce - optional nonce
+     * - version - optional version
+     * - maxFee - optional maxFee
      * @returns response from addTransaction
      */
-    abstract invokeFunction(invocation: Invocation): Promise<AddTransactionResponse>;
-    abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    abstract invokeFunction(invocation: Invocation, details?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    /**
+     * Estimates the fee for a given 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 getEstimateFee(invocation: Invocation, blockIdentifier: BlockIdentifier, details?: InvocationsDetails): Promise<EstimateFeeResponse>;
     /**
-     * @deprecated use `waitForTransaction` instead
+     * Wait for the transaction to be accepted
+     * @param txHash - transaction hash
+     * @param retryInterval - retry interval
      */
     abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }

package/dist/provider/rpc.d.ts

@@ -0,0 +1,57 @@
+import { StarknetChainId } from '../constants';
+import { BlockTag, Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, 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;
+};
+export declare class RpcProvider implements ProviderInterface {
+    nodeUrl: string;
+    chainId: StarknetChainId;
+    private responseParser;
+    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>;
+    getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
+    getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
+    getClassAt(contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<any>;
+    getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;
+    declareContract({ contract, version, }: DeclareContractPayload): Promise<DeclareContractResponse>;
+    deployContract({ contract, constructorCalldata, addressSalt, }: DeployContractPayload): Promise<DeployContractResponse>;
+    invokeFunction(functionInvocation: Invocation, details: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
+    waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    /**
+     * Gets the transaction count from a block.
+     *
+     *
+     * @param blockIdentifier
+     * @returns Number of transactions
+     */
+    getTransactionCount(blockIdentifier: BlockIdentifier): Promise<RPC.GetTransactionCountResponse>;
+    /**
+     * Gets the latest block number
+     *
+     *
+     * @returns Number of the latest block
+     */
+    getBlockNumber(): Promise<RPC.GetBlockNumberResponse>;
+    /**
+     * Gets syncing status of the node
+     *
+     *
+     * @returns Object with the stats data
+     */
+    getSyncingStats(): Promise<RPC.GetSyncingStatsResponse>;
+    /**
+     * Gets all the events filtered
+     *
+     *
+     * @returns events and the pagination of the events
+     */
+    getEvents(eventFilter: RPC.EventFilter): Promise<RPC.GetEventsResponse>;
+}

package/dist/provider/rpc.js

@@ -0,0 +1,364 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcProvider = void 0;
+var fetchPonyfill_1 = __importDefault(require("../utils/fetchPonyfill"));
+var hash_1 = require("../utils/hash");
+var json_1 = require("../utils/json");
+var number_1 = require("../utils/number");
+var provider_1 = require("../utils/provider");
+var rpc_1 = require("../utils/responseParser/rpc");
+var stark_1 = require("../utils/stark");
+var RpcProvider = /** @class */ (function () {
+    function RpcProvider(optionsOrProvider) {
+        var _this = this;
+        this.responseParser = new rpc_1.RPCResponseParser();
+        var nodeUrl = optionsOrProvider.nodeUrl;
+        this.nodeUrl = nodeUrl;
+        this.getChainId().then(function (chainId) {
+            _this.chainId = chainId;
+        });
+    }
+    RpcProvider.prototype.fetchEndpoint = function (method, request) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var requestData, rawResult, _b, error, result, code, message, error_1, data;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        requestData = {
+                            method: method,
+                            jsonrpc: '2.0',
+                            params: request,
+                            id: 0,
+                        };
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, (0, fetchPonyfill_1.default)(this.nodeUrl, {
+                                method: 'POST',
+                                body: (0, json_1.stringify)(requestData),
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                },
+                            })];
+                    case 2:
+                        rawResult = _c.sent();
+                        return [4 /*yield*/, rawResult.json()];
+                    case 3:
+                        _b = _c.sent(), error = _b.error, result = _b.result;
+                        if (error) {
+                            code = error.code, message = error.message;
+                            throw new Error("".concat(code, ": ").concat(message));
+                        }
+                        else {
+                            return [2 /*return*/, result];
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _c.sent();
+                        data = (_a = error_1 === null || error_1 === void 0 ? void 0 : error_1.response) === null || _a === void 0 ? void 0 : _a.data;
+                        if (data === null || data === void 0 ? void 0 : data.message) {
+                            throw new Error("".concat(data.code, ": ").concat(data.message));
+                        }
+                        throw error_1;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RpcProvider.prototype.getChainId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_chainId')];
+            });
+        });
+    };
+    RpcProvider.prototype.getBlock = function (blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var method;
+            return __generator(this, function (_a) {
+                method = typeof blockIdentifier === 'string' && (0, number_1.isHex)(blockIdentifier)
+                    ? 'starknet_getBlockByHash'
+                    : 'starknet_getBlockByNumber';
+                return [2 /*return*/, this.fetchEndpoint(method, [blockIdentifier]).then(this.responseParser.parseGetBlockResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.getStorageAt = function (contractAddress, key, blockHashOrTag) {
+        if (blockHashOrTag === void 0) { blockHashOrTag = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var parsedKey;
+            return __generator(this, function (_a) {
+                parsedKey = (0, number_1.toHex)((0, number_1.toBN)(key));
+                return [2 /*return*/, this.fetchEndpoint('starknet_getStorageAt', [
+                        contractAddress,
+                        parsedKey,
+                        blockHashOrTag,
+                    ])];
+            });
+        });
+    };
+    RpcProvider.prototype.getTransaction = function (txHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [txHash]).then(this.responseParser.parseGetTransactionResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.getTransactionReceipt = function (txHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionReceipt', [txHash]).then(this.responseParser.parseGetTransactionReceiptResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.getClassAt = function (contractAddress, _blockIdentifier) {
+        if (_blockIdentifier === void 0) { _blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getClassAt', [contractAddress])];
+            });
+        });
+    };
+    RpcProvider.prototype.getEstimateFee = function (invocation, blockIdentifier, invocationDetails) {
+        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.fetchEndpoint('starknet_estimateFee', [
+                        {
+                            contract_address: invocation.contractAddress,
+                            entry_point_selector: (0, hash_1.getSelectorFromName)(invocation.entrypoint),
+                            calldata: (0, provider_1.parseCalldata)(invocation.calldata),
+                            signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(invocation.signature || []),
+                            version: (0, number_1.toHex)((0, number_1.toBN)((invocationDetails === null || invocationDetails === void 0 ? void 0 : invocationDetails.version) || 0)),
+                        },
+                        blockIdentifier,
+                    ]).then(this.responseParser.parseFeeEstimateResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.declareContract = function (_a) {
+        var contract = _a.contract, version = _a.version;
+        return __awaiter(this, void 0, void 0, function () {
+            var contractDefinition;
+            return __generator(this, function (_b) {
+                contractDefinition = (0, provider_1.parseContract)(contract);
+                return [2 /*return*/, this.fetchEndpoint('starknet_addDeclareTransaction', [
+                        {
+                            program: contractDefinition.program,
+                            entry_points_by_type: contractDefinition.entry_points_by_type,
+                        },
+                        (0, number_1.toHex)((0, number_1.toBN)(version || 0)),
+                    ]).then(this.responseParser.parseDeclareContractResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.deployContract = function (_a) {
+        var contract = _a.contract, constructorCalldata = _a.constructorCalldata, addressSalt = _a.addressSalt;
+        return __awaiter(this, void 0, void 0, function () {
+            var contractDefinition;
+            return __generator(this, function (_b) {
+                contractDefinition = (0, provider_1.parseContract)(contract);
+                return [2 /*return*/, this.fetchEndpoint('starknet_addDeployTransaction', [
+                        addressSalt !== null && addressSalt !== void 0 ? addressSalt : (0, stark_1.randomAddress)(),
+                        (0, number_1.bigNumberishArrayToDecimalStringArray)(constructorCalldata !== null && constructorCalldata !== void 0 ? constructorCalldata : []),
+                        {
+                            program: contractDefinition.program,
+                            entry_points_by_type: contractDefinition.entry_points_by_type,
+                        },
+                    ]).then(this.responseParser.parseDeployContractResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.invokeFunction = function (functionInvocation, details) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_addInvokeTransaction', [
+                        {
+                            contract_address: functionInvocation.contractAddress,
+                            entry_point_selector: (0, hash_1.getSelectorFromName)(functionInvocation.entrypoint),
+                            calldata: (0, provider_1.parseCalldata)(functionInvocation.calldata),
+                        },
+                        (0, number_1.bigNumberishArrayToDecimalStringArray)(functionInvocation.signature || []),
+                        (0, number_1.toHex)((0, number_1.toBN)(details.maxFee || 0)),
+                        (0, number_1.toHex)((0, number_1.toBN)(details.version || 0)),
+                    ]).then(this.responseParser.parseInvokeFunctionResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.callContract = function (call, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.fetchEndpoint('starknet_call', [
+                            {
+                                contract_address: call.contractAddress,
+                                entry_point_selector: (0, hash_1.getSelectorFromName)(call.entrypoint),
+                                calldata: (0, provider_1.parseCalldata)(call.calldata),
+                            },
+                            blockIdentifier,
+                        ])];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, this.responseParser.parseCallContractResponse(result)];
+                }
+            });
+        });
+    };
+    RpcProvider.prototype.waitForTransaction = function (txHash, retryInterval) {
+        if (retryInterval === void 0) { retryInterval = 8000; }
+        return __awaiter(this, void 0, void 0, function () {
+            var onchain, retries, successStates, errorStates, res, message, error, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        onchain = false;
+                        retries = 100;
+                        _a.label = 1;
+                    case 1:
+                        if (!!onchain) return [3 /*break*/, 7];
+                        successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
+                        errorStates = ['REJECTED', 'NOT_RECEIVED'];
+                        // eslint-disable-next-line no-await-in-loop
+                        return [4 /*yield*/, (0, provider_1.wait)(retryInterval)];
+                    case 2:
+                        // eslint-disable-next-line no-await-in-loop
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, this.getTransactionReceipt(txHash)];
+                    case 4:
+                        res = _a.sent();
+                        if (successStates.includes(res.status)) {
+                            onchain = true;
+                        }
+                        else if (errorStates.includes(res.status)) {
+                            message = res.status;
+                            error = new Error(message);
+                            error.response = res;
+                            throw error;
+                        }
+                        return [3 /*break*/, 6];
+                    case 5:
+                        error_2 = _a.sent();
+                        if (error_2 instanceof Error && errorStates.includes(error_2.message)) {
+                            throw error_2;
+                        }
+                        if (retries === 0) {
+                            throw error_2;
+                        }
+                        return [3 /*break*/, 6];
+                    case 6:
+                        retries -= 1;
+                        return [3 /*break*/, 1];
+                    case 7: return [4 /*yield*/, (0, provider_1.wait)(retryInterval)];
+                    case 8:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Gets the transaction count from a block.
+     *
+     *
+     * @param blockIdentifier
+     * @returns Number of transactions
+     */
+    RpcProvider.prototype.getTransactionCount = function (blockIdentifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (typeof blockIdentifier === 'number') {
+                    return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCountByNumber', [blockIdentifier])];
+                }
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCountByHash', [blockIdentifier])];
+            });
+        });
+    };
+    /**
+     * Gets the latest block number
+     *
+     *
+     * @returns Number of the latest block
+     */
+    RpcProvider.prototype.getBlockNumber = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_blockNumber')];
+            });
+        });
+    };
+    /**
+     * Gets syncing status of the node
+     *
+     *
+     * @returns Object with the stats data
+     */
+    RpcProvider.prototype.getSyncingStats = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_syncing')];
+            });
+        });
+    };
+    /**
+     * Gets all the events filtered
+     *
+     *
+     * @returns events and the pagination of the events
+     */
+    RpcProvider.prototype.getEvents = function (eventFilter) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getEvents', [eventFilter])];
+            });
+        });
+    };
+    return RpcProvider;
+}());
+exports.RpcProvider = RpcProvider;

package/dist/provider/sequencer.d.ts

@@ -0,0 +1,66 @@
+import { StarknetChainId } from '../constants';
+import { BlockTag, Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { GetContractAddressesResponse, GetTransactionStatusResponse, GetTransactionTraceResponse, Sequencer } from '../types/api';
+import { BigNumberish } from '../utils/number';
+import { ProviderInterface } from './interface';
+import { BlockIdentifier } from './utils';
+declare type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
+export declare type SequencerProviderOptions = {
+    network: NetworkName;
+} | {
+    baseUrl: string;
+    feederGatewayUrl?: string;
+    gatewayUrl?: string;
+    chainId?: StarknetChainId;
+};
+export declare class SequencerProvider implements ProviderInterface {
+    baseUrl: string;
+    feederGatewayUrl: string;
+    gatewayUrl: string;
+    chainId: StarknetChainId;
+    private responseParser;
+    constructor(optionsOrProvider?: SequencerProviderOptions);
+    protected static getNetworkFromName(name: NetworkName): "https://alpha-mainnet.starknet.io" | "https://alpha4.starknet.io";
+    protected static getChainIdFromBaseUrl(baseUrl: string): StarknetChainId;
+    private getFetchUrl;
+    private getFetchMethod;
+    private getQueryString;
+    private getHeaders;
+    protected fetchEndpoint<T extends keyof Sequencer.Endpoints>(endpoint: T, ...[query, request]: Sequencer.Endpoints[T]['QUERY'] extends never ? Sequencer.Endpoints[T]['REQUEST'] extends never ? [] : [undefined, Sequencer.Endpoints[T]['REQUEST']] : Sequencer.Endpoints[T]['REQUEST'] extends never ? [Sequencer.Endpoints[T]['QUERY']] : [Sequencer.Endpoints[T]['QUERY'], Sequencer.Endpoints[T]['REQUEST']]): Promise<Sequencer.Endpoints[T]['RESPONSE']>;
+    callContract({ contractAddress, entrypoint: entryPointSelector, calldata }: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
+    getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
+    getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
+    getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
+    invokeFunction(functionInvocation: Invocation, details: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    deployContract({ contract, constructorCalldata, addressSalt, }: DeployContractPayload): Promise<DeployContractResponse>;
+    declareContract({ contract, }: DeclareContractPayload): Promise<DeclareContractResponse>;
+    getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;
+    waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    /**
+     * Gets the status of a transaction.
+     *
+     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L48-L52)
+     *
+     * @param txHash
+     * @returns the transaction status object { block_number, tx_status: NOT_RECEIVED | RECEIVED | PENDING | REJECTED | ACCEPTED_ONCHAIN }
+     */
+    getTransactionStatus(txHash: BigNumberish): Promise<GetTransactionStatusResponse>;
+    /**
+     * Gets the smart contract address on the goerli testnet.
+     *
+     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L13-L15)
+     * @returns starknet smart contract addresses
+     */
+    getContractAddresses(): Promise<GetContractAddressesResponse>;
+    /**
+     * Gets the transaction trace from a tx id.
+     *
+     *
+     * @param txHash
+     * @returns the transaction trace
+     */
+    getTransactionTrace(txHash: BigNumberish): Promise<GetTransactionTraceResponse>;
+}
+export {};