starknet 2.2.0 → 2.5.0

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/dist/utils/uint256.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bn.js" />
+import { BigNumberish } from './number';
+export interface Uint256 {
+    low: BigNumberish;
+    high: BigNumberish;
+}
+export declare function uint256ToBN(uint256: Uint256): import("bn.js");
+export declare const UINT_128_MAX: import("bn.js");
+export declare const UINT_256_MAX: import("bn.js");
+export declare function isUint256(bn: BigNumberish): boolean;
+export declare function bnToUint256(bignumber: BigNumberish): Uint256;

package/dist/utils/uint256.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bnToUint256 = exports.isUint256 = exports.UINT_256_MAX = exports.UINT_128_MAX = exports.uint256ToBN = void 0;
+var encode_1 = require("./encode");
+var number_1 = require("./number");
+// function to convert Uint256 to BN
+function uint256ToBN(uint256) {
+    return (0, number_1.toBN)(uint256.high).shln(128).add((0, number_1.toBN)(uint256.low));
+}
+exports.uint256ToBN = uint256ToBN;
+exports.UINT_128_MAX = (0, number_1.toBN)(1).shln(128).sub((0, number_1.toBN)(1));
+exports.UINT_256_MAX = (0, number_1.toBN)(1).shln(256).sub((0, number_1.toBN)(1));
+// function to check if BN is smaller or equal 2**256-1
+function isUint256(bn) {
+    return (0, number_1.toBN)(bn).lte(exports.UINT_256_MAX);
+}
+exports.isUint256 = isUint256;
+// function to convert BN to Uint256
+function bnToUint256(bignumber) {
+    var bn = (0, number_1.toBN)(bignumber);
+    if (!isUint256(bn))
+        throw new Error('Number is too large');
+    return {
+        low: (0, encode_1.addHexPrefix)(bn.maskn(128).toString(16)),
+        high: (0, encode_1.addHexPrefix)(bn.shrn(128).toString(16)),
+    };
+}
+exports.bnToUint256 = bnToUint256;

package/index.d.ts

@@ -15,3 +15,6 @@ export * as json from './utils/json';
 export * as number from './utils/number';
 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,10 @@ var __importStar =
     return result;
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.ec =
+exports.typedData =
+  exports.shortString =
+  exports.uint256 =
+  exports.ec =
   exports.stark =
   exports.number =
   exports.json =
@@ -69,3 +72,6 @@ exports.json = __importStar(require('./utils/json'));
 exports.number = __importStar(require('./utils/number'));
 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.2.0",
+  "version": "2.5.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

@@ -8,6 +8,7 @@ import {
   GetContractAddressesResponse,
   GetTransactionResponse,
   GetTransactionStatusResponse,
+  Signature,
   Transaction,
 } from '../types';
 import { BigNumberish } from '../utils/number';
@@ -40,11 +41,14 @@ 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 invokeTransaction - transaction to be invoked
    * @param blockId
    * @returns the result of the function on the smart contract.
    */
-  callContract(invokeTx: CallContractTransaction, blockId?: number): Promise<CallContractResponse>;
+  callContract(
+    invokeTransaction: CallContractTransaction,
+    blockId?: number
+  ): Promise<CallContractResponse>;
   /**
    * Gets the block information from a block ID.
    *
@@ -98,10 +102,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 +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

@@ -219,11 +219,11 @@ var Provider = /** @class */ (function () {
    *
    * [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 invokeTransaction - transaction to be invoked
    * @param blockId
    * @returns the result of the function on the smart contract.
    */
-  Provider.prototype.callContract = function (invokeTx, blockId) {
+  Provider.prototype.callContract = function (invokeTransaction, blockId) {
     return __awaiter(this, void 0, void 0, function () {
       var data;
       return __generator(this, function (_a) {
@@ -237,7 +237,7 @@ var Provider = /** @class */ (function () {
                   'call_contract',
                   '?blockId=' + (blockId !== null && blockId !== void 0 ? blockId : 'null')
                 ),
-                __assign({ signature: [], calldata: [] }, invokeTx)
+                __assign({ signature: [], calldata: [] }, invokeTransaction)
               ),
             ];
           case 1:
@@ -421,19 +421,21 @@ var Provider = /** @class */ (function () {
    *
    * [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
    */
-  Provider.prototype.addTransaction = function (tx) {
+  Provider.prototype.addTransaction = function (transaction) {
     return __awaiter(this, void 0, void 0, function () {
       var signature, contract_address_salt, data;
       return __generator(this, function (_a) {
         switch (_a.label) {
           case 0:
-            signature = tx.type === 'INVOKE_FUNCTION' && (0, stark_1.formatSignature)(tx.signature);
+            signature =
+              transaction.type === 'INVOKE_FUNCTION' &&
+              (0, stark_1.formatSignature)(transaction.signature);
             contract_address_salt =
-              tx.type === 'DEPLOY' &&
-              (0, number_1.toHex)((0, number_1.toBN)(tx.contract_address_salt));
+              transaction.type === 'DEPLOY' &&
+              (0, number_1.toHex)((0, number_1.toBN)(transaction.contract_address_salt));
             return [
               4 /*yield*/,
               axios_1.default.post(
@@ -441,7 +443,7 @@ var Provider = /** @class */ (function () {
                 (0, json_1.stringify)(
                   __assign(
                     __assign(
-                      __assign({}, tx),
+                      __assign({}, transaction),
                       Array.isArray(signature) && { signature: signature }
                     ),
                     contract_address_salt && { contract_address_salt: contract_address_salt }
@@ -515,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';
@@ -27,12 +28,12 @@ export declare abstract class 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 invokeTransaction - transaction to be invoked
    * @param blockId
    * @returns the result of the function on the smart contract.
    */
   abstract callContract(
-    invokeTx: CallContractTransaction,
+    invokeTransaction: CallContractTransaction,
     blockId?: number
   ): Promise<CallContractResponse>;
   /**
@@ -88,10 +89,10 @@ export declare abstract class 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
    */
-  abstract addTransaction(tx: Transaction): Promise<AddTransactionResponse>;
+  abstract addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
   /**
    * Deploys a given compiled contract (json) to starknet
    *
@@ -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;
@@ -10,8 +11,24 @@ export declare class Signer extends Provider implements SignerInterface {
    *
    * [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>;
+  /**
+   * 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) {
@@ -216,19 +217,23 @@ var Signer = /** @class */ (function (_super) {
    *
    * [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
    */
-  Signer.prototype.addTransaction = function (tx) {
+  Signer.prototype.addTransaction = function (transaction) {
     return __awaiter(this, void 0, void 0, function () {
-      var result, nonceBn, 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 (tx.type === 'DEPLOY')
-              return [2 /*return*/, _super.prototype.addTransaction.call(this, tx)];
+            if (transaction.type === 'DEPLOY')
+              return [2 /*return*/, _super.prototype.addTransaction.call(this, transaction)];
             (0,
-            minimalistic_assert_1.default)(!tx.signature, "Adding signatures to a signer tx currently isn't supported");
+            minimalistic_assert_1.default)(!transaction.signature, "Adding signatures to a signer transaction currently isn't supported");
+            if (!transaction.nonce) return [3 /*break*/, 1];
+            nonceBn = (0, number_1.toBN)(transaction.nonce);
+            return [3 /*break*/, 3];
+          case 1:
             return [
               4 /*yield*/,
               this.callContract({
@@ -236,22 +241,24 @@ var Signer = /** @class */ (function (_super) {
                 entry_point_selector: (0, stark_1.getSelectorFromName)('get_nonce'),
               }),
             ];
-          case 1:
-            result = _b.sent().result;
+          case 2:
+            result = _a.sent().result;
             nonceBn = (0, number_1.toBN)(result[0]);
-            calldataDecimal = (tx.calldata || []).map(function (x) {
+            _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,
-                tx.contract_address,
-                tx.entry_point_selector,
+                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, {
@@ -260,8 +267,8 @@ var Signer = /** @class */ (function (_super) {
                 calldata: __spreadArray(
                   __spreadArray(
                     [
-                      tx.contract_address,
-                      tx.entry_point_selector,
+                      transaction.contract_address,
+                      transaction.entry_point_selector,
                       calldataDecimal.length.toString(),
                     ],
                     __read(calldataDecimal),
@@ -273,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;
   /**
@@ -7,8 +8,26 @@ export declare abstract class SignerInterface extends Provider {
    *
    * [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
    */
-  abstract addTransaction(tx: Transaction): Promise<AddTransactionResponse>;
+  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>;
 }