starknet 4.3.0 → 4.4.1

package/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 });

package/types/api/rpc.d.ts

@@ -1,5 +1,7 @@
 import { StarknetChainId } from '../../constants';
+import { BlockIdentifier } from '../../provider/utils';
 import { Status } from '../lib';
+import { OPENRPC } from './openrpc';
 export declare namespace RPC {
     export type Response = {
         id: number;
@@ -26,23 +28,9 @@ export declare namespace RPC {
         gas_consumed: number;
         gas_price: number;
     };
-    export type GetBlockResponse = {
-        block_hash: string;
-        parent_hash: string;
-        block_number: number;
-        status: Status;
-        sequencer: string;
-        new_root: string;
-        old_root: string;
-        accepted_time: number;
-        gas_price: string;
-        transactions: string[];
-    };
-    export type GetCodeResponse = {
-        bytecode: string[];
-        abi: string;
-    };
-    export type GetStorageAtResponse = string;
+    export type GetBlockWithTxHashesResponse = OPENRPC.GetBlockWithTxHashesResponse;
+    export type GetBlockWithTxs = OPENRPC.GetBlockWithTxs;
+    export type GetStorageAtResponse = OPENRPC.GetStorageAtResponse;
     export type GetTransactionReceiptResponse = {
         txn_hash: string;
         actual_fee: string;
@@ -68,7 +56,8 @@ export declare namespace RPC {
         contract_class?: GetClassResponse;
         sender_address?: string;
     }
-    export type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
+    export type GetTransactionByHashResponse = OPENRPC.GetTransactionByHashResponse;
+    export type GetTransactionByBlockIdAndIndex = OPENRPC.GetTransactionByBlockIdAndIndex;
     export type GetTransactionCountResponse = number;
     export type GetBlockNumberResponse = number;
     export type GetSyncingStatsResponse = {
@@ -80,8 +69,8 @@ export declare namespace RPC {
         highest_block_num: string;
     } | boolean;
     export type EventFilter = {
-        fromBlock: string;
-        toBlock: string;
+        fromBlock: BlockIdentifier;
+        toBlock: BlockIdentifier;
         address: string;
         keys: string[];
         page_size: number;
@@ -116,56 +105,46 @@ export declare namespace RPC {
         payload: string[];
     };
     export type Methods = {
-        starknet_getBlockByHash: {
+        starknet_getBlockWithTxHashes: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetBlockResponse;
+            RESPONSE: GetBlockWithTxHashesResponse;
         };
-        starknet_getBlockByNumber: {
+        starknet_getBlockWithTxs: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetBlockResponse;
+            RESPONSE: GetBlockWithTxs;
         };
-        starknet_getStorageAt: {
+        starknet_getNonce: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetStorageAtResponse;
+            RESPONSE: string;
         };
-        starknet_getTransactionByHash: {
+        starknet_getStorageAt: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetTransactionResponse;
+            RESPONSE: GetStorageAtResponse;
         };
-        starknet_getTransactionByBlockHashAndIndex: {
+        starknet_getTransactionByHash: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetTransactionResponse;
+            RESPONSE: GetTransactionByHashResponse;
         };
-        starknet_getTransactionByBlockNumberAndIndex: {
+        starknet_getTransactionByBlockIdAndIndex: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetTransactionResponse;
+            RESPONSE: GetTransactionByBlockIdAndIndex;
         };
         starknet_getTransactionReceipt: {
             QUERY: never;
             REQUEST: any[];
             RESPONSE: GetTransactionReceiptResponse;
         };
-        starknet_getBlockTransactionCountByHash: {
+        starknet_getBlockTransactionCount: {
             QUERY: never;
             REQUEST: any[];
             RESPONSE: GetTransactionCountResponse;
         };
-        starknet_getBlockTransactionCountByNumber: {
-            QUERY: never;
-            REQUEST: any[];
-            RESPONSE: GetTransactionCountResponse;
-        };
-        starknet_getCode: {
-            QUERY: never;
-            REQUEST: any[];
-            RESPONSE: GetCodeResponse;
-        };
         starknet_call: {
             QUERY: never;
             REQUEST: any[];

package/types/provider.d.ts

@@ -1,17 +1,17 @@
+/**
+ * Common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import BN from 'bn.js';
 import { Abi, CompressedProgram, EntryPointsByType, RawCalldata, Signature, Status } from './lib';
 export interface GetBlockResponse {
-    accepted_time: number;
+    timestamp: number;
     block_hash: string;
     block_number: number;
-    gas_price: string;
     new_root: string;
-    old_root?: string;
     parent_hash: string;
-    sequencer: string;
     status: Status;
     transactions: Array<string>;
-    starknet_version?: string;
 }
 export interface GetCodeResponse {
     bytecode: string[];

package/utils/ellipticCurve.d.ts

@@ -12,5 +12,18 @@ export declare function getStarkKey(keyPair: KeyPair): string;
  * @returns keyPair with public key only, which can be used to verify signatures, but cant sign anything
  */
 export declare function getKeyPairFromPublicKey(publicKey: BigNumberish): KeyPair;
+/**
+ * Signs a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid private key.
+ * @returns an Signature.
+ */
 export declare function sign(keyPair: KeyPair, msgHash: string): Signature;
+/**
+ * Verifies a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid public key.
+ * @param sig should be an Signature.
+ * @returns true if the verification succeeds.
+ */
 export declare function verify(keyPair: KeyPair | KeyPair[], msgHash: string, sig: Signature): boolean;

package/utils/ellipticCurve.js

@@ -37,11 +37,13 @@ exports.ec = new elliptic_1.ec(new elliptic_1.curves.PresetCurve({
     gRed: false,
     g: constants_1.CONSTANT_POINTS[1],
 }));
-/*
- The function _truncateToN in lib/elliptic/ec/index.js does a shift-right of 4 bits
- in some cases. This function does the opposite operation so that
-   _truncateToN(fixMessage(msg)) == msg.
-*/
+/**
+ * The function _truncateToN in lib/elliptic/ec/index.js does a shift-right of 4 bits
+ * in some cases. This function does the opposite operation so that
+ * _truncateToN(fixMessage(msg)) == msg.
+ *
+ * @param msg
+ */
 function fixMessage(msg) {
     var pureHex = msg.replace(/^0x0*/, '');
     if (pureHex.length <= 62) {
@@ -77,11 +79,12 @@ function getKeyPairFromPublicKey(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.
- Returns an Signature.
-*/
+/**
+ * Signs a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid private key.
+ * @returns an Signature.
+ */
 function sign(keyPair, msgHash) {
     var msgHashBN = (0, number_1.toBN)((0, encode_1.addHexPrefix)(msgHash));
     // Verify message hash has valid length.
@@ -101,12 +104,13 @@ function chunkArray(arr, 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.
-   msgSignature should be an Signature.
-   Returns a boolean true if the verification succeeds.
-  */
+/**
+ * Verifies a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid public key.
+ * @param sig should be an Signature.
+ * @returns 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));

package/utils/hash.js

@@ -78,13 +78,15 @@ function pedersen(input) {
     for (var i = 0; i < input.length; i += 1) {
         var x = (0, number_1.toBN)(input[i]);
         (0, minimalistic_assert_1.default)(x.gte(constants_1.ZERO) && x.lt((0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.FIELD_PRIME))), "Invalid input: ".concat(input[i]));
-        for (var j = 0; j < 252; j += 1) {
-            var pt = constantPoints[2 + i * 252 + j];
-            (0, minimalistic_assert_1.default)(!point.getX().eq(pt.getX()));
-            if (x.and(constants_1.ONE).toNumber() !== 0) {
-                point = point.add(pt);
+        if (!x.isZero()) {
+            for (var j = 0; j < 252; j += 1) {
+                var pt = constantPoints[2 + i * 252 + j];
+                (0, minimalistic_assert_1.default)(!point.getX().eq(pt.getX()));
+                if (x.and(constants_1.ONE).toNumber() !== 0) {
+                    point = point.add(pt);
+                }
+                x = x.shrn(1);
             }
-            x = x.shrn(1);
         }
     }
     return (0, encode_1.addHexPrefix)(point.getX().toString(16));

package/utils/merkle.d.ts

@@ -0,0 +1,10 @@
+export declare class MerkleTree {
+    leaves: string[];
+    branches: string[][];
+    root: string;
+    constructor(leafHashes: string[]);
+    private build;
+    static hash(a: string, b: string): string;
+    getProof(leaf: string, branch?: string[], hashPath?: string[]): string[];
+}
+export declare function proofMerklePath(root: string, leaf: string, path: string[]): boolean;

package/utils/merkle.js

@@ -0,0 +1,90 @@
+"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 __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.proofMerklePath = exports.MerkleTree = void 0;
+var hash_1 = require("./hash");
+var MerkleTree = /** @class */ (function () {
+    function MerkleTree(leafHashes) {
+        this.branches = [];
+        this.leaves = leafHashes;
+        this.root = this.build(leafHashes);
+    }
+    MerkleTree.prototype.build = function (leaves) {
+        if (leaves.length === 1) {
+            return leaves[0];
+        }
+        if (leaves.length !== this.leaves.length) {
+            this.branches.push(leaves);
+        }
+        var newLeaves = [];
+        for (var i = 0; i < leaves.length; i += 2) {
+            if (i + 1 === leaves.length) {
+                newLeaves.push(leaves[i]);
+            }
+            else {
+                newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1]));
+            }
+        }
+        return this.build(newLeaves);
+    };
+    MerkleTree.hash = function (a, b) {
+        var _a = __read([a, b].sort(), 2), aSorted = _a[0], bSorted = _a[1];
+        return (0, hash_1.pedersen)([aSorted, bSorted]);
+    };
+    MerkleTree.prototype.getProof = function (leaf, branch, hashPath) {
+        var _a, _b;
+        if (branch === void 0) { branch = this.leaves; }
+        if (hashPath === void 0) { hashPath = []; }
+        var index = branch.indexOf(leaf);
+        if (index === -1) {
+            throw new Error('leaf not found');
+        }
+        if (branch.length === 1) {
+            return hashPath;
+        }
+        var isLeft = index % 2 === 0;
+        var neededBranch = (_a = (isLeft ? branch[index + 1] : branch[index - 1])) !== null && _a !== void 0 ? _a : '0x0';
+        var newHashPath = __spreadArray(__spreadArray([], __read(hashPath), false), [neededBranch], false);
+        var currentBranchLevelIndex = this.leaves.length === branch.length
+            ? -1
+            : this.branches.findIndex(function (b) { return b.length === branch.length; });
+        var nextBranch = (_b = this.branches[currentBranchLevelIndex + 1]) !== null && _b !== void 0 ? _b : [this.root];
+        return this.getProof(neededBranch === '0x0'
+            ? leaf
+            : MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf), nextBranch, newHashPath);
+    };
+    return MerkleTree;
+}());
+exports.MerkleTree = MerkleTree;
+function proofMerklePath(root, leaf, path) {
+    if (path.length === 0) {
+        return root === leaf;
+    }
+    var _a = __read(path), next = _a[0], rest = _a.slice(1);
+    return proofMerklePath(root, MerkleTree.hash(leaf, next), rest);
+}
+exports.proofMerklePath = proofMerklePath;

package/utils/number.d.ts

@@ -7,3 +7,4 @@ export declare function hexToDecimalString(hex: string): string;
 export declare function toFelt(num: BigNumberish): string;
 export declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
 export declare function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[];
+export declare function bigNumberishArrayToHexadecimalStringArray(rawCalldata: BigNumberish[]): string[];

package/utils/number.js

@@ -26,12 +26,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bigNumberishArrayToDecimalStringArray = exports.assertInRange = exports.toFelt = exports.hexToDecimalString = exports.toHex = exports.toBN = exports.isHex = void 0;
+exports.bigNumberishArrayToHexadecimalStringArray = exports.bigNumberishArrayToDecimalStringArray = exports.assertInRange = exports.toFelt = exports.hexToDecimalString = exports.toHex = exports.toBN = exports.isHex = void 0;
 var bn_js_1 = __importStar(require("bn.js"));
 var minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
 var encode_1 = require("./encode");
 function isHex(hex) {
-    return hex.startsWith('0x');
+    return /^0x[0-9a-f]*$/i.test(hex);
 }
 exports.isHex = isHex;
 function toBN(number, base) {
@@ -76,3 +76,7 @@ function bigNumberishArrayToDecimalStringArray(rawCalldata) {
     return rawCalldata.map(function (x) { return toBN(x).toString(10); });
 }
 exports.bigNumberishArrayToDecimalStringArray = bigNumberishArrayToDecimalStringArray;
+function bigNumberishArrayToHexadecimalStringArray(rawCalldata) {
+    return rawCalldata.map(function (x) { return toHex(toBN(x)); });
+}
+exports.bigNumberishArrayToHexadecimalStringArray = bigNumberishArrayToHexadecimalStringArray;

package/utils/responseParser/rpc.d.ts

@@ -1,14 +1,24 @@
+/**
+ * Map RPC Response to common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import { CallContractResponse, DeclareContractResponse, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, InvokeFunctionResponse } from '../../types';
 import { RPC } from '../../types/api';
 import { ResponseParser } from '.';
+declare type RpcGetBlockResponse = RPC.GetBlockWithTxHashesResponse & {
+    [key: string]: any;
+};
+declare type GetTransactionByHashResponse = RPC.GetTransactionByHashResponse & {
+    [key: string]: any;
+};
 export declare class RPCResponseParser extends ResponseParser {
-    parseGetBlockResponse(res: RPC.GetBlockResponse): GetBlockResponse;
-    parseGetTransactionResponse(res: RPC.GetTransactionResponse): GetTransactionResponse;
+    parseGetBlockResponse(res: RpcGetBlockResponse): GetBlockResponse;
+    parseGetTransactionResponse(res: GetTransactionByHashResponse): GetTransactionResponse;
     parseGetTransactionReceiptResponse(res: RPC.GetTransactionReceiptResponse): GetTransactionReceiptResponse;
-    parseGetCodeResponse(res: RPC.GetCodeResponse): RPC.GetCodeResponse;
     parseFeeEstimateResponse(res: RPC.EstimateFeeResponse): EstimateFeeResponse;
     parseCallContractResponse(res: Array<string>): CallContractResponse;
     parseInvokeFunctionResponse(res: RPC.AddTransactionResponse): InvokeFunctionResponse;
     parseDeployContractResponse(res: RPC.DeployContractResponse): DeployContractResponse;
     parseDeclareContractResponse(res: RPC.DeclareResponse): DeclareContractResponse;
 }
+export {};

package/utils/responseParser/rpc.js

@@ -25,14 +25,11 @@ var RPCResponseParser = /** @class */ (function (_super) {
     }
     RPCResponseParser.prototype.parseGetBlockResponse = function (res) {
         return {
-            accepted_time: res.accepted_time,
+            timestamp: res.timestamp,
             block_hash: res.block_hash,
             block_number: res.block_number,
-            gas_price: res.gas_price,
             new_root: res.new_root,
-            old_root: res.old_root,
             parent_hash: res.parent_hash,
-            sequencer: res.sequencer,
             status: res.status,
             transactions: res.transactions,
         };
@@ -41,13 +38,11 @@ var RPCResponseParser = /** @class */ (function (_super) {
         return {
             calldata: res.calldata || [],
             contract_address: res.contract_address,
-            contract_class: res.contract_class,
             entry_point_selector: res.entry_point_selector,
             max_fee: res.max_fee,
             nonce: res.nonce,
-            sender_address: res.sender_address,
             signature: res.signature || [],
-            transaction_hash: res.txn_hash,
+            transaction_hash: res.transaction_hash,
             version: res.version,
         };
     };
@@ -62,9 +57,6 @@ var RPCResponseParser = /** @class */ (function (_super) {
             events: res.events,
         };
     };
-    RPCResponseParser.prototype.parseGetCodeResponse = function (res) {
-        return res;
-    };
     RPCResponseParser.prototype.parseFeeEstimateResponse = function (res) {
         return {
             overall_fee: (0, number_1.toBN)(res.overall_fee),

package/utils/responseParser/sequencer.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Map Sequencer Response to common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import { CallContractResponse, DeclareContractResponse, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, InvokeFunctionResponse } from '../../types';
 import { Sequencer } from '../../types/api';
 import { ResponseParser } from '.';
@@ -5,7 +9,6 @@ export declare class SequencerAPIResponseParser extends ResponseParser {
     parseGetBlockResponse(res: Sequencer.GetBlockResponse): GetBlockResponse;
     parseGetTransactionResponse(res: Sequencer.GetTransactionResponse): GetTransactionResponse;
     parseGetTransactionReceiptResponse(res: Sequencer.TransactionReceiptResponse): GetTransactionReceiptResponse;
-    parseGetCodeResponse(res: Sequencer.GetCodeResponse): Sequencer.GetCodeResponse;
     parseFeeEstimateResponse(res: Sequencer.EstimateFeeResponse): EstimateFeeResponse;
     parseCallContractResponse(res: Sequencer.CallContractResponse): CallContractResponse;
     parseInvokeFunctionResponse(res: Sequencer.AddTransactionResponse): InvokeFunctionResponse;

package/utils/responseParser/sequencer.js

@@ -36,14 +36,11 @@ var SequencerAPIResponseParser = /** @class */ (function (_super) {
     }
     SequencerAPIResponseParser.prototype.parseGetBlockResponse = function (res) {
         return {
-            accepted_time: res.timestamp,
+            timestamp: res.timestamp,
             block_hash: res.block_hash,
             block_number: res.block_number,
-            gas_price: res.gas_price,
             new_root: res.state_root,
-            old_root: undefined,
             parent_hash: res.parent_block_hash,
-            sequencer: res.sequencer_address,
             status: res.status,
             transactions: Object.values(res.transactions)
                 .map(function (value) { return 'transaction_hash' in value && value.transaction_hash; })
@@ -79,9 +76,6 @@ var SequencerAPIResponseParser = /** @class */ (function (_super) {
             l1_origin_message: undefined,
         };
     };
-    SequencerAPIResponseParser.prototype.parseGetCodeResponse = function (res) {
-        return res;
-    };
     SequencerAPIResponseParser.prototype.parseFeeEstimateResponse = function (res) {
         if ('overall_fee' in res) {
             var gasInfo = {};

package/utils/typedData/index.d.ts

@@ -1,6 +1,12 @@
 import { BigNumberish } from '../number';
-import { TypedData } from './types';
+import { StarkNetMerkleType, StarkNetType, TypedData } from './types';
 export * from './types';
+export declare function prepareSelector(selector: string): string;
+export declare function isMerkleTreeType(type: StarkNetType): type is StarkNetMerkleType;
+interface Context {
+    parent?: string;
+    key?: string;
+}
 /**
  * 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.
@@ -10,7 +16,7 @@ export * from './types';
  * @param {string[]} [dependencies]
  * @return {string[]}
  */
-export declare const getDependencies: (typedData: TypedData, type: string, dependencies?: string[]) => string[];
+export declare const getDependencies: (types: TypedData['types'], type: string, dependencies?: string[]) => string[];
 /**
  * Encode a type to a string. All dependant types are alphabetically sorted.
  *
@@ -18,7 +24,7 @@ export declare const getDependencies: (typedData: TypedData, type: string, depen
  * @param {string} type
  * @return {string}
  */
-export declare const encodeType: (typedData: TypedData, type: string) => string;
+export declare const encodeType: (types: TypedData['types'], type: string) => string;
 /**
  * Get a type string as hash.
  *
@@ -26,7 +32,17 @@ export declare const encodeType: (typedData: TypedData, type: string) => string;
  * @param {string} type
  * @return {string}
  */
-export declare const getTypeHash: (typedData: TypedData, type: string) => string;
+export declare const getTypeHash: (types: TypedData['types'], type: string) => string;
+/**
+ * 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]}
+ */
+export declare const encodeValue: (types: TypedData['types'], type: string, data: unknown, ctx?: Context) => [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.
@@ -35,7 +51,7 @@ export declare const getTypeHash: (typedData: TypedData, type: string) => string
  * @param {string} type
  * @param {Record<string, any>} data
  */
-export declare const encodeData: <T extends TypedData>(typedData: T, type: string, data: T["message"]) => string[][];
+export declare const encodeData: <T extends TypedData>(types: T["types"], 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.
@@ -45,10 +61,9 @@ export declare const encodeData: <T extends TypedData>(typedData: T, type: strin
  * @param {Record<string, any>} data
  * @return {Buffer}
  */
-export declare const getStructHash: <T extends TypedData>(typedData: T, type: string, data: T["message"]) => string;
+export declare const getStructHash: <T extends TypedData>(types: T["types"], 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.
+ * Get the EIP-191 encoded message to sign, from the typedData object.
  *
  * @param {TypedData} typedData
  * @param {BigNumberish} account