starknet 2.4.0 → 2.5.0

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.4.0",
+  "version": "2.5.0",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -68,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

@@ -8,6 +8,7 @@ import {
   GetContractAddressesResponse,
   GetTransactionResponse,
   GetTransactionStatusResponse,
+  Signature,
   Transaction,
 } from '../types';
 import { BigNumberish } from '../utils/number';
@@ -130,7 +131,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>;
 }

package/provider/default.js

@@ -517,29 +517,29 @@ var Provider = /** @class */ (function () {
         switch (_a.label) {
           case 0:
             onchain = false;
-            _a.label = 1;
+            return [4 /*yield*/, wait(retryInterval)];
           case 1:
-            if (!!onchain) return [3 /*break*/, 4];
+            _a.sent();
+            _a.label = 2;
+          case 2:
+            if (!!onchain) return [3 /*break*/, 5];
             // eslint-disable-next-line no-await-in-loop
             return [4 /*yield*/, wait(retryInterval)];
-          case 2:
+          case 3:
             // eslint-disable-next-line no-await-in-loop
             _a.sent();
             return [4 /*yield*/, this.getTransactionStatus(txHash)];
-          case 3:
+          case 4:
             res = _a.sent();
-            if (
-              res.tx_status === 'ACCEPTED_ONCHAIN' ||
-              (res.tx_status === 'PENDING' && res.block_hash !== 'pending') // This is needed as of today. In the future there will be a different status for pending transactions.
-            ) {
+            if (res.tx_status === 'ACCEPTED_ON_L1' || res.tx_status === 'ACCEPTED_ON_L2') {
               onchain = true;
             } else if (res.tx_status === 'REJECTED') {
               throw Error('REJECTED');
             } else if (res.tx_status === 'NOT_RECEIVED') {
               throw Error('NOT_RECEIVED');
             }
-            return [3 /*break*/, 1];
-          case 4:
+            return [3 /*break*/, 2];
+          case 5:
             return [2 /*return*/];
         }
       });

package/provider/interface.d.ts

@@ -8,6 +8,7 @@ import type {
   GetContractAddressesResponse,
   GetTransactionResponse,
   GetTransactionStatusResponse,
+  Signature,
   Transaction,
 } from '../types';
 import type { BigNumberish } from '../utils/number';
@@ -117,7 +118,7 @@ export declare abstract class ProviderInterface {
     contractAddress: string,
     entrypointSelector: string,
     calldata?: string[],
-    signature?: [BigNumberish, BigNumberish]
+    signature?: Signature
   ): Promise<AddTransactionResponse>;
   abstract waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }

package/signer/default.d.ts

@@ -1,5 +1,6 @@
 import { Provider } from '../provider';
-import { AddTransactionResponse, KeyPair, Transaction } from '../types';
+import { AddTransactionResponse, KeyPair, Signature, Transaction } from '../types';
+import { TypedData } from '../utils/typedData';
 import { SignerInterface } from './interface';
 export declare class Signer extends Provider implements SignerInterface {
   address: string;
@@ -14,4 +15,20 @@ export declare class Signer extends Provider implements SignerInterface {
    * @returns a confirmation of invoking a function on the starknet contract
    */
   addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
+  /**
+   * Sign an JSON object with the starknet private key and return the signature
+   *
+   * @param json - JSON object to be signed
+   * @returns the signature of the JSON object
+   * @throws {Error} if the JSON object is not a valid JSON
+   */
+  signMessage(typedData: TypedData): Promise<Signature>;
+  /**
+   * Hash a JSON object with pederson hash and return the hash
+   *
+   * @param json - JSON object to be hashed
+   * @returns the hash of the JSON object
+   * @throws {Error} if the JSON object is not a valid JSON
+   */
+  hashMessage(typedData: TypedData): Promise<string>;
 }

package/signer/default.js

@@ -203,6 +203,7 @@ var encode_1 = require('../utils/encode');
 var hash_1 = require('../utils/hash');
 var number_1 = require('../utils/number');
 var stark_1 = require('../utils/stark');
+var typedData_1 = require('../utils/typedData');
 var Signer = /** @class */ (function (_super) {
   __extends(Signer, _super);
   function Signer(provider, address, keyPair) {
@@ -221,9 +222,9 @@ var Signer = /** @class */ (function (_super) {
    */
   Signer.prototype.addTransaction = function (transaction) {
     return __awaiter(this, void 0, void 0, function () {
-      var nonceBn, result, calldataDecimal, msgHash, _a, r, s;
-      return __generator(this, function (_b) {
-        switch (_b.label) {
+      var nonceBn, result, calldataDecimal, msgHash, signature;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
           case 0:
             if (transaction.type === 'DEPLOY')
               return [2 /*return*/, _super.prototype.addTransaction.call(this, transaction)];
@@ -241,9 +242,9 @@ var Signer = /** @class */ (function (_super) {
               }),
             ];
           case 2:
-            result = _b.sent().result;
+            result = _a.sent().result;
             nonceBn = (0, number_1.toBN)(result[0]);
-            _b.label = 3;
+            _a.label = 3;
           case 3:
             calldataDecimal = (transaction.calldata || []).map(function (x) {
               return (0, number_1.toBN)(x).toString();
@@ -257,7 +258,7 @@ var Signer = /** @class */ (function (_super) {
                 nonceBn.toString()
               )
             );
-            (_a = (0, ellipticCurve_1.sign)(this.keyPair, msgHash)), (r = _a.r), (s = _a.s);
+            signature = (0, ellipticCurve_1.sign)(this.keyPair, msgHash);
             return [
               2 /*return*/,
               _super.prototype.addTransaction.call(this, {
@@ -279,13 +280,49 @@ var Signer = /** @class */ (function (_super) {
                   return (0, number_1.toBN)(x).toString();
                 }),
                 contract_address: this.address,
-                signature: [r, s],
+                signature: signature,
               }),
             ];
         }
       });
     });
   };
+  /**
+   * Sign an JSON object with the starknet private key and return the signature
+   *
+   * @param json - JSON object to be signed
+   * @returns the signature of the JSON object
+   * @throws {Error} if the JSON object is not a valid JSON
+   */
+  Signer.prototype.signMessage = function (typedData) {
+    return __awaiter(this, void 0, void 0, function () {
+      var _a, _b;
+      return __generator(this, function (_c) {
+        switch (_c.label) {
+          case 0:
+            _a = ellipticCurve_1.sign;
+            _b = [this.keyPair];
+            return [4 /*yield*/, this.hashMessage(typedData)];
+          case 1:
+            return [2 /*return*/, _a.apply(void 0, _b.concat([_c.sent()]))];
+        }
+      });
+    });
+  };
+  /**
+   * Hash a JSON object with pederson hash and return the hash
+   *
+   * @param json - JSON object to be hashed
+   * @returns the hash of the JSON object
+   * @throws {Error} if the JSON object is not a valid JSON
+   */
+  Signer.prototype.hashMessage = function (typedData) {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        return [2 /*return*/, (0, typedData_1.getMessageHash)(typedData, this.address)];
+      });
+    });
+  };
   return Signer;
 })(provider_1.Provider);
 exports.Signer = Signer;

package/signer/interface.d.ts

@@ -1,5 +1,6 @@
 import { Provider } from '../provider';
-import { AddTransactionResponse, Transaction } from '../types';
+import { AddTransactionResponse, Signature, Transaction } from '../types';
+import { TypedData } from '../utils/typedData/types';
 export declare abstract class SignerInterface extends Provider {
   abstract address: string;
   /**
@@ -11,4 +12,22 @@ export declare abstract class SignerInterface extends Provider {
    * @returns a confirmation of invoking a function on the starknet contract
    */
   abstract addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
+  /**
+   * Sign an JSON object for off-chain usage with the starknet private key and return the signature
+   * This adds a message prefix so it cant be interchanged with transactions
+   *
+   * @param json - JSON object to be signed
+   * @returns the signature of the JSON object
+   * @throws {Error} if the JSON object is not a valid JSON
+   */
+  abstract signMessage(typedData: TypedData): Promise<Signature>;
+  /**
+   * Hash a JSON object with pederson hash and return the hash
+   * This adds a message prefix so it cant be interchanged with transactions
+   *
+   * @param json - JSON object to be hashed
+   * @returns the hash of the JSON object
+   * @throws {Error} if the JSON object is not a valid JSON
+   */
+  abstract hashMessage(typedData: TypedData): Promise<string>;
 }

package/src/contract.ts

@@ -2,7 +2,7 @@ import BN from 'bn.js';
 import assert from 'minimalistic-assert';
 
 import { Provider, defaultProvider } from './provider';
-import { Abi, AbiEntry, FunctionAbi, StructAbi } from './types';
+import { Abi, AbiEntry, FunctionAbi, Signature, StructAbi } from './types';
 import { BigNumberish, toBN } from './utils/number';
 import { getSelectorFromName } from './utils/stark';
 
@@ -146,7 +146,7 @@ export class Contract {
     return this.parseResponseField(methodAbi, responseIterator);
   }
 
-  public invoke(method: string, args: Args = {}, signature?: [BigNumberish, BigNumberish]) {
+  public invoke(method: string, args: Args = {}, signature?: Signature) {
     // ensure contract is connected
     assert(this.connectedTo !== null, 'contract isnt connected to an address');
 

package/src/index.ts

@@ -18,3 +18,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';