starknet 4.3.0 → 4.4.1

package/dist/provider/default.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { BlockTag, 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, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { RpcProviderOptions } from './rpc';
@@ -16,7 +16,7 @@ export declare class Provider implements ProviderInterface {
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockTagOrHash?: BlockTag | BigNumberish): 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>;

package/dist/provider/default.js

@@ -86,11 +86,11 @@ var Provider = /** @class */ (function () {
             });
         });
     };
-    Provider.prototype.getStorageAt = function (contractAddress, key, blockTagOrHash) {
-        if (blockTagOrHash === void 0) { blockTagOrHash = 'pending'; }
+    Provider.prototype.getStorageAt = function (contractAddress, key, 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.getStorageAt(contractAddress, key, blockTagOrHash)];
+                return [2 /*return*/, this.provider.getStorageAt(contractAddress, key, blockIdentifier)];
             });
         });
     };

package/dist/provider/interface.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import type { BlockTag, 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, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
 export declare abstract class ProviderInterface {
@@ -19,6 +19,9 @@ export declare abstract class ProviderInterface {
      * @returns the block object
      */
     abstract getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
+    /**
+     * @deprecated The method should not be used
+     */
     abstract getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
     /**
      * Gets the contract class of the deployed contract.
@@ -33,10 +36,10 @@ export declare abstract class ProviderInterface {
      *
      * @param contractAddress
      * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-     * @param blockHashOrTag - block hash or tag (pending, latest)
+     * @param blockIdentifier - block identifier
      * @returns the value of the storage variable
      */
-    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier: BlockIdentifier): Promise<BigNumberish>;
     /**
      * Gets the transaction information from a tx id.
      *

package/dist/provider/rpc.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { BlockTag, Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import { RPC } from '../types/api';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
@@ -15,16 +15,21 @@ export declare class RpcProvider implements ProviderInterface {
     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>;
+    getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxHashesResponse>;
+    getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxs>;
+    getNonce(contractAddress: string): Promise<any>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
+    getTransactionByHash(txHash: BigNumberish): Promise<RPC.GetTransactionByHashResponse>;
+    getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.GetTransactionByBlockIdAndIndex>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
-    getClassAt(contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<any>;
+    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>;
-    getCode(contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<RPC.GetCodeResponse>;
+    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
     waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
     /**
      * Gets the transaction count from a block.

package/dist/provider/rpc.js

@@ -47,6 +47,7 @@ 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 utils_1 = require("./utils");
 var RpcProvider = /** @class */ (function () {
     function RpcProvider(optionsOrProvider) {
         var _this = this;
@@ -112,36 +113,78 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
+    // Common Interface
     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)];
+                return [2 /*return*/, this.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseGetBlockResponse)];
             });
         });
     };
-    RpcProvider.prototype.getStorageAt = function (contractAddress, key, blockHashOrTag) {
-        if (blockHashOrTag === void 0) { blockHashOrTag = 'pending'; }
+    RpcProvider.prototype.getBlockWithTxHashes = function (blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
+            return __generator(this, function (_a) {
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxHashes', [
+                        blockIdentifierGetter.getIdentifier(),
+                    ])];
+            });
+        });
+    };
+    RpcProvider.prototype.getBlockWithTxs = function (blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
+            return __generator(this, function (_a) {
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxs', [blockIdentifierGetter.getIdentifier()])];
+            });
+        });
+    };
+    RpcProvider.prototype.getNonce = function (contractAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getNonce', [contractAddress])];
+            });
+        });
+    };
+    RpcProvider.prototype.getStorageAt = function (contractAddress, key, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
-            var parsedKey;
+            var parsedKey, blockIdentifierGetter;
             return __generator(this, function (_a) {
                 parsedKey = (0, number_1.toHex)((0, number_1.toBN)(key));
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
                 return [2 /*return*/, this.fetchEndpoint('starknet_getStorageAt', [
                         contractAddress,
                         parsedKey,
-                        blockHashOrTag,
+                        blockIdentifierGetter.getIdentifier(),
                     ])];
             });
         });
     };
+    // common interface
     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)];
+                return [2 /*return*/, this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.getTransactionByHash = function (txHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [txHash])];
+            });
+        });
+    };
+    RpcProvider.prototype.getTransactionByBlockIdAndIndex = function (blockIdentifier, index) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [blockIdentifier, index])];
             });
         });
     };
@@ -152,11 +195,15 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
-    RpcProvider.prototype.getClassAt = function (contractAddress, _blockIdentifier) {
-        if (_blockIdentifier === void 0) { _blockIdentifier = 'pending'; }
+    RpcProvider.prototype.getClassAt = function (contractAddress, blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchEndpoint('starknet_getClassAt', [contractAddress])];
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getClassAt', [
+                        blockIdentifierGetter.getIdentifier(),
+                        contractAddress,
+                    ])];
             });
         });
     };
@@ -170,7 +217,7 @@ var RpcProvider = /** @class */ (function () {
                             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 || []),
+                            signature: (0, number_1.bigNumberishArrayToHexadecimalStringArray)(invocation.signature || []),
                             version: (0, number_1.toHex)((0, number_1.toBN)((invocationDetails === null || invocationDetails === void 0 ? void 0 : invocationDetails.version) || 0)),
                         },
                         blockIdentifier,
@@ -202,7 +249,7 @@ var RpcProvider = /** @class */ (function () {
                 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 : []),
+                        (0, number_1.bigNumberishArrayToHexadecimalStringArray)(constructorCalldata !== null && constructorCalldata !== void 0 ? constructorCalldata : []),
                         {
                             program: contractDefinition.program,
                             entry_points_by_type: contractDefinition.entry_points_by_type,
@@ -220,7 +267,7 @@ var RpcProvider = /** @class */ (function () {
                             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.bigNumberishArrayToHexadecimalStringArray)(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)];
@@ -248,16 +295,10 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
-    RpcProvider.prototype.getCode = function (contractAddress, _blockIdentifier) {
+    RpcProvider.prototype.getCode = function (_contractAddress, _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.fetchEndpoint('starknet_getCode', [contractAddress])];
-                    case 1:
-                        result = _a.sent();
-                        return [2 /*return*/, this.responseParser.parseGetCodeResponse(result)];
-                }
+                throw new Error('RPC 0.1.0 does not implement getCode function');
             });
         });
     };
@@ -325,11 +366,12 @@ var RpcProvider = /** @class */ (function () {
      */
     RpcProvider.prototype.getTransactionCount = function (blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
             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])];
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCount', [
+                        blockIdentifierGetter.getIdentifier(),
+                    ])];
             });
         });
     };

package/dist/provider/sequencer.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { BlockTag, Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { 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';
@@ -29,7 +29,7 @@ export declare class SequencerProvider implements ProviderInterface {
     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>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;

package/dist/provider/sequencer.js

@@ -249,14 +249,14 @@ var SequencerProvider = /** @class */ (function () {
             });
         });
     };
-    SequencerProvider.prototype.getStorageAt = function (contractAddress, key, blockHashOrTag) {
-        if (blockHashOrTag === void 0) { blockHashOrTag = 'pending'; }
+    SequencerProvider.prototype.getStorageAt = function (contractAddress, key, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             var parsedKey;
             return __generator(this, function (_a) {
                 parsedKey = (0, number_1.toBN)(key).toString(10);
                 return [2 /*return*/, this.fetchEndpoint('get_storage_at', {
-                        blockIdentifier: blockHashOrTag,
+                        blockIdentifier: blockIdentifier,
                         contractAddress: contractAddress,
                         key: parsedKey,
                     })];
@@ -359,7 +359,7 @@ var SequencerProvider = /** @class */ (function () {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchEndpoint('get_code', { contractAddress: contractAddress, blockIdentifier: blockIdentifier }).then(this.responseParser.parseGetCodeResponse)];
+                return [2 /*return*/, this.fetchEndpoint('get_code', { contractAddress: contractAddress, blockIdentifier: blockIdentifier })];
             });
         });
     };

package/dist/provider/utils.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="bn.js" />
 import type { BlockNumber } from '../types';
 import { BigNumberish } from '../utils/number';
 /**
@@ -23,6 +24,17 @@ declare type BlockIdentifierObject = {
     type: 'BLOCK_HASH';
     data: BigNumberish;
 };
+export declare class BlockIdentifierClass {
+    blockIdentifier: BlockIdentifier;
+    constructor(blockIdentifier: BlockIdentifier);
+    getIdentifier(): string | import("bn.js") | {
+        block_hash: string;
+        block_number?: undefined;
+    } | {
+        block_number: number;
+        block_hash?: undefined;
+    } | null;
+}
 /**
  * Identifies the block to be queried.
  *

package/dist/provider/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFormattedBlockIdentifier = exports.getBlockIdentifier = exports.txIdentifier = exports.formatHash = void 0;
+exports.getFormattedBlockIdentifier = exports.getBlockIdentifier = exports.BlockIdentifierClass = exports.txIdentifier = exports.formatHash = void 0;
 var number_1 = require("../utils/number");
 /**
  *
@@ -29,6 +29,22 @@ function txIdentifier(txHash, txId) {
     return "transactionHash=".concat(hashString);
 }
 exports.txIdentifier = txIdentifier;
+var BlockIdentifierClass = /** @class */ (function () {
+    function BlockIdentifierClass(blockIdentifier) {
+        this.blockIdentifier = blockIdentifier;
+    }
+    BlockIdentifierClass.prototype.getIdentifier = function () {
+        if (typeof this.blockIdentifier === 'string' && (0, number_1.isHex)(this.blockIdentifier)) {
+            return { block_hash: this.blockIdentifier };
+        }
+        if (typeof this.blockIdentifier === 'number') {
+            return { block_number: this.blockIdentifier };
+        }
+        return this.blockIdentifier;
+    };
+    return BlockIdentifierClass;
+}());
+exports.BlockIdentifierClass = BlockIdentifierClass;
 /**
  * Identifies the block to be queried.
  *

package/dist/signer/default.d.ts

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

package/dist/signer/default.js

@@ -43,6 +43,7 @@ var transaction_1 = require("../utils/transaction");
 var typedData_1 = require("../utils/typedData");
 var Signer = /** @class */ (function () {
     function Signer(keyPair) {
+        if (keyPair === void 0) { keyPair = (0, ellipticCurve_1.genKeyPair)(); }
         this.keyPair = keyPair;
     }
     Signer.prototype.getPubKey = function () {

package/dist/types/api/openrpc.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Starknet RPC version 0.1.0
+ * starknet_api_openrpc version 0.31.0
+ *
+ * TypeScript Representation of OpenRpc protocol types | results
+ * errors are not implemented here only results
+ */
+/**
+ * "type": "string",
+ * "title": "Field element",
+ * "$comment": "A field element, represented as a string of hex digits",
+ * "description": "A field element. Represented as up to 63 hex digits and leading 4 bits zeroed.",
+ * "pattern": "^0x0[a-fA-F0-9]{1,63}$"
+ */
+declare type FELT = string;
+declare type BLOCK_NUMBER = number;
+declare type BLOCK_HASH = FELT;
+declare type TXN_HASH = FELT;
+declare type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+declare type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'INVOKE' | 'L1_HANDLER';
+declare type MSG_TO_L1 = {
+    to_address: FELT;
+    payload: Array<FELT>;
+};
+declare type EVENT = {
+    from_address: FELT;
+    keys: Array<FELT>;
+    data: Array<FELT>;
+};
+declare type COMMON_RECEIPT_PROPERTIES = {
+    transaction_hash: TXN_HASH;
+    actual_fee: FELT;
+    status: TXN_STATUS;
+    block_hash: BLOCK_HASH;
+    block_number: BLOCK_NUMBER;
+    type?: TXN_TYPE;
+};
+declare type INVOKE_TXN_RECEIPT_PROPERTIES = {
+    messages_sent: MSG_TO_L1;
+    events: EVENT;
+};
+declare type PENDING_COMMON_RECEIPT_PROPERTIES = {
+    transaction_hash: TXN_HASH;
+    actual_fee: FELT;
+    type?: TXN_TYPE;
+};
+declare type INVOKE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+declare type L1_HANDLER_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+declare type DECLARE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+declare type DEPLOY_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+declare type PENDING_INVOKE_TXN_RECEIPT = PENDING_COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+declare type PENDING_TXN_RECEIPT = PENDING_INVOKE_TXN_RECEIPT | PENDING_COMMON_RECEIPT_PROPERTIES;
+declare type TXN_RECEIPT = INVOKE_TXN_RECEIPT | L1_HANDLER_TXN_RECEIPT | DECLARE_TXN_RECEIPT | DEPLOY_TXN_RECEIPT | PENDING_TXN_RECEIPT;
+export declare namespace RPC_1 {
+    type GetTransactionReceiptResponse = TXN_RECEIPT;
+    type Methods = {
+        starknet_getTransactionReceipt: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionReceiptResponse;
+        };
+    };
+}
+declare type BLOCK_HEADER = {
+    block_hash: BLOCK_HASH;
+    parent_hash: BLOCK_HASH;
+    block_number: BLOCK_NUMBER;
+    new_root: FELT;
+    timestamp: number;
+    sequencer_address: FELT;
+};
+declare type BLOCK_BODY_WITH_TX_HASHES = {
+    transactions: Array<TXN_HASH>;
+};
+declare type BLOCK_WITH_TX_HASHES = {
+    status: TXN_STATUS;
+} & BLOCK_HEADER & BLOCK_BODY_WITH_TX_HASHES;
+declare type PENDING_BLOCK_WITH_TX_HASHES = BLOCK_BODY_WITH_TX_HASHES & {
+    timestamp: number;
+    sequencer_address: FELT;
+    parent_hash: BLOCK_HASH;
+};
+declare type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+/**
+ * "title": "An integer number in hex format (0x...)",
+ * "pattern": "^0x[a-fA-F0-9]+$"
+ */
+declare type NUM_AS_HEX = string;
+declare type SIGNATURE = Array<FELT>;
+declare type COMMON_TXN_PROPERTIES = {
+    transaction_hash: TXN_HASH;
+    max_fee: FELT;
+    version: NUM_AS_HEX;
+    signature: SIGNATURE;
+    nonce: FELT;
+    type: TXN_TYPE;
+};
+declare type ADDRESS = FELT;
+declare type FUNCTION_CALL = {
+    contract_address: ADDRESS;
+    entry_point_selector: FELT;
+    calldata: Array<FELT>;
+};
+declare type INVOKE_TXN = COMMON_TXN_PROPERTIES & FUNCTION_CALL;
+declare type DECLARE_TXN = COMMON_TXN_PROPERTIES & {
+    class_hash: FELT;
+    sender_address: ADDRESS;
+};
+declare type DEPLOY_TXN = {
+    transaction_hash: TXN_HASH;
+    class_hash: FELT;
+    version: NUM_AS_HEX;
+    type: TXN_TYPE;
+    contract_address: FELT;
+    contract_address_salt: FELT;
+    constructor_calldata: Array<FELT>;
+};
+declare type TXN = INVOKE_TXN | DECLARE_TXN | DEPLOY_TXN;
+declare type BLOCK_BODY_WITH_TXS = {
+    transactions: Array<TXN>;
+};
+declare type BLOCK_WITH_TXS = {
+    status: BLOCK_STATUS;
+} & BLOCK_HEADER & BLOCK_BODY_WITH_TXS;
+declare type PENDING_BLOCK_WITH_TXS = BLOCK_BODY_WITH_TXS & {
+    timestamp: number;
+    sequencer_address: FELT;
+    parent_hash: BLOCK_HASH;
+};
+declare type CONTRACT_CLASS = {
+    program: string;
+    entry_points_by_type: {
+        CONSTRUCTOR: CONTRACT_ENTRY_POINT_LIST;
+        EXTERNAL: CONTRACT_ENTRY_POINT_LIST;
+        L1_HANDLER: CONTRACT_ENTRY_POINT_LIST;
+    };
+};
+declare type CONTRACT_ENTRY_POINT_LIST = Array<CONTRACT_ENTRY_POINT>;
+declare type CONTRACT_ENTRY_POINT = {
+    offset: NUM_AS_HEX;
+    selector: FELT;
+};
+export declare namespace OPENRPC {
+    type GetBlockWithTxHashesResponse = BLOCK_WITH_TX_HASHES | PENDING_BLOCK_WITH_TX_HASHES;
+    type GetBlockWithTxs = BLOCK_WITH_TXS | PENDING_BLOCK_WITH_TXS;
+    type GetStorageAtResponse = FELT;
+    type GetTransactionByHashResponse = TXN;
+    type GetTransactionByBlockIdAndIndex = TXN;
+    type GetClassResponse = CONTRACT_CLASS;
+}
+export {};

package/dist/types/api/openrpc.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Starknet RPC version 0.1.0
+ * starknet_api_openrpc version 0.31.0
+ *
+ * TypeScript Representation of OpenRpc protocol types | results
+ * errors are not implemented here only results
+ */
+Object.defineProperty(exports, "__esModule", { value: true });