starknet 4.17.0 → 4.18.0

package/src/utils/hash.ts

@@ -1,235 +0,0 @@
-/* eslint-disable import/extensions */
-import BN from 'bn.js';
-import { keccak256 } from 'ethereum-cryptography/keccak.js';
-import { hexToBytes } from 'ethereum-cryptography/utils.js';
-import assert from 'minimalistic-assert';
-
-import {
-  CONSTANT_POINTS,
-  FIELD_PRIME,
-  MASK_250,
-  ONE,
-  StarknetChainId,
-  TransactionHashPrefix,
-  ZERO,
-} from '../constants';
-import { RawCalldata } from '../types';
-import { ec } from './ellipticCurve';
-import { addHexPrefix, buf2hex, removeHexPrefix, utf8ToArray } from './encode';
-import {
-  BigNumberish,
-  isHex,
-  isStringWholeNumber,
-  toBN,
-  toFelt,
-  toHex,
-  toHexString,
-} from './number';
-
-export const transactionVersion = 1;
-export const feeTransactionVersion = toBN(2).pow(toBN(128)).add(toBN(transactionVersion));
-
-export function keccakBn(value: BigNumberish): string {
-  const hexWithoutPrefix = removeHexPrefix(toHex(toBN(value)));
-  const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
-  return addHexPrefix(buf2hex(keccak256(hexToBytes(evenHex))));
-}
-
-function keccakHex(value: string): string {
-  return addHexPrefix(buf2hex(keccak256(utf8ToArray(value))));
-}
-
-/**
- * Function to get the starknet keccak hash from a string
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L17-L22)
- * @param value - string you want to get the starknetKeccak hash from
- * @returns starknet keccak hash as BigNumber
- */
-export function starknetKeccak(value: string): BN {
-  return toBN(keccakHex(value)).and(MASK_250);
-}
-
-/**
- * Function to get the hex selector from a given function name
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L25-L26)
- * @param funcName - selectors abi function name
- * @returns hex selector of given abi function name
- */
-export function getSelectorFromName(funcName: string) {
-  // sometimes BigInteger pads the hex string with zeros, which is not allowed in the starknet api
-  return toHex(starknetKeccak(funcName));
-}
-
-/**
- * Function to get hex selector from function name, decimal string or hex string
- * @param value hex string | decimal string | string
- * @returns Hex selector
- */
-export function getSelector(value: string) {
-  if (isHex(value)) {
-    return value;
-  }
-  if (isStringWholeNumber(value)) {
-    return toHexString(value);
-  }
-  return getSelectorFromName(value);
-}
-
-const constantPoints = CONSTANT_POINTS.map((coords: string[]) =>
-  ec.curve.point(coords[0], coords[1])
-);
-
-export function pedersen(input: [BigNumberish, BigNumberish]) {
-  let point = constantPoints[0];
-  for (let i = 0; i < input.length; i += 1) {
-    let x = toBN(input[i]);
-    assert(x.gte(ZERO) && x.lt(toBN(addHexPrefix(FIELD_PRIME))), `Invalid input: ${input[i]}`);
-    if (!x.isZero()) {
-      for (let j = 0; j < 252; j += 1) {
-        const pt = constantPoints[2 + i * 252 + j];
-        assert(!point.getX().eq(pt.getX()));
-        if (x.and(ONE).toNumber() !== 0) {
-          point = point.add(pt);
-        }
-        x = x.shrn(1);
-      }
-    }
-  }
-  return addHexPrefix(point.getX().toString(16));
-}
-
-export function computeHashOnElements(data: BigNumberish[]) {
-  return [...data, data.length].reduce((x, y) => pedersen([x, y]), 0).toString();
-}
-
-// following implementation is based on this python implementation:
-// https://github.com/starkware-libs/cairo-lang/blob/b614d1867c64f3fb2cf4a4879348cfcf87c3a5a7/src/starkware/starknet/core/os/transaction_hash/transaction_hash.py
-
-export function calculateTransactionHashCommon(
-  txHashPrefix: TransactionHashPrefix,
-  version: BigNumberish,
-  contractAddress: BigNumberish,
-  entryPointSelector: BigNumberish,
-  calldata: BigNumberish[],
-  maxFee: BigNumberish,
-  chainId: StarknetChainId,
-  additionalData: BigNumberish[] = []
-): string {
-  const calldataHash = computeHashOnElements(calldata);
-  const dataToHash = [
-    txHashPrefix,
-    version,
-    contractAddress,
-    entryPointSelector,
-    calldataHash,
-    maxFee,
-    chainId,
-    ...additionalData,
-  ];
-  return computeHashOnElements(dataToHash);
-}
-
-export function calculateDeployTransactionHash(
-  contractAddress: BigNumberish,
-  constructorCalldata: BigNumberish[],
-  version: BigNumberish,
-  chainId: StarknetChainId
-): string {
-  return calculateTransactionHashCommon(
-    TransactionHashPrefix.DEPLOY,
-    version,
-    contractAddress,
-    getSelectorFromName('constructor'),
-    constructorCalldata,
-    ZERO,
-    chainId
-  );
-}
-
-export function calculateDeclareTransactionHash(
-  // contractClass: ContractClass, // Should be used once class hash is present in ContractClass
-  classHash: BigNumberish,
-  senderAddress: BigNumberish,
-  version: BigNumberish,
-  maxFee: BigNumberish,
-  chainId: StarknetChainId,
-  nonce: BigNumberish
-): string {
-  return calculateTransactionHashCommon(
-    TransactionHashPrefix.DECLARE,
-    version,
-    senderAddress,
-    0,
-    [classHash],
-    maxFee,
-    chainId,
-    [nonce]
-  );
-}
-
-export function calculateDeployAccountTransactionHash(
-  contractAddress: BigNumberish,
-  classHash: BigNumberish,
-  constructorCalldata: BigNumberish[],
-  salt: BigNumberish,
-  version: BigNumberish,
-  maxFee: BigNumberish,
-  chainId: StarknetChainId,
-  nonce: BigNumberish
-) {
-  const calldata = [classHash, salt, ...constructorCalldata];
-
-  return calculateTransactionHashCommon(
-    TransactionHashPrefix.DEPLOY_ACCOUNT,
-    version,
-    contractAddress,
-    0,
-    calldata,
-    maxFee,
-    chainId,
-    [nonce]
-  );
-}
-
-export function calculateTransactionHash(
-  contractAddress: BigNumberish,
-  version: BigNumberish,
-  calldata: BigNumberish[],
-  maxFee: BigNumberish,
-  chainId: StarknetChainId,
-  nonce: BigNumberish
-): string {
-  return calculateTransactionHashCommon(
-    TransactionHashPrefix.INVOKE,
-    version,
-    contractAddress,
-    0,
-    calldata,
-    maxFee,
-    chainId,
-    [nonce]
-  );
-}
-
-export function calculateContractAddressFromHash(
-  salt: BigNumberish,
-  classHash: BigNumberish,
-  constructorCalldata: RawCalldata,
-  deployerAddress: BigNumberish
-) {
-  const constructorCalldataHash = computeHashOnElements(constructorCalldata);
-
-  const CONTRACT_ADDRESS_PREFIX = toFelt('0x535441524b4e45545f434f4e54524143545f41444452455353'); // Equivalent to 'STARKNET_CONTRACT_ADDRESS'
-
-  const dataToHash = [
-    CONTRACT_ADDRESS_PREFIX,
-    deployerAddress,
-    salt,
-    classHash,
-    constructorCalldataHash,
-  ];
-
-  return computeHashOnElements(dataToHash);
-}

package/src/utils/json.ts

@@ -1,15 +0,0 @@
-import Json from 'json-bigint';
-
-const json = (alwaysParseAsBig: boolean) => {
-  return Json({
-    alwaysParseAsBig,
-    useNativeBigInt: true,
-    protoAction: 'preserve',
-    constructorAction: 'preserve',
-  });
-};
-
-export const { parse, stringify } = json(false);
-export const { parse: parseAlwaysAsBig, stringify: stringifyAlwaysAsBig } = json(true);
-
-export default { parse, stringify };

package/src/utils/merkle.ts

@@ -1,69 +0,0 @@
-import { pedersen } from './hash';
-import { toBN } from './number';
-
-export class MerkleTree {
-  public leaves: string[];
-
-  public branches: string[][] = [];
-
-  public root: string;
-
-  constructor(leafHashes: string[]) {
-    this.leaves = leafHashes;
-    this.root = this.build(leafHashes);
-  }
-
-  private build(leaves: string[]): string {
-    if (leaves.length === 1) {
-      return leaves[0];
-    }
-    if (leaves.length !== this.leaves.length) {
-      this.branches.push(leaves);
-    }
-    const newLeaves = [];
-    for (let i = 0; i < leaves.length; i += 2) {
-      if (i + 1 === leaves.length) {
-        newLeaves.push(MerkleTree.hash(leaves[i], '0x0'));
-      } else {
-        newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1]));
-      }
-    }
-    return this.build(newLeaves);
-  }
-
-  static hash(a: string, b: string) {
-    const [aSorted, bSorted] = [toBN(a), toBN(b)].sort((x: any, y: any) => (x.gte(y) ? 1 : -1));
-    return pedersen([aSorted, bSorted]);
-  }
-
-  public getProof(leaf: string, branch = this.leaves, hashPath: string[] = []): string[] {
-    const index = branch.indexOf(leaf);
-    if (index === -1) {
-      throw new Error('leaf not found');
-    }
-    if (branch.length === 1) {
-      return hashPath;
-    }
-    const isLeft = index % 2 === 0;
-    const neededBranch = (isLeft ? branch[index + 1] : branch[index - 1]) ?? '0x0';
-    const newHashPath = [...hashPath, neededBranch];
-    const currentBranchLevelIndex =
-      this.leaves.length === branch.length
-        ? -1
-        : this.branches.findIndex((b) => b.length === branch.length);
-    const nextBranch = this.branches[currentBranchLevelIndex + 1] ?? [this.root];
-    return this.getProof(
-      MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf),
-      nextBranch,
-      newHashPath
-    );
-  }
-}
-
-export function proofMerklePath(root: string, leaf: string, path: string[]): boolean {
-  if (path.length === 0) {
-    return root === leaf;
-  }
-  const [next, ...rest] = path;
-  return proofMerklePath(root, MerkleTree.hash(leaf, next), rest);
-}

package/src/utils/number.ts

@@ -1,98 +0,0 @@
-import BN from 'bn.js';
-import assert from 'minimalistic-assert';
-
-import { addHexPrefix, removeHexPrefix } from './encode';
-
-export type BigNumberish = string | number | BN;
-
-export function isHex(hex: string): boolean {
-  return /^0x[0-9a-f]*$/i.test(hex);
-}
-
-export function toBN(number: BigNumberish, base?: number | 'hex') {
-  if (typeof number === 'string') {
-    // eslint-disable-next-line no-param-reassign
-    number = number.toLowerCase();
-  }
-  if (typeof number === 'string' && isHex(number) && !base)
-    return new BN(removeHexPrefix(number), 'hex');
-  return new BN(number, base);
-}
-
-export function toHex(number: BN): string {
-  return addHexPrefix(number.toString('hex'));
-}
-
-export function hexToDecimalString(hex: string): string {
-  return toBN(`0x${hex.replace(/^0x/, '')}`).toString();
-}
-
-export function toFelt(num: BigNumberish): string {
-  if (BN.isBN(num)) {
-    return num.toString();
-  }
-  return toBN(num).toString();
-}
-
-/**
- * Remove hex string leading zero and lower case '0x01A'.. -> '0x1a..'
- * @param hex string
- */
-export const cleanHex = (hex: string) => hex.toLowerCase().replace(/^(0x)0+/, '$1');
-
-/*
- Asserts input is equal to or greater then lowerBound and lower then upperBound.
- Assert message specifies inputName.
- input, lowerBound, and upperBound should be of type BN.
- inputName should be a string.
-*/
-export function assertInRange(
-  input: BigNumberish,
-  lowerBound: BigNumberish,
-  upperBound: BigNumberish,
-  inputName = ''
-) {
-  const messageSuffix = inputName === '' ? 'invalid length' : `invalid ${inputName} length`;
-  const inputBn = toBN(input);
-  assert(
-    inputBn.gte(toBN(lowerBound)) && inputBn.lt(toBN(upperBound)),
-    `Message not signable, ${messageSuffix}.`
-  );
-}
-
-export function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[] {
-  return rawCalldata.map((x) => toBN(x).toString(10));
-}
-
-export function bigNumberishArrayToHexadecimalStringArray(rawCalldata: BigNumberish[]): string[] {
-  return rawCalldata.map((x) => toHex(toBN(x)));
-}
-
-export const isStringWholeNumber = (value: string) => /^\d+$/.test(value);
-export const toHexString = (value: string) => toHex(toBN(value));
-
-export function getDecimalString(value: string) {
-  if (isHex(value)) {
-    return hexToDecimalString(value);
-  }
-  if (isStringWholeNumber(value)) {
-    return value;
-  }
-  throw new Error(`${value} need to be hex-string or whole-number-string`);
-}
-
-export function getHexString(value: string) {
-  if (isHex(value)) {
-    return value;
-  }
-  if (isStringWholeNumber(value)) {
-    return toHexString(value);
-  }
-  throw new Error(`${value} need to be hex-string or whole-number-string`);
-}
-
-export function getHexStringArray(value: Array<string>) {
-  return value.map((el) => getHexString(el));
-}
-
-export const toCairoBool = (value: boolean): string => (+value).toString();

package/src/utils/provider.ts

@@ -1,28 +0,0 @@
-import { CompiledContract, ContractClass, RawCalldata } from '../types';
-import { parse } from './json';
-import { isHex, toBN, toHex } from './number';
-import { compressProgram } from './stark';
-
-export function wait(delay: number) {
-  return new Promise((res) => {
-    setTimeout(res, delay);
-  });
-}
-
-export function parseCalldata(calldata: RawCalldata = []) {
-  return calldata.map((data) => {
-    if (typeof data === 'string' && isHex(data as string)) {
-      return data;
-    }
-    return toHex(toBN(data));
-  });
-}
-
-export function parseContract(contract: CompiledContract | string) {
-  const parsedContract =
-    typeof contract === 'string' ? (parse(contract) as CompiledContract) : contract;
-  return {
-    ...parsedContract,
-    program: compressProgram(parsedContract.program),
-  } as ContractClass;
-}

package/src/utils/responseParser/index.ts

@@ -1,28 +0,0 @@
-import {
-  CallContractResponse,
-  DeclareContractResponse,
-  DeployContractResponse,
-  EstimateFeeResponse,
-  GetBlockResponse,
-  GetTransactionReceiptResponse,
-  GetTransactionResponse,
-  InvokeFunctionResponse,
-} from '../../types';
-
-export abstract class ResponseParser {
-  abstract parseGetBlockResponse(res: any): GetBlockResponse;
-
-  abstract parseGetTransactionResponse(res: any): GetTransactionResponse;
-
-  abstract parseGetTransactionReceiptResponse(res: any): GetTransactionReceiptResponse;
-
-  abstract parseFeeEstimateResponse(res: any): EstimateFeeResponse;
-
-  abstract parseCallContractResponse(res: any): CallContractResponse;
-
-  abstract parseInvokeFunctionResponse(res: any): InvokeFunctionResponse;
-
-  abstract parseDeployContractResponse(res: any): DeployContractResponse;
-
-  abstract parseDeclareContractResponse(res: any): DeclareContractResponse;
-}

package/src/utils/responseParser/rpc.ts

@@ -1,70 +0,0 @@
-/**
- * Map RPC Response to common interface response
- * Intersection (sequencer response ∩ (∪ rpc responses))
- */
-import {
-  CallContractResponse,
-  EstimateFeeResponse,
-  GetBlockResponse,
-  GetTransactionResponse,
-  RPC,
-} from '../../types';
-import { toBN } from '../number';
-import { ResponseParser } from '.';
-
-type RpcGetBlockResponse = RPC.GetBlockWithTxHashesResponse & {
-  [key: string]: any;
-};
-
-type GetTransactionByHashResponse = RPC.GetTransactionByHashResponse & {
-  [key: string]: any;
-};
-
-export class RPCResponseParser
-  implements
-    Omit<
-      ResponseParser,
-      | 'parseDeclareContractResponse'
-      | 'parseDeployContractResponse'
-      | 'parseInvokeFunctionResponse'
-      | 'parseGetTransactionReceiptResponse'
-    >
-{
-  public parseGetBlockResponse(res: RpcGetBlockResponse): GetBlockResponse {
-    return {
-      timestamp: res.timestamp,
-      block_hash: res.block_hash,
-      block_number: res.block_number,
-      new_root: res.new_root,
-      parent_hash: res.parent_hash,
-      status: res.status,
-      transactions: res.transactions,
-    };
-  }
-
-  public parseGetTransactionResponse(res: GetTransactionByHashResponse): GetTransactionResponse {
-    return {
-      calldata: res.calldata || [],
-      contract_address: res.contract_address,
-      max_fee: res.max_fee,
-      nonce: res.nonce,
-      signature: res.signature || [],
-      transaction_hash: res.transaction_hash,
-      version: res.version,
-    };
-  }
-
-  public parseFeeEstimateResponse(res: RPC.EstimateFeeResponse): EstimateFeeResponse {
-    return {
-      overall_fee: toBN(res.overall_fee),
-      gas_consumed: toBN(res.gas_consumed),
-      gas_price: toBN(res.gas_price),
-    };
-  }
-
-  public parseCallContractResponse(res: Array<string>): CallContractResponse {
-    return {
-      result: res,
-    };
-  }
-}

package/src/utils/responseParser/sequencer.ts

@@ -1,135 +0,0 @@
-/**
- * Map Sequencer Response to common interface response
- * Intersection (sequencer response ∩ (∪ rpc responses))
- */
-import {
-  CallContractResponse,
-  DeclareContractResponse,
-  DeployContractResponse,
-  EstimateFeeResponse,
-  GetBlockResponse,
-  GetTransactionReceiptResponse,
-  GetTransactionResponse,
-  InvokeFunctionResponse,
-  Sequencer,
-} from '../../types';
-import { toBN } from '../number';
-import { ResponseParser } from '.';
-
-export class SequencerAPIResponseParser extends ResponseParser {
-  public parseGetBlockResponse(res: Sequencer.GetBlockResponse): GetBlockResponse {
-    return {
-      ...res,
-      new_root: res.state_root,
-      parent_hash: res.parent_block_hash,
-      transactions: Object.values(res.transactions)
-        .map((value) => 'transaction_hash' in value && value.transaction_hash)
-        .filter(Boolean) as Array<string>,
-    };
-  }
-
-  public parseGetTransactionResponse(
-    res: Sequencer.GetTransactionResponse
-  ): GetTransactionResponse {
-    return {
-      ...res,
-      calldata: 'calldata' in res.transaction ? (res.transaction.calldata as Array<string>) : [],
-      contract_address:
-        'contract_address' in res.transaction ? res.transaction.contract_address : undefined,
-      contract_class:
-        'contract_class' in res.transaction ? (res.transaction.contract_class as any) : undefined,
-      entry_point_selector:
-        'entry_point_selector' in res.transaction
-          ? res.transaction.entry_point_selector
-          : undefined,
-      max_fee: 'max_fee' in res.transaction ? (res.transaction.max_fee as string) : undefined,
-      nonce: res.transaction.nonce as string,
-      sender_address:
-        'sender_address' in res.transaction
-          ? (res.transaction.sender_address as string)
-          : undefined,
-      signature: 'signature' in res.transaction ? res.transaction.signature : undefined,
-      transaction_hash:
-        'transaction_hash' in res.transaction ? res.transaction.transaction_hash : undefined,
-      version: 'version' in res.transaction ? (res.transaction.version as string) : undefined,
-    };
-  }
-
-  public parseGetTransactionReceiptResponse(
-    res: Sequencer.TransactionReceiptResponse
-  ): GetTransactionReceiptResponse {
-    return {
-      transaction_hash: res.transaction_hash,
-      status: res.status,
-      messages_sent: res.l2_to_l1_messages as any, // TODO: parse
-      events: res.events as any,
-      ...('block_hash' in res && { block_hash: res.block_hash }),
-      ...('block_number' in res && { block_number: res.block_number }),
-      ...('actual_fee' in res && { actual_fee: res.actual_fee }),
-      ...('transaction_index' in res && { transaction_index: res.transaction_index }),
-      ...('execution_resources' in res && { execution_resources: res.execution_resources }),
-      ...('l1_to_l2_consumed_message' in res && {
-        // eslint-disable-next-line @typescript-eslint/dot-notation
-        l1_to_l2_consumed_message: res['l1_to_l2_consumed_message'],
-      }),
-      ...('transaction_failure_reason' in res && {
-        transaction_failure_reason: res.transaction_failure_reason,
-      }),
-    };
-  }
-
-  public parseFeeEstimateResponse(res: Sequencer.EstimateFeeResponse): EstimateFeeResponse {
-    if ('overall_fee' in res) {
-      let gasInfo = {};
-
-      try {
-        gasInfo = {
-          gas_consumed: toBN(res.gas_usage),
-          gas_price: toBN(res.gas_price),
-        };
-      } catch {
-        // do nothing
-      }
-
-      return {
-        overall_fee: toBN(res.overall_fee),
-        ...gasInfo,
-      };
-    }
-    return {
-      overall_fee: toBN(res.amount),
-    };
-  }
-
-  public parseCallContractResponse(res: Sequencer.CallContractResponse): CallContractResponse {
-    return {
-      result: res.result,
-    };
-  }
-
-  public parseInvokeFunctionResponse(
-    res: Sequencer.AddTransactionResponse
-  ): InvokeFunctionResponse {
-    return {
-      transaction_hash: res.transaction_hash,
-    };
-  }
-
-  public parseDeployContractResponse(
-    res: Sequencer.AddTransactionResponse
-  ): DeployContractResponse {
-    return {
-      transaction_hash: res.transaction_hash,
-      contract_address: res.address as string,
-    };
-  }
-
-  public parseDeclareContractResponse(
-    res: Sequencer.AddTransactionResponse
-  ): DeclareContractResponse {
-    return {
-      transaction_hash: res.transaction_hash,
-      class_hash: res.class_hash as string,
-    };
-  }
-}

package/src/utils/shortString.ts

@@ -1,21 +0,0 @@
-import { addHexPrefix, removeHexPrefix } from './encode';
-
-export function isASCII(str: string) {
-  // eslint-disable-next-line no-control-regex
-  return /^[\x00-\x7F]*$/.test(str);
-}
-
-// function to check if string has less or equal 31 characters
-export function isShortString(str: string) {
-  return str.length <= 31;
-}
-
-export function encodeShortString(str: string) {
-  if (!isASCII(str)) throw new Error(`${str} is not an ASCII string`);
-  if (!isShortString(str)) throw new Error(`${str} is too long`);
-  return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
-}
-
-export function decodeShortString(str: string) {
-  return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
-}