starknet 4.17.0 → 4.18.0

package/src/utils/stark.ts

@@ -1,57 +0,0 @@
-import BN from 'bn.js';
-import { gzip } from 'pako';
-
-import { Calldata, CompressedProgram, Program, RawArgs, Signature } from '../types';
-import { genKeyPair, getStarkKey } from './ellipticCurve';
-import { addHexPrefix, btoaUniversal } from './encode';
-import { stringify } from './json';
-import { BigNumberish, toBN } from './number';
-
-/**
- * Function to compress compiled cairo program
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/services/api/gateway/transaction.py#L54-L58)
- * @param jsonProgram - json file representing the compiled cairo program
- * @returns Compressed cairo program
- */
-export function compressProgram(jsonProgram: Program | string): CompressedProgram {
-  const stringified = typeof jsonProgram === 'string' ? jsonProgram : stringify(jsonProgram);
-  const compressedProgram = gzip(stringified);
-  return btoaUniversal(compressedProgram);
-}
-
-export function randomAddress(): string {
-  const randomKeyPair = genKeyPair();
-  return getStarkKey(randomKeyPair);
-}
-
-export function makeAddress(input: string): string {
-  return addHexPrefix(input).toLowerCase();
-}
-
-export function formatSignature(sig?: Signature): string[] {
-  if (!sig) return [];
-  try {
-    return sig.map((x) => toBN(x)).map((x) => x.toString());
-  } catch (e) {
-    return [];
-  }
-}
-
-export function compileCalldata(args: RawArgs): Calldata {
-  return Object.values(args).flatMap((value) => {
-    if (Array.isArray(value))
-      return [toBN(value.length).toString(), ...value.map((x) => toBN(x).toString())];
-    if (typeof value === 'object' && 'type' in value)
-      return Object.entries(value)
-        .filter(([k]) => k !== 'type')
-        .map(([, v]) => toBN(v).toString());
-    return toBN(value).toString();
-  });
-}
-
-export function estimatedFeeToMaxFee(estimatedFee: BigNumberish, overhead: number = 0.5): BN {
-  // BN can only handle Integers, so we need to do all calulations with integers
-  const overHeadPercent = Math.round((1 + overhead) * 100);
-  return toBN(estimatedFee).mul(toBN(overHeadPercent)).div(toBN(100));
-}

package/src/utils/starknetId.ts

@@ -1,116 +0,0 @@
-/* eslint-disable no-param-reassign */
-import BN from 'bn.js';
-
-import { StarknetChainId } from '../constants';
-
-const basicAlphabet = 'abcdefghijklmnopqrstuvwxyz0123456789-';
-const basicSizePlusOne = new BN(basicAlphabet.length + 1);
-const bigAlphabet = '这来';
-const basicAlphabetSize = new BN(basicAlphabet.length);
-const bigAlphabetSize = new BN(bigAlphabet.length);
-const bigAlphabetSizePlusOne = new BN(bigAlphabet.length + 1);
-
-function extractStars(str: string): [string, number] {
-  let k = 0;
-  while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
-    str = str.substring(0, str.length - 1);
-    k += 1;
-  }
-  return [str, k];
-}
-
-export function useDecoded(encoded: BN[]): string {
-  let decoded = '';
-
-  encoded.forEach((subdomain) => {
-    while (!subdomain.isZero()) {
-      const code = subdomain.mod(basicSizePlusOne).toNumber();
-      subdomain = subdomain.div(basicSizePlusOne);
-      if (code === basicAlphabet.length) {
-        const nextSubdomain = subdomain.div(bigAlphabetSizePlusOne);
-        if (nextSubdomain.isZero()) {
-          const code2 = subdomain.mod(bigAlphabetSizePlusOne).toNumber();
-          subdomain = nextSubdomain;
-          if (code2 === 0) decoded += basicAlphabet[0];
-          else decoded += bigAlphabet[code2 - 1];
-        } else {
-          const code2 = subdomain.mod(bigAlphabetSize).toNumber();
-          decoded += bigAlphabet[code2];
-          subdomain = subdomain.div(bigAlphabetSize);
-        }
-      } else decoded += basicAlphabet[code];
-    }
-
-    const [str, k] = extractStars(decoded);
-    if (k)
-      decoded =
-        str +
-        (k % 2 === 0
-          ? bigAlphabet[bigAlphabet.length - 1].repeat(k / 2 - 1) +
-            bigAlphabet[0] +
-            basicAlphabet[1]
-          : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
-    decoded += '.';
-  });
-  return decoded.concat('stark');
-}
-
-export function useEncoded(decoded: string): BN {
-  let encoded = new BN(0);
-  let multiplier = new BN(1);
-
-  if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
-    const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
-    decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
-  } else {
-    const [str, k] = extractStars(decoded);
-    if (k) decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
-  }
-
-  for (let i = 0; i < decoded.length; i += 1) {
-    const char = decoded[i];
-    const index = basicAlphabet.indexOf(char);
-    const bnIndex = new BN(basicAlphabet.indexOf(char));
-
-    if (index !== -1) {
-      // add encoded + multiplier * index
-      if (i === decoded.length - 1 && decoded[i] === basicAlphabet[0]) {
-        encoded = encoded.add(multiplier.mul(basicAlphabetSize));
-        multiplier = multiplier.mul(basicSizePlusOne);
-        // add 0
-        multiplier = multiplier.mul(basicSizePlusOne);
-      } else {
-        encoded = encoded.add(multiplier.mul(bnIndex));
-        multiplier = multiplier.mul(basicSizePlusOne);
-      }
-    } else if (bigAlphabet.indexOf(char) !== -1) {
-      // add encoded + multiplier * (basicAlphabetSize)
-      encoded = encoded.add(multiplier.mul(basicAlphabetSize));
-      multiplier = multiplier.mul(basicSizePlusOne);
-      // add encoded + multiplier * index
-      const newid = (i === decoded.length - 1 ? 1 : 0) + bigAlphabet.indexOf(char);
-      encoded = encoded.add(multiplier.mul(new BN(newid)));
-      multiplier = multiplier.mul(bigAlphabetSize);
-    }
-  }
-
-  return encoded;
-}
-
-export function getStarknetIdContract(chainId: StarknetChainId): string {
-  const starknetIdMainnetContract =
-    '0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678';
-  const starknetIdTestnetContract =
-    '0x05cf267a0af6101667013fc6bd3f6c11116a14cda9b8c4b1198520d59f900b17';
-
-  switch (chainId) {
-    case StarknetChainId.MAINNET:
-      return starknetIdMainnetContract;
-
-    case StarknetChainId.TESTNET:
-      return starknetIdTestnetContract;
-
-    default:
-      throw new Error('Starknet.id is not yet deployed on this network');
-  }
-}

package/src/utils/transaction.ts

@@ -1,56 +0,0 @@
-import { Call, ParsedStruct } from '../types';
-import { getSelectorFromName } from './hash';
-import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN } from './number';
-
-/**
- * Transforms a list of Calls, each with their own calldata, into
- * two arrays: one with the entrypoints, and one with the concatenated calldata.
- * @param calls
- * @returns
- */
-export const transformCallsToMulticallArrays = (calls: Call[]) => {
-  const callArray: ParsedStruct[] = [];
-  const calldata: BigNumberish[] = [];
-  calls.forEach((call) => {
-    const data = call.calldata || [];
-    callArray.push({
-      to: toBN(call.contractAddress).toString(10),
-      selector: toBN(getSelectorFromName(call.entrypoint)).toString(10),
-      data_offset: calldata.length.toString(),
-      data_len: data.length.toString(),
-    });
-    calldata.push(...data);
-  });
-  return {
-    callArray,
-    calldata: bigNumberishArrayToDecimalStringArray(calldata),
-  };
-};
-
-/**
- * Transforms a list of calls in the full flattened calldata expected
- * by the __execute__ protocol.
- * @param calls
- * @returns
- */
-export const fromCallsToExecuteCalldata = (calls: Call[]): string[] => {
-  const { callArray, calldata } = transformCallsToMulticallArrays(calls);
-  return [
-    callArray.length.toString(),
-    ...callArray
-      .map(
-        ({ to, selector, data_offset, data_len }) =>
-          [to, selector, data_offset, data_len] as string[]
-      )
-      .flat(),
-    calldata.length.toString(),
-    ...calldata,
-  ];
-};
-
-export const fromCallsToExecuteCalldataWithNonce = (
-  calls: Call[],
-  nonce: BigNumberish
-): string[] => {
-  return [...fromCallsToExecuteCalldata(calls), toBN(nonce).toString()];
-};

package/src/utils/typedData/index.ts

@@ -1,247 +0,0 @@
-import { computeHashOnElements, getSelectorFromName } from '../hash';
-import { MerkleTree } from '../merkle';
-import { BigNumberish, isHex, toBN, toHex } from '../number';
-import { encodeShortString } from '../shortString';
-import { StarkNetMerkleType, StarkNetType, 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}`);
-  }
-}
-
-export function prepareSelector(selector: string): string {
-  return isHex(selector) ? selector : getSelectorFromName(selector);
-}
-
-export function isMerkleTreeType(type: StarkNetType): type is StarkNetMerkleType {
-  return type.type === 'merkletree';
-}
-
-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.
- *
- * @param {TypedData} typedData
- * @param {string} type
- * @param {string[]} [dependencies]
- * @return {string[]}
- */
-export const getDependencies = (
-  types: TypedData['types'],
-  type: string,
-  dependencies: string[] = []
-): string[] => {
-  // Include pointers (struct arrays)
-  if (type[type.length - 1] === '*') {
-    // eslint-disable-next-line no-param-reassign
-    type = type.slice(0, -1);
-  }
-
-  if (dependencies.includes(type)) {
-    return dependencies;
-  }
-
-  if (!types[type]) {
-    return dependencies;
-  }
-
-  return [
-    type,
-    ...types[type].reduce<string[]>(
-      (previous, t) => [
-        ...previous,
-        ...getDependencies(types, t.type, previous).filter(
-          (dependency) => !previous.includes(dependency)
-        ),
-      ],
-      []
-    ),
-  ];
-};
-
-function getMerkleTreeType(types: TypedData['types'], ctx: Context) {
-  if (ctx.parent && ctx.key) {
-    const parentType = types[ctx.parent];
-    const merkleType = parentType.find((t) => t.name === ctx.key)!;
-    const isMerkleTree = isMerkleTreeType(merkleType);
-    if (!isMerkleTree) {
-      throw new Error(`${ctx.key} is not a merkle tree`);
-    }
-    if (merkleType.contains.endsWith('*')) {
-      throw new Error(`Merkle tree contain property must not be an array but was given ${ctx.key}`);
-    }
-    return merkleType.contains;
-  }
-  return 'raw';
-}
-
-/**
- * Encode a type to a string. All dependant types are alphabetically sorted.
- *
- * @param {TypedData} typedData
- * @param {string} type
- * @return {string}
- */
-export const encodeType = (types: TypedData['types'], type: string): string => {
-  const [primary, ...dependencies] = getDependencies(types, type);
-  const newTypes = !primary ? [] : [primary, ...dependencies.sort()];
-
-  return newTypes
-    .map((dependency) => {
-      return `${dependency}(${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 = (types: TypedData['types'], type: string): string => {
-  return getSelectorFromName(encodeType(types, 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]}
- */
-export const encodeValue = (
-  types: TypedData['types'],
-  type: string,
-  data: unknown,
-  ctx: Context = {}
-): [string, string] => {
-  if (types[type]) {
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    return [type, getStructHash(types, type, data as Record<string, unknown>)];
-  }
-
-  if (
-    Object.keys(types)
-      .map((x) => `${x}*`)
-      .includes(type)
-  ) {
-    const structHashes: string[] = (data as unknown[]).map((struct) => {
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      return getStructHash(types, type.slice(0, -1), struct as Record<string, unknown>);
-    });
-    return [type, computeHashOnElements(structHashes)];
-  }
-
-  if (type === 'merkletree') {
-    const merkleTreeType = getMerkleTreeType(types, ctx);
-    const structHashes: string[] = (data as unknown[]).map((struct) => {
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      return encodeValue(types, merkleTreeType, struct as Record<string, unknown>)[1];
-    });
-    const { root } = new MerkleTree(structHashes as string[]);
-    return ['felt', root];
-  }
-
-  if (type === 'felt*') {
-    return ['felt*', computeHashOnElements(data as string[])];
-  }
-
-  if (type === 'selector') {
-    return ['felt', prepareSelector(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>(
-  types: T['types'],
-  type: string,
-  data: T['message']
-) => {
-  const [returnTypes, values] = 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(types, field.type, value, {
-        parent: type,
-        key: field.name,
-      });
-
-      return [
-        [...ts, t],
-        [...vs, encodedValue],
-      ];
-    },
-    [['felt'], [getTypeHash(types, type)]]
-  );
-
-  return [returnTypes, 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>(
-  types: T['types'],
-  type: string,
-  data: T['message']
-) => {
-  return computeHashOnElements(encodeData(types, type, data)[1]);
-};
-
-/**
- * Get the EIP-191 encoded message to sign, from the typedData object.
- *
- * @param {TypedData} typedData
- * @param {BigNumberish} account
- * @return {string}
- */
-export const getMessageHash = (typedData: TypedData, account: BigNumberish): string => {
-  if (!validateTypedData(typedData)) {
-    throw new Error('Typed data does not match JSON schema');
-  }
-
-  const message = [
-    encodeShortString('StarkNet Message'),
-    getStructHash(typedData.types, 'StarkNetDomain', typedData.domain),
-    account,
-    getStructHash(typedData.types, typedData.primaryType, typedData.message),
-  ];
-
-  return computeHashOnElements(message);
-};

package/src/utils/typedData/types.ts

@@ -1,37 +0,0 @@
-export type StarkNetMerkleType = {
-  name: string;
-  type: 'merkletree';
-  contains: string;
-};
-
-/**
- * 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 =
-  | {
-      name: string;
-      type: string;
-    }
-  | StarkNetMerkleType;
-
-/**
- * The EIP712 domain struct. Any of these fields are optional, but it must contain at least one field.
- */
-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 interface TypedData {
-  types: Record<string, StarkNetType[]>;
-  primaryType: string;
-  domain: StarkNetDomain;
-  message: Record<string, unknown>;
-}

package/src/utils/typedData/utils.ts

@@ -1,16 +0,0 @@
-import { 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 => {
-  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/src/utils/uint256.ts

@@ -1,32 +0,0 @@
-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/src/utils/url.ts

@@ -1,53 +0,0 @@
-import urljoin from 'url-join';
-
-/**
- * Inspired from https://github.com/segmentio/is-url
- */
-
-/**
- * RegExps.
- * A URL must match #1 and then at least one of #2/#3.
- * Use two levels of REs to avoid REDOS.
- */
-const protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
-
-const localhostDomainRE = /^localhost[:?\d]*(?:[^:?\d]\S*)?$/;
-const nonLocalhostDomainRE = /^[^\s.]+\.\S{2,}$/;
-
-/**
- * Loosely validate a URL `string`.
- * @param {String} s
- * @return {Boolean}
- */
-export function isUrl(s?: string): boolean {
-  if (!s) {
-    return false;
-  }
-
-  if (typeof s !== 'string') {
-    return false;
-  }
-
-  const match = s.match(protocolAndDomainRE);
-  if (!match) {
-    return false;
-  }
-
-  const everythingAfterProtocol = match[1];
-  if (!everythingAfterProtocol) {
-    return false;
-  }
-
-  if (
-    localhostDomainRE.test(everythingAfterProtocol) ||
-    nonLocalhostDomainRE.test(everythingAfterProtocol)
-  ) {
-    return true;
-  }
-
-  return false;
-}
-
-export function buildUrl(baseUrl: string, defaultPath: string, urlOrPath?: string) {
-  return isUrl(urlOrPath) ? urlOrPath! : urljoin(baseUrl, urlOrPath ?? defaultPath);
-}

package/tsconfig.eslint.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["src/**/*", "__tests__/**/*"]
-}

package/tsup.config.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  sourcemap: true,
-  clean: true,
-  format: ['cjs'],
-  globalName: 'starknet',
-});

package/www/README.md

@@ -1,41 +0,0 @@
-# Website
-
-This website is built using [Docusaurus 2](https://docusaurus.io/), a modern static website generator.
-
-### Installation
-
-```
-$ yarn
-```
-
-### Local Development
-
-```
-$ yarn start
-```
-
-This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
-
-### Build
-
-```
-$ yarn build
-```
-
-This command generates static content into the `build` directory and can be served using any static contents hosting service.
-
-### Deployment
-
-Using SSH:
-
-```
-$ USE_SSH=true yarn deploy
-```
-
-Not using SSH:
-
-```
-$ GIT_USER=<Your GitHub username> yarn deploy
-```
-
-If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.

package/www/babel.config.js

@@ -1,3 +0,0 @@
-module.exports = {
-  presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
-};