starknet 2.2.0 → 2.5.0

package/src/utils/typedData/index.ts

@@ -0,0 +1,176 @@
+import { computeHashOnElements } from '../hash';
+import { BigNumberish, toBN, toHex } from '../number';
+import { encodeShortString } from '../shortString';
+import { getSelectorFromName } from '../stark';
+import { TypedData } from './types';
+import { validateTypedData } from './utils';
+
+export * from './types';
+
+function getHex(value: BigNumberish): string {
+  try {
+    return toHex(toBN(value));
+  } catch (e) {
+    if (typeof value === 'string') {
+      return toHex(toBN(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[]}
+ */
+export const getDependencies = (
+  typedData: TypedData,
+  type: string,
+  dependencies: string[] = []
+): string[] => {
+  // `getDependencies` is called by most other functions, so we validate the JSON schema here
+  if (!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 [
+    type,
+    ...typedData.types[type].reduce<string[]>(
+      (previous, t) => [
+        ...previous,
+        ...getDependencies(typedData, t.type, previous).filter(
+          (dependency) => !previous.includes(dependency)
+        ),
+      ],
+      []
+    ),
+  ];
+};
+
+/**
+ * Encode a type to a string. All dependant types are alphabetically sorted.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @return {string}
+ */
+export const encodeType = (typedData: TypedData, type: string): string => {
+  const [primary, ...dependencies] = getDependencies(typedData, type);
+  const types = [primary, ...dependencies.sort()];
+
+  return types
+    .map((dependency) => {
+      return `${dependency}(${typedData.types[dependency].map((t) => `${t.name}:${t.type}`)})`;
+    })
+    .join('');
+};
+
+/**
+ * Get a type string as hash.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @return {string}
+ */
+export const getTypeHash = (typedData: TypedData, type: string): string => {
+  return getSelectorFromName(encodeType(typedData, type));
+};
+
+/**
+ * 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]}
+ */
+const encodeValue = (typedData: TypedData, type: string, data: unknown): [string, string] => {
+  if (typedData.types[type]) {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    return [type, getStructHash(typedData, type, data as Record<string, unknown>)];
+  }
+
+  if (type === 'felt*') {
+    return ['felt*', computeHashOnElements(data as string[])];
+  }
+
+  return [type, getHex(data as 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 const encodeData = <T extends TypedData>(typedData: T, type: string, data: T['message']) => {
+  const [types, values] = typedData.types[type].reduce<[string[], string[]]>(
+    ([ts, vs], field) => {
+      if (data[field.name] === undefined || data[field.name] === null) {
+        throw new Error(`Cannot encode data: missing data for '${field.name}'`);
+      }
+
+      const value = data[field.name];
+      const [t, encodedValue] = encodeValue(typedData, field.type, value);
+
+      return [
+        [...ts, t],
+        [...vs, encodedValue],
+      ];
+    },
+    [['felt'], [getTypeHash(typedData, type)]]
+  );
+
+  return [types, values];
+};
+
+/**
+ * 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 const getStructHash = <T extends TypedData>(
+  typedData: T,
+  type: string,
+  data: T['message']
+) => {
+  return computeHashOnElements(encodeData(typedData, type, data)[1]);
+};
+
+/**
+ * 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 const getMessageHash = (typedData: TypedData, account: BigNumberish): string => {
+  const message = [
+    encodeShortString('StarkNet Message'),
+    getStructHash(typedData, 'StarkNetDomain', typedData.domain),
+    account,
+    getStructHash(typedData, typedData.primaryType, typedData.message),
+  ];
+
+  return computeHashOnElements(message);
+};

package/src/utils/typedData/types.ts

@@ -0,0 +1,82 @@
+import {
+  Infer,
+  array,
+  intersection,
+  number,
+  object,
+  optional,
+  record,
+  refine,
+  string,
+  type as t,
+  union,
+} from 'superstruct';
+
+export const 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}
+ */
+export const isValidType = (types: Record<string, unknown>, type: string): boolean => {
+  if (ATOMIC_TYPES.includes(type as string)) {
+    return true;
+  }
+
+  if (types[type]) {
+    return true;
+  }
+
+  return false;
+};
+
+const TYPE = refine(string(), 'Type', (type, context) => {
+  return isValidType(context.branch[0].types, type);
+});
+
+export const STARKNET_TYPE = object({
+  name: string(),
+  type: TYPE,
+});
+
+/**
+ * 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 type StarkNetType = Infer<typeof STARKNET_TYPE>;
+
+export const STARKNET_DOMAIN_TYPE = object({
+  name: optional(string()),
+  version: optional(string()),
+  chainId: optional(union([string(), number()])),
+});
+
+/**
+ * The EIP712 domain struct. Any of these fields are optional, but it must contain at least one field.
+ */
+export type StarkNetDomain = Infer<typeof STARKNET_DOMAIN_TYPE>;
+
+export const STARKNET_TYPED_DATA_TYPE = object({
+  types: intersection([
+    t({ StarkNetDomain: array(STARKNET_TYPE) }),
+    record(string(), array(STARKNET_TYPE)),
+  ]),
+  primaryType: string(),
+  domain: STARKNET_DOMAIN_TYPE,
+  message: object(),
+});
+
+/**
+ * The complete typed data, with all the structs, domain data, primary type of the message, and the message itself.
+ */
+export type TypedData = Infer<typeof STARKNET_TYPED_DATA_TYPE>;

package/src/utils/typedData/utils.ts

@@ -0,0 +1,13 @@
+import { is } from 'superstruct';
+
+import { STARKNET_TYPED_DATA_TYPE, TypedData } from './types';
+
+/**
+ * Validates that `data` matches the EIP-712 JSON schema.
+ *
+ * @param {any} data
+ * @return {boolean}
+ */
+export const validateTypedData = (data: unknown): data is TypedData => {
+  return is(data, STARKNET_TYPED_DATA_TYPE);
+};

package/src/utils/uint256.ts

@@ -0,0 +1,32 @@
+import { addHexPrefix } from './encode';
+import { BigNumberish, toBN } from './number';
+
+// Represents an integer in the range [0, 2^256).
+export interface Uint256 {
+  // The low 128 bits of the value.
+  low: BigNumberish;
+  // The high 128 bits of the value.
+  high: BigNumberish;
+}
+
+// function to convert Uint256 to BN
+export function uint256ToBN(uint256: Uint256) {
+  return toBN(uint256.high).shln(128).add(toBN(uint256.low));
+}
+
+export const UINT_128_MAX = toBN(1).shln(128).sub(toBN(1));
+export const UINT_256_MAX = toBN(1).shln(256).sub(toBN(1));
+// function to check if BN is smaller or equal 2**256-1
+export function isUint256(bn: BigNumberish): boolean {
+  return toBN(bn).lte(UINT_256_MAX);
+}
+
+// function to convert BN to Uint256
+export function bnToUint256(bignumber: BigNumberish): Uint256 {
+  const bn = toBN(bignumber);
+  if (!isUint256(bn)) throw new Error('Number is too large');
+  return {
+    low: addHexPrefix(bn.maskn(128).toString(16)),
+    high: addHexPrefix(bn.shrn(128).toString(16)),
+  };
+}

package/types.d.ts

@@ -2,7 +2,7 @@ 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;
@@ -11,9 +11,10 @@ export declare type Status =
   | 'NOT_RECEIVED'
   | 'RECEIVED'
   | 'PENDING'
-  | 'REJECTED'
-  | 'ACCEPTED_ONCHAIN';
-export declare type TxStatus = 'TRANSACTION_RECEIVED';
+  | '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';
 export declare type CompressedProgram = string;
@@ -50,14 +51,16 @@ export declare type DeployTransaction = {
   contract_definition: CompressedCompiledContract;
   contract_address_salt: BigNumberish;
   constructor_calldata: string[];
+  nonce?: BigNumberish;
 };
 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[];
+  nonce?: BigNumberish;
 };
 export declare type CallContractTransaction = Omit<InvokeFunctionTransaction, 'type'>;
 export declare type Transaction = DeployTransaction | InvokeFunctionTransaction;
@@ -106,7 +109,7 @@ export declare type GetTransactionResponse = {
   transaction_hash: string;
 };
 export declare type AddTransactionResponse = {
-  code: TxStatus;
+  code: TransactionStatus;
   transaction_hash: string;
   address?: string;
 };

package/utils/ellipticCurve.d.ts

@@ -6,5 +6,16 @@ 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/utils/ellipticCurve.js

@@ -1,4 +1,26 @@
 '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) {
@@ -7,6 +29,7 @@ var __importDefault =
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.verify =
   exports.sign =
+  exports.getKeyPairFromPublicKey =
   exports.getStarkKey =
   exports.getKeyPair =
   exports.genKeyPair =
@@ -62,6 +85,20 @@ function getStarkKey(keyPair) {
   );
 }
 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.
@@ -99,9 +136,16 @@ function sign(keyPair, msgHash) {
     (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.
@@ -109,35 +153,40 @@ 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'
+  (0, minimalistic_assert_1.default)(
+    keyPairArray.length === sig.length / 2,
+    'Signature and keyPair length must be equal'
   );
-  return keyPair.verify(fixMessage(msgHash), sig);
+  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/utils/shortString.d.ts

@@ -0,0 +1,4 @@
+export declare function isASCII(str: string): boolean;
+export declare function isShortString(str: string): boolean;
+export declare function encodeShortString(str: string): string;
+export declare function decodeShortString(str: string): string;

package/utils/shortString.js

@@ -0,0 +1,34 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.decodeShortString =
+  exports.encodeShortString =
+  exports.isShortString =
+  exports.isASCII =
+    void 0;
+var encode_1 = require('./encode');
+function isASCII(str) {
+  // eslint-disable-next-line no-control-regex
+  return /^[\x00-\x7F]*$/.test(str);
+}
+exports.isASCII = isASCII;
+// function to check if string has less or equal 31 characters
+function isShortString(str) {
+  return str.length <= 31;
+}
+exports.isShortString = isShortString;
+function encodeShortString(str) {
+  if (!isASCII(str)) throw new Error(str + ' is not an ASCII string');
+  if (!isShortString(str)) throw new Error(str + ' is too long');
+  return (0, encode_1.addHexPrefix)(
+    str.replace(/./g, function (char) {
+      return char.charCodeAt(0).toString(16);
+    })
+  );
+}
+exports.encodeShortString = encodeShortString;
+function decodeShortString(str) {
+  return (0, encode_1.removeHexPrefix)(str).replace(/.{2}/g, function (hex) {
+    return String.fromCharCode(parseInt(hex, 16));
+  });
+}
+exports.decodeShortString = decodeShortString;

package/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/utils/typedData/index.d.ts

@@ -0,0 +1,113 @@
+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;