starknet 2.3.0 → 2.6.0

package/dist/utils/stark.d.ts

@@ -1,5 +1,4 @@
-import { CompressedProgram, Program } from '../types';
-import { BigNumberish } from './number';
+import { CompressedProgram, Program, Signature } from '../types';
 /**
  * Function to compress compiled cairo program
  *
@@ -18,7 +17,4 @@ export declare function compressProgram(jsonProgram: Program | string): Compress
 export declare function getSelectorFromName(funcName: string): string;
 export declare function randomAddress(): string;
 export declare function makeAddress(input: string): string;
-export declare function formatSignature(sig?: [BigNumberish, BigNumberish]): [string, string] | [];
-export declare function compileStructToCalldata<S extends {
-    [k: string]: string;
-}>(struct: S): string[];
+export declare function formatSignature(sig?: Signature): string[];

package/dist/utils/stark.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileStructToCalldata = exports.formatSignature = exports.makeAddress = exports.randomAddress = exports.getSelectorFromName = exports.compressProgram = void 0;
+exports.formatSignature = exports.makeAddress = exports.randomAddress = exports.getSelectorFromName = exports.compressProgram = void 0;
 var pako_1 = require("pako");
 var ellipticCurve_1 = require("./ellipticCurve");
 var encode_1 = require("./encode");
@@ -52,7 +52,3 @@ function formatSignature(sig) {
     }
 }
 exports.formatSignature = formatSignature;
-function compileStructToCalldata(struct) {
-    return Object.values(struct);
-}
-exports.compileStructToCalldata = compileStructToCalldata;

package/dist/utils/typedData/index.d.ts

@@ -0,0 +1,91 @@
+import { BigNumberish } from '../number';
+import { TypedData } from './types';
+export * from './types';
+/**
+ * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
+ * in the resulting array.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @param {string[]} [dependencies]
+ * @return {string[]}
+ */
+export declare const getDependencies: (typedData: TypedData, type: string, dependencies?: string[]) => string[];
+/**
+ * Encode a type to a string. All dependant types are alphabetically sorted.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @return {string}
+ */
+export declare const encodeType: (typedData: TypedData, type: string) => string;
+/**
+ * Get a type string as hash.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @return {string}
+ */
+export declare const getTypeHash: (typedData: TypedData, type: string) => string;
+/**
+ * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values. All
+ * dependant types are automatically encoded.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @param {Record<string, any>} data
+ */
+export declare const encodeData: <T extends {
+    types: {
+        StarkNetDomain: {
+            type: string;
+            name: string;
+        }[];
+    } & Record<string, {
+        type: string;
+        name: string;
+    }[]>;
+    primaryType: string;
+    domain: {
+        name?: string | undefined;
+        version?: string | undefined;
+        chainId?: string | number | undefined;
+    };
+    message: Record<string, unknown>;
+}>(typedData: T, type: string, data: T["message"]) => string[][];
+/**
+ * Get encoded data as a hash. The data should be a key -> value object with all the required values. All dependant
+ * types are automatically encoded.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @param {Record<string, any>} data
+ * @return {Buffer}
+ */
+export declare const getStructHash: <T extends {
+    types: {
+        StarkNetDomain: {
+            type: string;
+            name: string;
+        }[];
+    } & Record<string, {
+        type: string;
+        name: string;
+    }[]>;
+    primaryType: string;
+    domain: {
+        name?: string | undefined;
+        version?: string | undefined;
+        chainId?: string | number | undefined;
+    };
+    message: Record<string, unknown>;
+}>(typedData: T, type: string, data: T["message"]) => string;
+/**
+ * Get the EIP-191 encoded message to sign, from the typedData object. If `hash` is enabled, the message will be hashed
+ * with Keccak256.
+ *
+ * @param {TypedData} typedData
+ * @param {boolean} hash
+ * @return {string}
+ */
+export declare const getMessageHash: (typedData: TypedData, account: BigNumberish) => string;

package/dist/utils/typedData/index.js

@@ -0,0 +1,183 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMessageHash = exports.getStructHash = exports.encodeData = exports.getTypeHash = exports.encodeType = exports.getDependencies = void 0;
+var hash_1 = require("../hash");
+var number_1 = require("../number");
+var shortString_1 = require("../shortString");
+var stark_1 = require("../stark");
+var utils_1 = require("./utils");
+__exportStar(require("./types"), exports);
+function getHex(value) {
+    try {
+        return (0, number_1.toHex)((0, number_1.toBN)(value));
+    }
+    catch (e) {
+        if (typeof value === 'string') {
+            return (0, number_1.toHex)((0, number_1.toBN)((0, shortString_1.encodeShortString)(value)));
+        }
+        throw new Error("Invalid BigNumberish: " + value);
+    }
+}
+/**
+ * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
+ * in the resulting array.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @param {string[]} [dependencies]
+ * @return {string[]}
+ */
+var getDependencies = function (typedData, type, dependencies) {
+    if (dependencies === void 0) { dependencies = []; }
+    // `getDependencies` is called by most other functions, so we validate the JSON schema here
+    if (!(0, utils_1.validateTypedData)(typedData)) {
+        throw new Error('Typed data does not match JSON schema');
+    }
+    if (dependencies.includes(type)) {
+        return dependencies;
+    }
+    if (!typedData.types[type]) {
+        return dependencies;
+    }
+    return __spreadArray([
+        type
+    ], __read(typedData.types[type].reduce(function (previous, t) { return __spreadArray(__spreadArray([], __read(previous), false), __read((0, exports.getDependencies)(typedData, t.type, previous).filter(function (dependency) { return !previous.includes(dependency); })), false); }, [])), false);
+};
+exports.getDependencies = getDependencies;
+/**
+ * Encode a type to a string. All dependant types are alphabetically sorted.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @return {string}
+ */
+var encodeType = function (typedData, type) {
+    var _a = __read((0, exports.getDependencies)(typedData, type)), primary = _a[0], dependencies = _a.slice(1);
+    var types = __spreadArray([primary], __read(dependencies.sort()), false);
+    return types
+        .map(function (dependency) {
+        return dependency + "(" + typedData.types[dependency].map(function (t) { return t.name + ":" + t.type; }) + ")";
+    })
+        .join('');
+};
+exports.encodeType = encodeType;
+/**
+ * Get a type string as hash.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @return {string}
+ */
+var getTypeHash = function (typedData, type) {
+    return (0, stark_1.getSelectorFromName)((0, exports.encodeType)(typedData, type));
+};
+exports.getTypeHash = getTypeHash;
+/**
+ * Encodes a single value to an ABI serialisable string, number or Buffer. Returns the data as tuple, which consists of
+ * an array of ABI compatible types, and an array of corresponding values.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @param {any} data
+ * @returns {[string, string]}
+ */
+var encodeValue = function (typedData, type, data) {
+    if (typedData.types[type]) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return [type, (0, exports.getStructHash)(typedData, type, data)];
+    }
+    if (type === 'felt*') {
+        return ['felt*', (0, hash_1.computeHashOnElements)(data)];
+    }
+    return [type, getHex(data)];
+};
+/**
+ * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values. All
+ * dependant types are automatically encoded.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @param {Record<string, any>} data
+ */
+var encodeData = function (typedData, type, data) {
+    var _a = __read(typedData.types[type].reduce(function (_a, field) {
+        var _b = __read(_a, 2), ts = _b[0], vs = _b[1];
+        if (data[field.name] === undefined || data[field.name] === null) {
+            throw new Error("Cannot encode data: missing data for '" + field.name + "'");
+        }
+        var value = data[field.name];
+        var _c = __read(encodeValue(typedData, field.type, value), 2), t = _c[0], encodedValue = _c[1];
+        return [
+            __spreadArray(__spreadArray([], __read(ts), false), [t], false),
+            __spreadArray(__spreadArray([], __read(vs), false), [encodedValue], false),
+        ];
+    }, [['felt'], [(0, exports.getTypeHash)(typedData, type)]]), 2), types = _a[0], values = _a[1];
+    return [types, values];
+};
+exports.encodeData = encodeData;
+/**
+ * Get encoded data as a hash. The data should be a key -> value object with all the required values. All dependant
+ * types are automatically encoded.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @param {Record<string, any>} data
+ * @return {Buffer}
+ */
+var getStructHash = function (typedData, type, data) {
+    return (0, hash_1.computeHashOnElements)((0, exports.encodeData)(typedData, type, data)[1]);
+};
+exports.getStructHash = getStructHash;
+/**
+ * Get the EIP-191 encoded message to sign, from the typedData object. If `hash` is enabled, the message will be hashed
+ * with Keccak256.
+ *
+ * @param {TypedData} typedData
+ * @param {boolean} hash
+ * @return {string}
+ */
+var getMessageHash = function (typedData, account) {
+    var message = [
+        (0, shortString_1.encodeShortString)('StarkNet Message'),
+        (0, exports.getStructHash)(typedData, 'StarkNetDomain', typedData.domain),
+        account,
+        (0, exports.getStructHash)(typedData, typedData.primaryType, typedData.message),
+    ];
+    return (0, hash_1.computeHashOnElements)(message);
+};
+exports.getMessageHash = getMessageHash;

package/dist/utils/typedData/types.d.ts

@@ -0,0 +1,82 @@
+import { Infer } from 'superstruct';
+export declare const ATOMIC_TYPES: string[];
+/**
+ * Checks if a type is valid with the given `typedData`. The following types are valid:
+ * - Atomic types: felt, felt*
+ * - Reference types: struct type (e.g. SomeStruct)
+ *
+ * @param {Record<string, unknown>} types
+ * @param {string} type
+ * @return {boolean}
+ */
+export declare const isValidType: (types: Record<string, unknown>, type: string) => boolean;
+export declare const STARKNET_TYPE: import("superstruct").Struct<{
+    type: string;
+    name: string;
+}, {
+    name: import("superstruct").Struct<string, null>;
+    type: import("superstruct").Struct<string, null>;
+}>;
+/**
+ * A single type, as part of a struct. The `type` field can be any of the EIP-712 supported types.
+ *
+ * Note that the `uint` and `int` aliases like in Solidity, and fixed point numbers are not supported by the EIP-712
+ * standard.
+ */
+export declare type StarkNetType = Infer<typeof STARKNET_TYPE>;
+export declare const STARKNET_DOMAIN_TYPE: import("superstruct").Struct<{
+    name?: string | undefined;
+    version?: string | undefined;
+    chainId?: string | number | undefined;
+}, {
+    name: import("superstruct").Struct<string | undefined, null>;
+    version: import("superstruct").Struct<string | undefined, null>;
+    chainId: import("superstruct").Struct<string | number | undefined, null>;
+}>;
+/**
+ * The EIP712 domain struct. Any of these fields are optional, but it must contain at least one field.
+ */
+export declare type StarkNetDomain = Infer<typeof STARKNET_DOMAIN_TYPE>;
+export declare const STARKNET_TYPED_DATA_TYPE: import("superstruct").Struct<{
+    types: {
+        StarkNetDomain: {
+            type: string;
+            name: string;
+        }[];
+    } & Record<string, {
+        type: string;
+        name: string;
+    }[]>;
+    primaryType: string;
+    domain: {
+        name?: string | undefined;
+        version?: string | undefined;
+        chainId?: string | number | undefined;
+    };
+    message: Record<string, unknown>;
+}, {
+    types: import("superstruct").Struct<{
+        StarkNetDomain: {
+            type: string;
+            name: string;
+        }[];
+    } & Record<string, {
+        type: string;
+        name: string;
+    }[]>, null>;
+    primaryType: import("superstruct").Struct<string, null>;
+    domain: import("superstruct").Struct<{
+        name?: string | undefined;
+        version?: string | undefined;
+        chainId?: string | number | undefined;
+    }, {
+        name: import("superstruct").Struct<string | undefined, null>;
+        version: import("superstruct").Struct<string | undefined, null>;
+        chainId: import("superstruct").Struct<string | number | undefined, null>;
+    }>;
+    message: import("superstruct").Struct<Record<string, unknown>, null>;
+}>;
+/**
+ * The complete typed data, with all the structs, domain data, primary type of the message, and the message itself.
+ */
+export declare type TypedData = Infer<typeof STARKNET_TYPED_DATA_TYPE>;

package/dist/utils/typedData/types.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STARKNET_TYPED_DATA_TYPE = exports.STARKNET_DOMAIN_TYPE = exports.STARKNET_TYPE = exports.isValidType = exports.ATOMIC_TYPES = void 0;
+var superstruct_1 = require("superstruct");
+exports.ATOMIC_TYPES = ['felt', 'felt*'];
+// Source: https://github.com/Mrtenz/eip-712/blob/master/src/eip-712.ts
+// and modified to support starknet types
+/**
+ * Checks if a type is valid with the given `typedData`. The following types are valid:
+ * - Atomic types: felt, felt*
+ * - Reference types: struct type (e.g. SomeStruct)
+ *
+ * @param {Record<string, unknown>} types
+ * @param {string} type
+ * @return {boolean}
+ */
+var isValidType = function (types, type) {
+    if (exports.ATOMIC_TYPES.includes(type)) {
+        return true;
+    }
+    if (types[type]) {
+        return true;
+    }
+    return false;
+};
+exports.isValidType = isValidType;
+var TYPE = (0, superstruct_1.refine)((0, superstruct_1.string)(), 'Type', function (type, context) {
+    return (0, exports.isValidType)(context.branch[0].types, type);
+});
+exports.STARKNET_TYPE = (0, superstruct_1.object)({
+    name: (0, superstruct_1.string)(),
+    type: TYPE,
+});
+exports.STARKNET_DOMAIN_TYPE = (0, superstruct_1.object)({
+    name: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+    version: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+    chainId: (0, superstruct_1.optional)((0, superstruct_1.union)([(0, superstruct_1.string)(), (0, superstruct_1.number)()])),
+});
+exports.STARKNET_TYPED_DATA_TYPE = (0, superstruct_1.object)({
+    types: (0, superstruct_1.intersection)([
+        (0, superstruct_1.type)({ StarkNetDomain: (0, superstruct_1.array)(exports.STARKNET_TYPE) }),
+        (0, superstruct_1.record)((0, superstruct_1.string)(), (0, superstruct_1.array)(exports.STARKNET_TYPE)),
+    ]),
+    primaryType: (0, superstruct_1.string)(),
+    domain: exports.STARKNET_DOMAIN_TYPE,
+    message: (0, superstruct_1.object)(),
+});

package/dist/utils/typedData/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Validates that `data` matches the EIP-712 JSON schema.
+ *
+ * @param {any} data
+ * @return {boolean}
+ */
+export declare const validateTypedData: (data: unknown) => data is {
+    types: {
+        StarkNetDomain: {
+            type: string;
+            name: string;
+        }[];
+    } & Record<string, {
+        type: string;
+        name: string;
+    }[]>;
+    primaryType: string;
+    domain: {
+        name?: string | undefined;
+        version?: string | undefined;
+        chainId?: string | number | undefined;
+    };
+    message: Record<string, unknown>;
+};

package/dist/utils/typedData/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTypedData = void 0;
+var superstruct_1 = require("superstruct");
+var types_1 = require("./types");
+/**
+ * Validates that `data` matches the EIP-712 JSON schema.
+ *
+ * @param {any} data
+ * @return {boolean}
+ */
+var validateTypedData = function (data) {
+    return (0, superstruct_1.is)(data, types_1.STARKNET_TYPED_DATA_TYPE);
+};
+exports.validateTypedData = validateTypedData;

package/index.d.ts

@@ -17,3 +17,4 @@ export * as stark from './utils/stark';
 export * as ec from './utils/ellipticCurve';
 export * as uint256 from './utils/uint256';
 export * as shortString from './utils/shortString';
+export * as typedData from './utils/typedData';

package/index.js

@@ -44,7 +44,8 @@ var __importStar =
     return result;
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.shortString =
+exports.typedData =
+  exports.shortString =
   exports.uint256 =
   exports.ec =
   exports.stark =
@@ -73,3 +74,4 @@ exports.stark = __importStar(require('./utils/stark'));
 exports.ec = __importStar(require('./utils/ellipticCurve'));
 exports.uint256 = __importStar(require('./utils/uint256'));
 exports.shortString = __importStar(require('./utils/shortString'));
+exports.typedData = __importStar(require('./utils/typedData'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "2.3.0",
+  "version": "2.6.0",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,6 +23,7 @@
     "zk",
     "rollup"
   ],
+  "repository": "github:seanjameshan/starknet.js",
   "author": "Sean Han",
   "license": "MIT",
   "devDependencies": {
@@ -67,6 +68,7 @@
     "json-bigint": "^1.0.0",
     "minimalistic-assert": "^1.0.1",
     "pako": "^2.0.4",
+    "superstruct": "^0.15.3",
     "url-join": "^4.0.1"
   },
   "lint-staged": {

package/provider/default.d.ts

@@ -1,5 +1,6 @@
 import {
   AddTransactionResponse,
+  BlockNumber,
   CallContractResponse,
   CallContractTransaction,
   CompiledContract,
@@ -8,11 +9,12 @@ import {
   GetContractAddressesResponse,
   GetTransactionResponse,
   GetTransactionStatusResponse,
+  Signature,
   Transaction,
 } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
-declare type NetworkName = 'mainnet-alpha' | 'georli-alpha';
+declare type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
 declare type ProviderOptions =
   | {
       network: NetworkName;
@@ -40,30 +42,33 @@ export declare class Provider implements ProviderInterface {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L17-L25)
    *
-   * @param invokeTx - transaction to be invoked
-   * @param blockId
+   * @param invokeTransaction - transaction to be invoked
+   * @param blockNumber
    * @returns the result of the function on the smart contract.
    */
-  callContract(invokeTx: CallContractTransaction, blockId?: number): Promise<CallContractResponse>;
+  callContract(
+    invokeTransaction: CallContractTransaction,
+    blockNumber?: BlockNumber
+  ): Promise<CallContractResponse>;
   /**
    * Gets the block information from a block ID.
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L27-L31)
    *
-   * @param blockId
-   * @returns the block object { block_id, previous_block_id, state_root, status, timestamp, transaction_receipts, transactions }
+   * @param blockNumber
+   * @returns the block object { block_number, previous_block_number, state_root, status, timestamp, transaction_receipts, transactions }
    */
-  getBlock(blockId?: number): Promise<GetBlockResponse>;
+  getBlock(blockNumber?: BlockNumber): Promise<GetBlockResponse>;
   /**
    * Gets the code of the deployed contract.
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L33-L36)
    *
    * @param contractAddress
-   * @param blockId
+   * @param blockNumber
    * @returns Bytecode and ABI of compiled contract
    */
-  getCode(contractAddress: string, blockId?: number): Promise<GetCodeResponse>;
+  getCode(contractAddress: string, blockNumber?: BlockNumber): Promise<GetCodeResponse>;
   /**
    * Gets the contract's storage variable at a specific key.
    *
@@ -71,17 +76,17 @@ export declare class Provider implements ProviderInterface {
    *
    * @param contractAddress
    * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-   * @param blockId
+   * @param blockNumber
    * @returns the value of the storage variable
    */
-  getStorageAt(contractAddress: string, key: number, blockId?: number): Promise<object>;
+  getStorageAt(contractAddress: string, key: number, blockNumber?: BlockNumber): 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_id, tx_status: NOT_RECEIVED | RECEIVED | PENDING | REJECTED | ACCEPTED_ONCHAIN }
+   * @returns the transaction status object { block_number, tx_status: NOT_RECEIVED | RECEIVED | PENDING | REJECTED | ACCEPTED_ONCHAIN }
    */
   getTransactionStatus(txHash: BigNumberish): Promise<GetTransactionStatusResponse>;
   /**
@@ -90,7 +95,7 @@ export declare class Provider implements ProviderInterface {
    * [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_id?, block_number?, transaction_index?, transaction_failure_reason? }
+   * @returns the transacton object { transaction_id, status, transaction, block_number?, block_number?, transaction_index?, transaction_failure_reason? }
    */
   getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
   /**
@@ -98,10 +103,10 @@ export declare class Provider implements ProviderInterface {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
    *
-   * @param tx - transaction to be invoked
+   * @param transaction - transaction to be invoked
    * @returns a confirmation of invoking a function on the starknet contract
    */
-  addTransaction(tx: Transaction): Promise<AddTransactionResponse>;
+  addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
   /**
    * Deploys a given compiled contract (json) to starknet
    *
@@ -127,7 +132,7 @@ export declare class Provider implements ProviderInterface {
     contractAddress: string,
     entrypointSelector: string,
     calldata?: string[],
-    signature?: [BigNumberish, BigNumberish]
+    signature?: Signature
   ): Promise<AddTransactionResponse>;
   waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }