starknet 2.4.0 → 2.5.0

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+# [2.5.0](https://github.com/seanjameshan/starknet.js/compare/v2.4.0...v2.5.0) (2021-12-13)
+
+### Bug Fixes
+
+- add jsdoc comment ([4cd969f](https://github.com/seanjameshan/starknet.js/commit/4cd969f82eb4a5d8c08feb59c42fb3e7195af50e))
+- remove eip712 reference ([039a360](https://github.com/seanjameshan/starknet.js/commit/039a360873f9a1cdedc7a498b6e1732183957143))
+- remove unused types ([e528f7d](https://github.com/seanjameshan/starknet.js/commit/e528f7d75f4560d2affe3ca99426e01fbee6dfb5))
+- review ([a3813c9](https://github.com/seanjameshan/starknet.js/commit/a3813c9931c178d58c2521b926fb3fdff6944635))
+
+### Features
+
+- add `getKeyPairFromPublicKey` method ([66d543d](https://github.com/seanjameshan/starknet.js/commit/66d543dca1bb302654f0f1588a27f7794bfa49be))
+- add tests ([b414a83](https://github.com/seanjameshan/starknet.js/commit/b414a839a1fdd56084a58d6efb4747e8f5455628))
+- allow multi sig ([fc1e086](https://github.com/seanjameshan/starknet.js/commit/fc1e0866154d2bf29f26374639a34fec438bae5e))
+- support eip712 for starknet ([d597082](https://github.com/seanjameshan/starknet.js/commit/d59708211fc497d801699a7168dad1a5cc9648fd))
+
 # [2.4.0](https://github.com/seanjameshan/starknet.js/compare/v2.3.1...v2.4.0) (2021-12-09)
 
 ### Features

package/__tests__/account.test.ts

@@ -104,7 +104,7 @@ describe('deploy and test Wallet', () => {
       )
     );
 
-    const { r, s } = ec.sign(starkKeyPair, msgHash);
+    const signature = ec.sign(starkKeyPair, msgHash);
     const { code, transaction_hash } = await wallet.invoke(
       'execute',
       {
@@ -113,7 +113,7 @@ describe('deploy and test Wallet', () => {
         calldata: [erc20Address, '10'],
         nonce: nonce.toString(),
       },
-      [number.toHex(r), number.toHex(s)]
+      signature
     );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
@@ -151,7 +151,7 @@ test('build tx', async () => {
       .toString()
   );
 
-  const { r, s } = ec.sign(keyPair, msgHash);
+  const [r, s] = ec.sign(keyPair, msgHash);
   expect(r.toString()).toBe(
     '706800951915233622090196542158919402159816118214143837213294331713137614072'
   );

package/__tests__/utils/ellipticalCurve.test.ts

@@ -40,7 +40,7 @@ test('hashMessage()', () => {
   );
   expect(hashMsg).toBe('0x7f15c38ea577a26f4f553282fcfe4f1feeb8ecfaad8f221ae41abf8224cbddd');
   const keyPair = getKeyPair(privateKey);
-  const { r, s } = sign(keyPair, removeHexPrefix(hashMsg));
+  const [r, s] = sign(keyPair, removeHexPrefix(hashMsg));
   expect(r.toString()).toStrictEqual(
     toBN('2458502865976494910213617956670505342647705497324144349552978333078363662855').toString()
   );

package/__tests__/utils/typedData.test.ts

@@ -0,0 +1,72 @@
+import { encodeType, getMessageHash, getStructHash, getTypeHash } from '../../src/utils/typedData';
+
+const typedDataExample = {
+  types: {
+    StarkNetDomain: [
+      { name: 'name', type: 'felt' },
+      { name: 'version', type: 'felt' },
+      { name: 'chainId', type: 'felt' },
+    ],
+    Person: [
+      { name: 'name', type: 'felt' },
+      { name: 'wallet', type: 'felt' },
+    ],
+    Mail: [
+      { name: 'from', type: 'Person' },
+      { name: 'to', type: 'Person' },
+      { name: 'contents', type: 'felt' },
+    ],
+  },
+  primaryType: 'Mail',
+  domain: {
+    name: 'StarkNet Mail',
+    version: '1',
+    chainId: 1,
+  },
+  message: {
+    from: {
+      name: 'Cow',
+      wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+    },
+    to: {
+      name: 'Bob',
+      wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+    },
+    contents: 'Hello, Bob!',
+  },
+};
+
+describe('typedData', () => {
+  test('should get right type encoding', () => {
+    const typeEncoding = encodeType(typedDataExample, 'Mail');
+    expect(typeEncoding).toMatchInlineSnapshot(
+      `"Mail(from:Person,to:Person,contents:felt)Person(name:felt,wallet:felt)"`
+    );
+  });
+  test('should get right type hash', () => {
+    const typeHashDomain = getTypeHash(typedDataExample, 'StarkNetDomain');
+    expect(typeHashDomain).toMatchInlineSnapshot(
+      `"0x1bfc207425a47a5dfa1a50a4f5241203f50624ca5fdf5e18755765416b8e288"`
+    );
+    const typeHashPerson = getTypeHash(typedDataExample, 'Person');
+    expect(typeHashPerson).toMatchInlineSnapshot(
+      `"0x2896dbe4b96a67110f454c01e5336edc5bbc3635537efd690f122f4809cc855"`
+    );
+    const typeHashMail = getTypeHash(typedDataExample, 'Mail');
+    expect(typeHashMail).toMatchInlineSnapshot(
+      `"0x13d89452df9512bf750f539ba3001b945576243288137ddb6c788457d4b2f79"`
+    );
+  });
+  test('should get right hash for StarkNetDomain', () => {
+    const hash = getStructHash(typedDataExample, 'StarkNetDomain', typedDataExample.domain as any);
+    expect(hash).toMatchInlineSnapshot(
+      `"0x54833b121883a3e3aebff48ec08a962f5742e5f7b973469c1f8f4f55d470b07"`
+    );
+  });
+  test('should get right hash for entire message', () => {
+    const hash = getMessageHash(typedDataExample, '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826');
+    expect(hash).toMatchInlineSnapshot(
+      `"0x6fcff244f63e38b9d88b9e3378d44757710d1b244282b435cb472053c8d78d0"`
+    );
+  });
+});

package/contract.d.ts

@@ -1,5 +1,5 @@
 import { Provider } from './provider';
-import { Abi, StructAbi } from './types';
+import { Abi, Signature, StructAbi } from './types';
 import { BigNumberish } from './utils/number';
 export declare type Args = {
   [inputName: string]:
@@ -33,7 +33,7 @@ export declare class Contract {
   invoke(
     method: string,
     args?: Args,
-    signature?: [BigNumberish, BigNumberish]
+    signature?: Signature
   ): Promise<import('./types').AddTransactionResponse>;
   call(method: string, args?: Args): Promise<Args>;
 }

package/dist/contract.d.ts

@@ -1,5 +1,5 @@
 import { Provider } from './provider';
-import { Abi, StructAbi } from './types';
+import { Abi, Signature, StructAbi } from './types';
 import { BigNumberish } from './utils/number';
 export declare type Args = {
     [inputName: string]: string | string[] | {
@@ -27,6 +27,6 @@ export declare class Contract {
     private validateMethodAndArgs;
     private parseResponseField;
     private parseResponse;
-    invoke(method: string, args?: Args, signature?: [BigNumberish, BigNumberish]): Promise<import("./types").AddTransactionResponse>;
+    invoke(method: string, args?: Args, signature?: Signature): Promise<import("./types").AddTransactionResponse>;
     call(method: string, args?: Args): Promise<Args>;
 }

package/dist/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/dist/index.js

@@ -22,7 +22,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shortString = exports.uint256 = exports.ec = exports.stark = exports.number = exports.json = exports.hash = exports.encode = exports.constants = void 0;
+exports.typedData = exports.shortString = exports.uint256 = exports.ec = exports.stark = exports.number = exports.json = exports.hash = exports.encode = exports.constants = void 0;
 /**
  * Main
  */
@@ -42,3 +42,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/dist/provider/default.d.ts

@@ -1,4 +1,4 @@
-import { AddTransactionResponse, CallContractResponse, CallContractTransaction, CompiledContract, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionResponse, GetTransactionStatusResponse, Transaction } from '../types';
+import { AddTransactionResponse, CallContractResponse, CallContractTransaction, CompiledContract, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionResponse, GetTransactionStatusResponse, Signature, Transaction } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 declare type NetworkName = 'mainnet-alpha' | 'georli-alpha';
@@ -104,7 +104,7 @@ export declare class Provider implements ProviderInterface {
      * @param signature - (optional) signature to send along
      * @returns response from addTransaction
      */
-    invokeFunction(contractAddress: string, entrypointSelector: string, calldata?: string[], signature?: [BigNumberish, BigNumberish]): Promise<AddTransactionResponse>;
+    invokeFunction(contractAddress: string, entrypointSelector: string, calldata?: string[], signature?: Signature): Promise<AddTransactionResponse>;
     waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }
 export {};

package/dist/provider/default.js

@@ -308,20 +308,21 @@ 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') {
@@ -330,8 +331,8 @@ var Provider = /** @class */ (function () {
                         else if (res.tx_status === 'NOT_RECEIVED') {
                             throw Error('NOT_RECEIVED');
                         }
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/];
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/];
                 }
             });
         });

package/dist/provider/interface.d.ts

@@ -1,4 +1,4 @@
-import type { AddTransactionResponse, CallContractResponse, CallContractTransaction, CompiledContract, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionResponse, GetTransactionStatusResponse, Transaction } from '../types';
+import type { AddTransactionResponse, CallContractResponse, CallContractTransaction, CompiledContract, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionResponse, GetTransactionStatusResponse, Signature, Transaction } from '../types';
 import type { BigNumberish } from '../utils/number';
 export declare abstract class ProviderInterface {
     abstract baseUrl: string;
@@ -95,6 +95,6 @@ export declare abstract class ProviderInterface {
      * @param signature - (optional) signature to send along
      * @returns response from addTransaction
      */
-    abstract invokeFunction(contractAddress: string, entrypointSelector: string, calldata?: string[], signature?: [BigNumberish, BigNumberish]): Promise<AddTransactionResponse>;
+    abstract invokeFunction(contractAddress: string, entrypointSelector: string, calldata?: string[], signature?: Signature): Promise<AddTransactionResponse>;
     abstract waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }

package/dist/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/dist/signer/default.js

@@ -87,6 +87,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) {
@@ -105,9 +106,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)];
@@ -120,13 +121,13 @@ var Signer = /** @class */ (function (_super) {
                             entry_point_selector: (0, stark_1.getSelectorFromName)('get_nonce'),
                         })];
                     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(); });
                         msgHash = (0, encode_1.addHexPrefix)((0, hash_1.hashMessage)(this.address, transaction.contract_address, transaction.entry_point_selector, calldataDecimal, 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, {
                                 type: 'INVOKE_FUNCTION',
                                 entry_point_selector: (0, stark_1.getSelectorFromName)('execute'),
@@ -138,12 +139,47 @@ var Signer = /** @class */ (function (_super) {
                                     nonceBn.toString(),
                                 ], false).map(function (x) { 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/dist/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/dist/types.d.ts

@@ -1,12 +1,12 @@
 import type { ec as EC } from 'elliptic';
 import type { BigNumberish } from './utils/number';
 export declare type KeyPair = EC.KeyPair;
-export declare type Signature = EC.Signature;
+export declare type Signature = BigNumberish[];
 export declare type GetContractAddressesResponse = {
     Starknet: string;
     GpsStatementVerifier: string;
 };
-export declare type Status = 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'REJECTED' | 'ACCEPTED_ONCHAIN';
+export declare type Status = 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
 export declare type TransactionStatus = 'TRANSACTION_RECEIVED';
 export declare type Type = 'DEPLOY' | 'INVOKE_FUNCTION';
 export declare type EntryPointType = 'EXTERNAL';
@@ -49,7 +49,7 @@ export declare type DeployTransaction = {
 export declare type InvokeFunctionTransaction = {
     type: 'INVOKE_FUNCTION';
     contract_address: string;
-    signature?: [BigNumberish, BigNumberish];
+    signature?: Signature;
     entry_point_type?: EntryPointType;
     entry_point_selector: string;
     calldata?: string[];

package/dist/utils/ellipticCurve.d.ts

@@ -5,5 +5,12 @@ export declare const ec: EC;
 export declare const genKeyPair: (options?: EC.GenKeyPairOptions | undefined) => EC.KeyPair;
 export declare function getKeyPair(pk: BigNumberish): KeyPair;
 export declare function getStarkKey(keyPair: KeyPair): string;
+/**
+ * Takes a public key and casts it into `elliptic` KeyPair format.
+ *
+ * @param publicKey - public key which should get casted to a KeyPair
+ * @returns keyPair with public key only, which can be used to verify signatures, but cant sign anything
+ */
+export declare function getKeyPairFromPublicKey(publicKey: BigNumberish): KeyPair;
 export declare function sign(keyPair: KeyPair, msgHash: string): Signature;
-export declare function verify(keyPair: KeyPair, msgHash: string, sig: Signature): boolean;
+export declare function verify(keyPair: KeyPair | KeyPair[], msgHash: string, sig: Signature): boolean;

package/dist/utils/ellipticCurve.js

@@ -1,9 +1,25 @@
 "use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verify = exports.sign = exports.getStarkKey = exports.getKeyPair = exports.genKeyPair = exports.ec = void 0;
+exports.verify = exports.sign = exports.getKeyPairFromPublicKey = exports.getStarkKey = exports.getKeyPair = exports.genKeyPair = exports.ec = void 0;
 var elliptic_1 = require("elliptic");
 var hash_js_1 = __importDefault(require("hash.js"));
 var minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
@@ -50,6 +66,17 @@ function getStarkKey(keyPair) {
     return (0, encode_1.addHexPrefix)((0, encode_1.sanitizeBytes)(keyPair.pub.getX().toString(16), 2));
 }
 exports.getStarkKey = getStarkKey;
+/**
+ * Takes a public key and casts it into `elliptic` KeyPair format.
+ *
+ * @param publicKey - public key which should get casted to a KeyPair
+ * @returns keyPair with public key only, which can be used to verify signatures, but cant sign anything
+ */
+function getKeyPairFromPublicKey(publicKey) {
+    var publicKeyBn = (0, number_1.toBN)(publicKey);
+    return exports.ec.keyFromPublic((0, encode_1.removeHexPrefix)((0, number_1.toHex)(publicKeyBn)), 'hex');
+}
+exports.getKeyPairFromPublicKey = getKeyPairFromPublicKey;
 /*
  Signs a message using the provided key.
  key should be an KeyPair with a valid private key.
@@ -66,9 +93,14 @@ function sign(keyPair, msgHash) {
     (0, number_1.assertInRange)(r, constants_1.ONE, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.MAX_ECDSA_VAL)), 'r');
     (0, number_1.assertInRange)(s, constants_1.ONE, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.EC_ORDER)), 's');
     (0, number_1.assertInRange)(w, constants_1.ONE, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.MAX_ECDSA_VAL)), 'w');
-    return msgSignature;
+    return [r, s];
 }
 exports.sign = sign;
+function chunkArray(arr, n) {
+    return Array(Math.ceil(arr.length / n))
+        .fill('')
+        .map(function (_, i) { return arr.slice(i * n, i * n + n); });
+}
 /*
    Verifies a message using the provided key.
    key should be an KeyPair with a valid public key.
@@ -76,14 +108,21 @@ exports.sign = sign;
    Returns a boolean true if the verification succeeds.
   */
 function verify(keyPair, msgHash, sig) {
+    var keyPairArray = Array.isArray(keyPair) ? keyPair : [keyPair];
     var msgHashBN = (0, number_1.toBN)((0, encode_1.addHexPrefix)(msgHash));
+    (0, minimalistic_assert_1.default)(sig.length % 2 === 0, 'Signature must be an array of length dividable by 2');
     (0, number_1.assertInRange)(msgHashBN, constants_1.ZERO, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.MAX_ECDSA_VAL)), 'msgHash');
-    var r = sig.r, s = sig.s;
-    var w = s.invm(exports.ec.n);
-    // Verify signature has valid length.
-    (0, number_1.assertInRange)(r, constants_1.ONE, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.MAX_ECDSA_VAL)), 'r');
-    (0, number_1.assertInRange)(s, constants_1.ONE, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.EC_ORDER)), 's');
-    (0, number_1.assertInRange)(w, constants_1.ONE, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.MAX_ECDSA_VAL)), 'w');
-    return keyPair.verify(fixMessage(msgHash), sig);
+    (0, minimalistic_assert_1.default)(keyPairArray.length === sig.length / 2, 'Signature and keyPair length must be equal');
+    return chunkArray(sig, 2).every(function (_a, i) {
+        var _b;
+        var _c = __read(_a, 2), r = _c[0], s = _c[1];
+        var rBN = (0, number_1.toBN)(r);
+        var sBN = (0, number_1.toBN)(s);
+        var w = sBN.invm(exports.ec.n);
+        (0, number_1.assertInRange)(rBN, constants_1.ONE, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.MAX_ECDSA_VAL)), 'r');
+        (0, number_1.assertInRange)(sBN, constants_1.ONE, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.EC_ORDER)), 's');
+        (0, number_1.assertInRange)(w, constants_1.ONE, (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.MAX_ECDSA_VAL)), 'w');
+        return (_b = exports.ec.verify(fixMessage(msgHash), { r: rBN, s: sBN }, keyPairArray[i])) !== null && _b !== void 0 ? _b : false;
+    });
 }
 exports.verify = verify;

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,4 +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 formatSignature(sig?: Signature): string[];

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;