starknet 4.17.0 → 4.18.0

package/src/utils/address.ts

@@ -1,44 +0,0 @@
-/* eslint-disable no-bitwise */
-import { arrayify } from '@ethersproject/bytes';
-
-import { MASK_251, ZERO } from '../constants';
-import { addHexPrefix, removeHexPrefix } from './encode';
-import { keccakBn } from './hash';
-import { BigNumberish, assertInRange, toBN, toHex } from './number';
-
-export function addAddressPadding(address: BigNumberish): string {
-  return addHexPrefix(removeHexPrefix(toHex(toBN(address))).padStart(64, '0'));
-}
-
-export function validateAndParseAddress(address: BigNumberish): string {
-  assertInRange(address, ZERO, MASK_251, 'Starknet Address');
-
-  const result = addAddressPadding(address);
-
-  if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
-    throw new Error('Invalid Address Format');
-  }
-
-  return result;
-}
-
-// from https://github.com/ethers-io/ethers.js/blob/fc1e006575d59792fa97b4efb9ea2f8cca1944cf/packages/address/src.ts/index.ts#L12
-export function getChecksumAddress(address: BigNumberish): string {
-  const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split('');
-  const hashed = arrayify(keccakBn(address), { hexPad: 'left' }); // in case the hash is 251 bits (63 chars) we need to pad it to 64 chars without changing the number value ("left")
-
-  for (let i = 0; i < chars.length; i += 2) {
-    if (hashed[i >> 1] >> 4 >= 8) {
-      chars[i] = chars[i].toUpperCase();
-    }
-    if ((hashed[i >> 1] & 0x0f) >= 8) {
-      chars[i + 1] = chars[i + 1].toUpperCase();
-    }
-  }
-
-  return addHexPrefix(chars.join(''));
-}
-
-export function validateChecksumAddress(address: string): boolean {
-  return getChecksumAddress(address) === address;
-}

package/src/utils/calldata.ts

@@ -1,250 +0,0 @@
-import BN from 'bn.js';
-import assert from 'minimalistic-assert';
-
-import { Abi, AbiEntry, Calldata, FunctionAbi, ParsedStruct, StructAbi } from '../types';
-import { BigNumberish, toFelt } from './number';
-
-export class CheckCallData {
-  abi: Abi;
-
-  protected readonly structs: { [name: string]: StructAbi };
-
-  constructor(abi: Abi) {
-    this.abi = abi;
-    this.structs = abi
-      .filter((abiEntry) => abiEntry.type === 'struct')
-      .reduce(
-        (acc, abiEntry) => ({
-          ...acc,
-          [abiEntry.name]: abiEntry,
-        }),
-        {}
-      );
-  }
-
-  /**
-   * Parse the calldata by using input fields from the abi for that method
-   *
-   * @param args - arguments passed the the method
-   * @param inputs  - list of inputs(fields) that are in the abi
-   * @return {Calldata} - parsed arguments in format that contract is expecting
-   */
-  public compileCalldata(args: Array<any>, inputs: AbiEntry[]): Calldata {
-    const argsIterator = args[Symbol.iterator]();
-    return inputs.reduce((acc, input) => {
-      if (/_len$/.test(input.name)) {
-        return acc;
-      }
-      const parsedData = this.parseCalldataField(argsIterator, input);
-      if (Array.isArray(parsedData)) {
-        acc.push(...parsedData);
-      } else {
-        acc.push(parsedData);
-      }
-      return acc;
-    }, [] as Calldata);
-  }
-
-  /**
-   * Validates if all arguments that are passed to the method are corresponding to the ones in the abi
-   *
-   * @param type - type of the method
-   * @param method  - name of the method
-   * @param args - arguments that are passed to the method
-   */
-  public validateMethodAndArgs(
-    type: 'INVOKE' | 'CALL' | 'DEPLOY',
-    method: string,
-    args: Array<any> = []
-  ) {
-    // ensure provided method exists
-    if (type !== 'DEPLOY') {
-      const invocableFunctionNames = this.abi
-        .filter((abi) => {
-          if (abi.type !== 'function') return false;
-          const isView = abi.stateMutability === 'view';
-          return type === 'INVOKE' ? !isView : isView;
-        })
-        .map((abi) => abi.name);
-      assert(
-        invocableFunctionNames.includes(method),
-        `${type === 'INVOKE' ? 'invocable' : 'viewable'} method not found in abi`
-      );
-    }
-
-    // ensure args match abi type
-    const methodAbi = this.abi.find((abi) =>
-      type === 'DEPLOY'
-        ? abi.name === method && abi.type === method
-        : abi.name === method && abi.type === 'function'
-    ) as FunctionAbi;
-    let argPosition = 0;
-    methodAbi.inputs.forEach((input) => {
-      if (/_len$/.test(input.name)) {
-        return;
-      }
-      if (input.type === 'felt') {
-        assert(
-          typeof args[argPosition] === 'string' ||
-            typeof args[argPosition] === 'number' ||
-            args[argPosition] instanceof BN,
-          `arg ${input.name} should be a felt (string, number, BigNumber)`
-        );
-        argPosition += 1;
-      } else if (input.type in this.structs && typeof args[argPosition] === 'object') {
-        if (Array.isArray(args[argPosition])) {
-          const structMembersLength = this.calculateStructMembers(input.type);
-          assert(
-            args[argPosition].length === structMembersLength,
-            `arg should be of length ${structMembersLength}`
-          );
-        } else {
-          this.structs[input.type].members.forEach(({ name }) => {
-            assert(
-              Object.keys(args[argPosition]).includes(name),
-              `arg should have a property ${name}`
-            );
-          });
-        }
-        argPosition += 1;
-      } else {
-        assert(Array.isArray(args[argPosition]), `arg ${input.name} should be an Array`);
-        if (input.type === 'felt*') {
-          args[argPosition].forEach((felt: BigNumberish) => {
-            assert(
-              typeof felt === 'string' || typeof felt === 'number' || felt instanceof BN,
-              `arg ${input.name} should be an array of string, number or BigNumber`
-            );
-          });
-          argPosition += 1;
-        } else if (/\(felt/.test(input.type)) {
-          const tupleLength = input.type.split(',').length;
-          assert(
-            args[argPosition].length === tupleLength,
-            `arg ${input.name} should have ${tupleLength} elements in tuple`
-          );
-          args[argPosition].forEach((felt: BigNumberish) => {
-            assert(
-              typeof felt === 'string' || typeof felt === 'number' || felt instanceof BN,
-              `arg ${input.name} should be an array of string, number or BigNumber`
-            );
-          });
-          argPosition += 1;
-        } else {
-          const arrayType = input.type.replace('*', '');
-          args[argPosition].forEach((struct: any) => {
-            this.structs[arrayType].members.forEach(({ name }) => {
-              if (Array.isArray(struct)) {
-                const structMembersLength = this.calculateStructMembers(arrayType);
-                assert(
-                  struct.length === structMembersLength,
-                  `arg should be of length ${structMembersLength}`
-                );
-              } else {
-                assert(
-                  Object.keys(struct).includes(name),
-                  `arg ${input.name} should be an array of ${arrayType}`
-                );
-              }
-            });
-          });
-          argPosition += 1;
-        }
-      }
-    });
-  }
-
-  /**
-   * Parse one field of the calldata by using input field from the abi for that method
-   *
-   * @param args - value of the field
-   * @param input  - input(field) information from the abi that will be used to parse the data
-   * @return {string | string[]} - parsed arguments in format that contract is expecting
-   */
-  protected parseCalldataField(argsIterator: Iterator<any>, input: AbiEntry): string | string[] {
-    const { name, type } = input;
-    const { value } = argsIterator.next();
-
-    const parsedCalldata: string[] = [];
-    switch (true) {
-      case /\*/.test(type):
-        if (Array.isArray(value)) {
-          parsedCalldata.push(toFelt(value.length));
-          return (value as (BigNumberish | ParsedStruct)[]).reduce((acc, el) => {
-            if (/felt/.test(type)) {
-              acc.push(toFelt(el as BigNumberish));
-            } else {
-              acc.push(...this.parseCalldataValue(el, type.replace('*', '')));
-            }
-            return acc;
-          }, parsedCalldata);
-        }
-        throw Error(`Expected ${name} to be array`);
-      case type in this.structs:
-        return this.parseCalldataValue(value as ParsedStruct | BigNumberish[], type);
-      case /\(felt/.test(type):
-        if (Array.isArray(value)) {
-          return value.map((el) => toFelt(el as BigNumberish));
-        }
-        throw Error(`Expected ${name} to be array`);
-      default:
-        return toFelt(value as BigNumberish);
-    }
-  }
-
-  /**
-   * Deep parse of the object that has been passed to the method
-   *
-   * @param element - element that needs to be parsed
-   * @param type  - name of the method
-   * @return {string | string[]} - parsed arguments in format that contract is expecting
-   */
-
-  protected parseCalldataValue(
-    element: ParsedStruct | BigNumberish | BigNumberish[],
-    type: string
-  ): string | string[] {
-    if (element === undefined) {
-      throw Error('Missing element in calldata');
-    }
-    if (Array.isArray(element)) {
-      const structMemberNum = this.calculateStructMembers(type);
-      if (element.length !== structMemberNum) {
-        throw Error('Missing element in calldata');
-      }
-      return element.map((el) => toFelt(el));
-    }
-    // checking if the passed element is struct or element in struct
-    if (this.structs[type] && this.structs[type].members.length) {
-      // going through all the members of the struct and parsing the value
-      return this.structs[type].members.reduce((acc, member: AbiEntry) => {
-        // if the member of the struct is another struct this will return array of the felts if not it will be single felt
-        // TODO: refactor types so member name can be used as keyof ParsedStruct
-        /* @ts-ignore */
-        const parsedData = this.parseCalldataValue(element[member.name], member.type);
-        if (typeof parsedData === 'string') {
-          acc.push(parsedData);
-        } else {
-          acc.push(...parsedData);
-        }
-        return acc;
-      }, [] as string[]);
-    }
-    return toFelt(element as BigNumberish);
-  }
-
-  /**
-   * Deep parse of the object that has been passed to the method
-   *
-   * @param struct - struct that needs to be calculated
-   * @return {number} - number of members for the given struct
-   */
-  private calculateStructMembers(struct: string): number {
-    return this.structs[struct].members.reduce((acc, member) => {
-      if (member.type === 'felt') {
-        return acc + 1;
-      }
-      return acc + this.calculateStructMembers(member.type);
-    }, 0);
-  }
-}

package/src/utils/ellipticCurve.ts

@@ -1,120 +0,0 @@
-import elliptic from 'elliptic';
-import hashJS from 'hash.js';
-import assert from 'minimalistic-assert';
-
-import { CONSTANT_POINTS, EC_ORDER, FIELD_PRIME, MAX_ECDSA_VAL, ONE, ZERO } from '../constants';
-import { KeyPair, Signature } from '../types';
-import { addHexPrefix, removeHexPrefix, sanitizeBytes } from './encode';
-import { BigNumberish, assertInRange, toBN, toHex } from './number';
-
-const { ec: EC, curves } = elliptic;
-
-export const ec = new EC(
-  new curves.PresetCurve({
-    type: 'short',
-    prime: null,
-    p: FIELD_PRIME,
-    a: '00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001',
-    b: '06f21413 efbe40de 150e596d 72f7a8c5 609ad26c 15c915c1 f4cdfcb9 9cee9e89',
-    n: EC_ORDER,
-    hash: hashJS.sha256,
-    gRed: false,
-    g: 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.
- *
- * @param msg
- */
-function fixMessage(msg: string) {
-  const pureHex = msg.replace(/^0x0*/, '');
-
-  if (pureHex.length <= 62) {
-    // In this case, pureHex should not be transformed, as the byteLength() is at most 31,
-    // so delta < 0 (see _truncateToN).
-    return pureHex;
-  }
-  assert(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`;
-}
-
-export const genKeyPair = ec.genKeyPair.bind(ec);
-
-export function getKeyPair(pk: BigNumberish): KeyPair {
-  const pkBn = toBN(pk);
-  return ec.keyFromPrivate(removeHexPrefix(toHex(pkBn)), 'hex');
-}
-
-export function getStarkKey(keyPair: KeyPair): string {
-  // this method needs to be run to generate the .pub property used below
-  // the result can be dumped
-  keyPair.getPublic(true, 'hex');
-  return addHexPrefix(sanitizeBytes((keyPair as any).pub.getX().toString(16), 2));
-}
-
-/**
- * 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 function getKeyPairFromPublicKey(publicKey: BigNumberish): KeyPair {
-  const publicKeyBn = toBN(publicKey);
-  return ec.keyFromPublic(removeHexPrefix(toHex(publicKeyBn)), 'hex');
-}
-
-/**
- * Signs a message using the provided key.
- *
- * @param keyPair should be an KeyPair with a valid private key.
- * @returns an Signature.
- */
-export function sign(keyPair: KeyPair, msgHash: string): Signature {
-  const msgHashBN = toBN(addHexPrefix(msgHash));
-  // Verify message hash has valid length.
-  assertInRange(msgHashBN, ZERO, toBN(addHexPrefix(MAX_ECDSA_VAL)), 'msgHash');
-  const msgSignature = keyPair.sign(fixMessage(msgHash));
-  const { r, s } = msgSignature;
-  const w = s.invm((ec as any).n);
-  // Verify signature has valid length.
-  assertInRange(r, ONE, toBN(addHexPrefix(MAX_ECDSA_VAL)), 'r');
-  assertInRange(s, ONE, toBN(addHexPrefix(EC_ORDER)), 's');
-  assertInRange(w, ONE, toBN(addHexPrefix(MAX_ECDSA_VAL)), 'w');
-  return [r.toString(), s.toString()];
-}
-
-function chunkArray(arr: any[], n: number): any[][] {
-  return Array(Math.ceil(arr.length / n))
-    .fill('')
-    .map((_, i) => arr.slice(i * n, i * n + n));
-}
-
-/**
- * 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 function verify(keyPair: KeyPair | KeyPair[], msgHash: string, sig: Signature): boolean {
-  const keyPairArray = Array.isArray(keyPair) ? keyPair : [keyPair];
-  const msgHashBN = toBN(addHexPrefix(msgHash));
-  assert(sig.length % 2 === 0, 'Signature must be an array of length dividable by 2');
-  assertInRange(msgHashBN, ZERO, toBN(addHexPrefix(MAX_ECDSA_VAL)), 'msgHash');
-  assert(keyPairArray.length === sig.length / 2, 'Signature and keyPair length must be equal');
-
-  return chunkArray(sig, 2).every(([r, s], i) => {
-    const rBN = toBN(r);
-    const sBN = toBN(s);
-    const w = sBN.invm((ec as any).n);
-    assertInRange(rBN, ONE, toBN(addHexPrefix(MAX_ECDSA_VAL)), 'r');
-    assertInRange(sBN, ONE, toBN(addHexPrefix(EC_ORDER)), 's');
-    assertInRange(w, ONE, toBN(addHexPrefix(MAX_ECDSA_VAL)), 'w');
-    return ec.verify(fixMessage(msgHash), { r: rBN, s: sBN }, keyPairArray[i]) ?? false;
-  });
-}

package/src/utils/encode.ts

@@ -1,66 +0,0 @@
-/* eslint-disable no-param-reassign */
-export const IS_BROWSER = typeof window !== 'undefined';
-
-const STRING_ZERO = '0';
-
-export function arrayBufferToString(array: ArrayBuffer): string {
-  return new Uint8Array(array).reduce((data, byte) => data + String.fromCharCode(byte), '');
-}
-
-export function btoaUniversal(b: ArrayBuffer): string {
-  return IS_BROWSER ? btoa(arrayBufferToString(b)) : Buffer.from(b).toString('base64');
-}
-
-export function buf2hex(buffer: Uint8Array) {
-  return [...buffer].map((x) => x.toString(16).padStart(2, '0')).join('');
-}
-
-/**
- * Some function imported from https://github.com/pedrouid/enc-utils/blob/master/src/index.ts
- * enc-utils is no dependency to avoid using `Buffer` which just works in node and no browsers
- */
-
-export function removeHexPrefix(hex: string): string {
-  return hex.replace(/^0x/, '');
-}
-
-export function addHexPrefix(hex: string): string {
-  return `0x${removeHexPrefix(hex)}`;
-}
-
-function padString(str: string, length: number, left: boolean, padding = STRING_ZERO): string {
-  const diff = length - str.length;
-  let result = str;
-  if (diff > 0) {
-    const pad = padding.repeat(diff);
-    result = left ? pad + str : str + pad;
-  }
-  return result;
-}
-
-export function padLeft(str: string, length: number, padding = STRING_ZERO): string {
-  return padString(str, length, true, padding);
-}
-
-export function calcByteLength(length: number, byteSize = 8): number {
-  const remainder = length % byteSize;
-  return remainder ? ((length - remainder) / byteSize) * byteSize + byteSize : length;
-}
-
-export function sanitizeBytes(str: string, byteSize = 8, padding = STRING_ZERO): string {
-  return padLeft(str, calcByteLength(str.length, byteSize), padding);
-}
-
-export function sanitizeHex(hex: string): string {
-  hex = removeHexPrefix(hex);
-  hex = sanitizeBytes(hex, 2);
-  if (hex) {
-    hex = addHexPrefix(hex);
-  }
-  return hex;
-}
-
-// implemented using TextEncoder to make it isomorphic
-export function utf8ToArray(str: string): Uint8Array {
-  return new TextEncoder().encode(str);
-}

package/src/utils/events.ts

@@ -1,32 +0,0 @@
-import { UDC } from '../constants';
-import { InvokeTransactionReceiptResponse } from '../types/provider';
-import { cleanHex } from './number';
-
-/**
- * Parse Transaction Receipt Event from UDC invoke transaction and
- * create DeployContractResponse compatibile response with adition of UDC Event data
- *
- * @param txReceipt
- * @returns DeployContractResponse | UDC Event Response data
- */
-export function parseUDCEvent(txReceipt: InvokeTransactionReceiptResponse) {
-  if (!txReceipt.events) {
-    throw new Error('UDC emited event is empty');
-  }
-  const event = txReceipt.events.find(
-    (it) => cleanHex(it.from_address) === cleanHex(UDC.ADDRESS)
-  ) || {
-    data: [],
-  };
-  return {
-    transaction_hash: txReceipt.transaction_hash,
-    contract_address: event.data[0],
-    address: event.data[0],
-    deployer: event.data[1],
-    unique: event.data[2],
-    classHash: event.data[3],
-    calldata_len: event.data[4],
-    calldata: event.data.slice(5, 5 + parseInt(event.data[4], 16)),
-    salt: event.data[event.data.length - 1],
-  };
-}

package/src/utils/fetchPonyfill.ts

@@ -1,5 +0,0 @@
-import isomorphicFetch from 'isomorphic-fetch';
-
-export default (typeof window !== 'undefined' && window.fetch) || // use buildin fetch in browser if available
-  (typeof global !== 'undefined' && global.fetch) || // use buildin fetch in node, react-native and service worker if available
-  isomorphicFetch; // ponyfill fetch in node and browsers that don't have it