starknet 3.12.1 → 3.13.0

package/src/provider/default.ts

@@ -1,4 +1,4 @@
-import axios, { AxiosRequestHeaders } from 'axios';
+import fetch from 'cross-fetch';
 import urljoin from 'url-join';
 
 import { StarknetChainId } from '../constants';
@@ -10,7 +10,6 @@ import {
   CompiledContract,
   DeployContractPayload,
   Endpoints,
-  EstimateFeeResponse,
   GetBlockResponse,
   GetCodeResponse,
   GetContractAddressesResponse,
@@ -32,7 +31,9 @@ type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
 type ProviderOptions = { network: NetworkName } | { baseUrl: string };
 
 function wait(delay: number) {
-  return new Promise((res) => setTimeout(res, delay));
+  return new Promise((res) => {
+    setTimeout(res, delay);
+  });
 }
 
 function isEmptyQueryObject(obj?: Record<any, any>): obj is undefined {
@@ -125,7 +126,7 @@ export class Provider implements ProviderInterface {
     return `?${queryString}`;
   }
 
-  private getHeaders(method: 'POST' | 'GET'): AxiosRequestHeaders | undefined {
+  private getHeaders(method: 'POST' | 'GET'): Record<string, string> | undefined {
     if (method === 'POST') {
       return {
         'Content-Type': 'application/json',
@@ -150,33 +151,25 @@ export class Provider implements ProviderInterface {
     const method = this.getFetchMethod(endpoint);
     const queryString = this.getQueryString(query);
     const headers = this.getHeaders(method);
-
-    try {
-      const { data } = await axios.request<Endpoints[T]['RESPONSE']>({
-        method,
-        transformResponse:
-          endpoint === 'estimate_fee'
-            ? (res): EstimateFeeResponse => {
-                return parse(res, (_, v) => {
-                  if (v && typeof v === 'bigint') {
-                    return toBN(v.toString());
-                  }
-                  return v;
-                });
-              }
-            : axios.defaults.transformResponse,
-        url: urljoin(baseUrl, endpoint, queryString),
-        data: stringify(request),
-        headers,
+    const url = urljoin(baseUrl, endpoint, queryString);
+
+    return fetch(url, {
+      method,
+      body: stringify(request),
+      headers,
+    })
+      .then((res) => res.text())
+      .then((res) => {
+        if (endpoint === 'estimate_fee') {
+          return parse(res, (_, v) => {
+            if (v && typeof v === 'bigint') {
+              return toBN(v.toString());
+            }
+            return v;
+          });
+        }
+        return parse(res) as Endpoints[T]['RESPONSE'];
       });
-      return data;
-    } catch (error: any) {
-      const data = error?.response?.data;
-      if (data?.message) {
-        throw new Error(`${data.code}: ${data.message}`);
-      }
-      throw error;
-    }
   }
 
   /**
@@ -259,7 +252,7 @@ export class Provider implements ProviderInterface {
    */
   public async getStorageAt(
     contractAddress: string,
-    key: number,
+    key: BigNumberish,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<object> {
     return this.fetchEndpoint('get_storage_at', { blockIdentifier, contractAddress, key });

package/src/provider/interface.ts

@@ -85,7 +85,7 @@ export abstract class ProviderInterface {
    */
   public abstract getStorageAt(
     contractAddress: string,
-    key: number,
+    key: BigNumberish,
     blockIdentifier?: BlockIdentifier
   ): Promise<object>;
 

package/src/types/api.ts

@@ -55,7 +55,7 @@ export type Endpoints = {
   get_storage_at: {
     QUERY: {
       contractAddress: string;
-      key: number;
+      key: BigNumberish;
       blockIdentifier: BlockIdentifier;
     };
     REQUEST: never;

package/src/utils/typedData/types.ts

@@ -1,82 +1,29 @@
-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()])),
-});
+export interface StarkNetType {
+  name: string;
+  type: 'felt' | 'felt*' | string;
+}
 
 /**
  * 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(),
-});
+export interface StarkNetDomain extends Record<string, unknown> {
+  name?: string;
+  version?: string;
+  chainId?: string | number;
+}
 
 /**
  * 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>;
+export interface TypedData {
+  types: Record<string, StarkNetType[]>;
+  primaryType: string;
+  domain: StarkNetDomain;
+  message: Record<string, unknown>;
+}

package/src/utils/typedData/utils.ts

@@ -1,6 +1,4 @@
-import { is } from 'superstruct';
-
-import { STARKNET_TYPED_DATA_TYPE, TypedData } from './types';
+import { TypedData } from './types';
 
 /**
  * Validates that `data` matches the EIP-712 JSON schema.
@@ -9,5 +7,10 @@ import { STARKNET_TYPED_DATA_TYPE, TypedData } from './types';
  * @return {boolean}
  */
 export const validateTypedData = (data: unknown): data is TypedData => {
-  return is(data, STARKNET_TYPED_DATA_TYPE);
+  const typedData = data as TypedData;
+
+  // Validate that the data matches the EIP-712 JSON schema
+  const valid = Boolean(typedData.types && typedData.primaryType && typedData.message);
+
+  return valid;
 };

package/types/api.d.ts

@@ -54,7 +54,7 @@ export declare type Endpoints = {
   get_storage_at: {
     QUERY: {
       contractAddress: string;
-      key: number;
+      key: BigNumberish;
       blockIdentifier: BlockIdentifier;
     };
     REQUEST: never;

package/types/index.js

@@ -4,12 +4,16 @@ var __createBinding =
   (Object.create
     ? function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;
-        Object.defineProperty(o, k2, {
-          enumerable: true,
-          get: function () {
-            return m[k];
-          },
-        });
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
       }
     : function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;

package/utils/ellipticCurve.js

@@ -68,7 +68,7 @@ function fixMessage(msg) {
   }
   (0, minimalistic_assert_1.default)(pureHex.length === 63);
   // In this case delta will be 4 so we perform a shift-left of 4 bits by adding a ZERO_BN.
-  return pureHex + '0';
+  return ''.concat(pureHex, '0');
 }
 exports.genKeyPair = exports.ec.genKeyPair.bind(exports.ec);
 function getKeyPair(pk) {

package/utils/encode.js

@@ -76,7 +76,7 @@ function removeHexPrefix(hex) {
 }
 exports.removeHexPrefix = removeHexPrefix;
 function addHexPrefix(hex) {
-  return '0x' + removeHexPrefix(hex);
+  return '0x'.concat(removeHexPrefix(hex));
 }
 exports.addHexPrefix = addHexPrefix;
 function padString(str, length, left, padding) {

package/utils/hash.js

@@ -97,7 +97,7 @@ function pedersen(input) {
     (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: ' + input[i]
+      'Invalid input: '.concat(input[i])
     );
     for (var j = 0; j < 252; j += 1) {
       var pt = constantPoints[2 + i * 252 + j];

package/utils/number.js

@@ -4,12 +4,16 @@ var __createBinding =
   (Object.create
     ? function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;
-        Object.defineProperty(o, k2, {
-          enumerable: true,
-          get: function () {
-            return m[k];
-          },
-        });
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
       }
     : function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;
@@ -68,7 +72,7 @@ function toHex(number) {
 }
 exports.toHex = toHex;
 function hexToDecimalString(hex) {
-  return toBN('0x' + hex.replace(/^0x/, '')).toString();
+  return toBN('0x'.concat(hex.replace(/^0x/, ''))).toString();
 }
 exports.hexToDecimalString = hexToDecimalString;
 function toFelt(num) {
@@ -88,11 +92,11 @@ function assertInRange(input, lowerBound, upperBound, inputName) {
   if (inputName === void 0) {
     inputName = '';
   }
-  var messageSuffix = inputName === '' ? 'invalid length' : 'invalid ' + inputName + ' length';
+  var messageSuffix = inputName === '' ? 'invalid length' : 'invalid '.concat(inputName, ' length');
   var inputBn = toBN(input);
   (0, minimalistic_assert_1.default)(
     inputBn.gte(toBN(lowerBound)) && inputBn.lt(toBN(upperBound)),
-    'Message not signable, ' + messageSuffix + '.'
+    'Message not signable, '.concat(messageSuffix, '.')
   );
 }
 exports.assertInRange = assertInRange;

package/utils/shortString.js

@@ -17,8 +17,8 @@ function isShortString(str) {
 }
 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');
+  if (!isASCII(str)) throw new Error(''.concat(str, ' is not an ASCII string'));
+  if (!isShortString(str)) throw new Error(''.concat(str, ' is too long'));
   return (0, encode_1.addHexPrefix)(
     str.replace(/./g, function (char) {
       return char.charCodeAt(0).toString(16);

package/utils/typedData/index.d.ts

@@ -39,29 +39,7 @@ export declare const getTypeHash: (typedData: TypedData, type: string) => string
  * @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: {
-      version?: string | undefined;
-      chainId?: string | number | undefined;
-      name?: string | undefined;
-    };
-    message: Record<string, unknown>;
-  }
->(
+export declare const encodeData: <T extends TypedData>(
   typedData: T,
   type: string,
   data: T['message']
@@ -75,29 +53,7 @@ export declare const encodeData: <
  * @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: {
-      version?: string | undefined;
-      chainId?: string | number | undefined;
-      name?: string | undefined;
-    };
-    message: Record<string, unknown>;
-  }
->(
+export declare const getStructHash: <T extends TypedData>(
   typedData: T,
   type: string,
   data: T['message']

package/utils/typedData/index.js

@@ -4,12 +4,16 @@ var __createBinding =
   (Object.create
     ? function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;
-        Object.defineProperty(o, k2, {
-          enumerable: true,
-          get: function () {
-            return m[k];
-          },
-        });
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
       }
     : function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;
@@ -76,7 +80,7 @@ function getHex(value) {
     if (typeof value === 'string') {
       return (0, number_1.toHex)((0, number_1.toBN)((0, shortString_1.encodeShortString)(value)));
     }
-    throw new Error('Invalid BigNumberish: ' + value);
+    throw new Error('Invalid BigNumberish: '.concat(value));
   }
 }
 /**
@@ -135,12 +139,10 @@ var encodeType = function (typedData, type) {
   var types = __spreadArray([primary], __read(dependencies.sort()), false);
   return types
     .map(function (dependency) {
-      return (
-        dependency +
-        '(' +
+      return ''.concat(dependency, '(').concat(
         typedData.types[dependency].map(function (t) {
-          return t.name + ':' + t.type;
-        }) +
+          return ''.concat(t.name, ':').concat(t.type);
+        }),
         ')'
       );
     })
@@ -193,7 +195,7 @@ var encodeData = function (typedData, type, data) {
             ts = _b[0],
             vs = _b[1];
           if (data[field.name] === undefined || data[field.name] === null) {
-            throw new Error("Cannot encode data: missing data for '" + field.name + "'");
+            throw new Error("Cannot encode data: missing data for '".concat(field.name, "'"));
           }
           var value = data[field.name];
           var _c = __read(encodeValue(typedData, field.type, value), 2),

package/utils/typedData/types.d.ts

@@ -1,103 +1,27 @@
-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<
-  {
-    version?: string | undefined;
-    chainId?: string | number | undefined;
-    name?: string | undefined;
-  },
-  {
-    name: import('superstruct').Struct<string | undefined, null>;
-    version: import('superstruct').Struct<string | undefined, null>;
-    chainId: import('superstruct').Struct<string | number | undefined, null>;
-  }
->;
+export interface StarkNetType {
+  name: string;
+  type: 'felt' | 'felt*' | string;
+}
 /**
  * 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: {
-      version?: string | undefined;
-      chainId?: string | number | undefined;
-      name?: string | 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<
-      {
-        version?: string | undefined;
-        chainId?: string | number | undefined;
-        name?: string | 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>;
-  }
->;
+export interface StarkNetDomain extends Record<string, unknown> {
+  name?: string;
+  version?: string;
+  chainId?: string | number;
+}
 /**
  * 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>;
+export interface TypedData {
+  types: Record<string, StarkNetType[]>;
+  primaryType: string;
+  domain: StarkNetDomain;
+  message: Record<string, unknown>;
+}

package/utils/typedData/types.js

@@ -1,57 +1,2 @@
 '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/utils/typedData/utils.d.ts

@@ -1,27 +1,8 @@
+import { TypedData } from './types';
 /**
  * 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: {
-    version?: string | undefined;
-    chainId?: string | number | undefined;
-    name?: string | undefined;
-  };
-  message: Record<string, unknown>;
-};
+export declare const validateTypedData: (data: unknown) => data is TypedData;