starknet 3.0.0 → 3.3.0

package/src/utils/hash.ts

@@ -3,9 +3,14 @@ import { keccak256 } from 'ethereum-cryptography/keccak';
 import assert from 'minimalistic-assert';
 
 import { CONSTANT_POINTS, FIELD_PRIME, MASK_250, ONE, ZERO } from '../constants';
+import { Call } from '../types';
 import { ec } from './ellipticCurve';
 import { addHexPrefix, buf2hex, utf8ToArray } from './encode';
-import { BigNumberish, toBN } from './number';
+import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from './number';
+import { encodeShortString } from './shortString';
+
+export const transactionPrefix = encodeShortString('StarkNet Transaction');
+export const transactionVersion = 0;
 
 function keccakHex(value: string): string {
   return addHexPrefix(buf2hex(keccak256(utf8ToArray(value))));
@@ -22,6 +27,18 @@ 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 isnt allowed in the starknet api
+  return toHex(starknetKeccak(funcName));
+}
+
 const constantPoints = CONSTANT_POINTS.map((coords: string[]) =>
   ec.curve.point(coords[0], coords[1])
 );
@@ -47,17 +64,27 @@ export function computeHashOnElements(data: BigNumberish[]) {
   return [...data, data.length].reduce((x, y) => pedersen([x, y]), 0).toString();
 }
 
-export function hashCalldata(calldata: string[]): string {
-  return computeHashOnElements(calldata);
-}
-
-export function hashMessage(
+export function hashMulticall(
   account: string,
-  to: string,
-  selector: string,
-  calldata: string[],
-  nonce: string
+  transactions: Call[],
+  nonce: string,
+  maxFee: string
 ) {
-  const calldataHash = hashCalldata(calldata);
-  return computeHashOnElements([account, to, selector, calldataHash, nonce]);
+  const hashArray = transactions
+    .map(({ contractAddress, entrypoint, calldata }) => [
+      contractAddress,
+      getSelectorFromName(entrypoint),
+      computeHashOnElements(calldata || []),
+    ])
+    .map(bigNumberishArrayToDecimalStringArray)
+    .map(computeHashOnElements);
+
+  return computeHashOnElements([
+    transactionPrefix,
+    account,
+    computeHashOnElements(hashArray),
+    nonce,
+    maxFee,
+    transactionVersion,
+  ]);
 }

package/src/utils/number.ts

@@ -1,4 +1,4 @@
-import BN from 'bn.js';
+import BN, { isBN } from 'bn.js';
 import assert from 'minimalistic-assert';
 
 import { addHexPrefix, removeHexPrefix } from './encode';
@@ -23,6 +23,13 @@ export function hexToDecimalString(hex: string): string {
   return toBN(`0x${hex.replace(/^0x/, '')}`).toString();
 }
 
+export function toFelt(num: BigNumberish): string {
+  if (isBN(num)) {
+    return num.toString();
+  }
+  return toBN(num).toString();
+}
+
 /*
  Asserts input is equal to or greater then lowerBound and lower then upperBound.
  Assert message specifies inputName.

package/src/utils/stark.ts

@@ -1,11 +1,10 @@
 import { gzip } from 'pako';
 
-import { CompressedProgram, Program, Signature } from '../types';
+import { Calldata, CompressedProgram, Program, RawArgs, Signature } from '../types';
 import { genKeyPair, getStarkKey } from './ellipticCurve';
 import { addHexPrefix, btoaUniversal } from './encode';
-import { starknetKeccak } from './hash';
 import { stringify } from './json';
-import { toBN, toHex } from './number';
+import { toBN } from './number';
 
 /**
  * Function to compress compiled cairo program
@@ -20,18 +19,6 @@ export function compressProgram(jsonProgram: Program | string): CompressedProgra
   return btoaUniversal(compressedProgram);
 }
 
-/**
- * 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 isnt allowed in the starknet api
-  return toHex(starknetKeccak(funcName));
-}
-
 export function randomAddress(): string {
   const randomKeyPair = genKeyPair();
   return getStarkKey(randomKeyPair);
@@ -49,3 +36,15 @@ export function formatSignature(sig?: Signature): string[] {
     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();
+  });
+}

package/src/utils/transaction.ts

@@ -0,0 +1,50 @@
+import { ParsedStruct } from '../contract';
+import { Call } 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,
+  ];
+};

package/src/utils/typedData/index.ts

@@ -1,7 +1,6 @@
-import { computeHashOnElements } from '../hash';
+import { computeHashOnElements, getSelectorFromName } from '../hash';
 import { BigNumberish, toBN, toHex } from '../number';
 import { encodeShortString } from '../shortString';
-import { getSelectorFromName } from '../stark';
 import { TypedData } from './types';
 import { validateTypedData } from './utils';
 
@@ -161,7 +160,7 @@ export const getStructHash = <T extends TypedData>(
  * with Keccak256.
  *
  * @param {TypedData} typedData
- * @param {boolean} hash
+ * @param {BigNumberish} account
  * @return {string}
  */
 export const getMessageHash = (typedData: TypedData, account: BigNumberish): string => {

package/types/api.d.ts

@@ -127,6 +127,11 @@ export declare type GetCodeResponse = {
 export declare type GetTransactionStatusResponse = {
   tx_status: Status;
   block_hash: string;
+  tx_failure_reason?: {
+    tx_id: number;
+    code: string;
+    error_message: string;
+  };
 };
 export declare type GetTransactionResponse = {
   status: Status;
@@ -150,3 +155,13 @@ export declare type TransactionReceipt = {
   l2_to_l1_messages: string[];
   events: string[];
 };
+export declare type RawArgs = {
+  [inputName: string]:
+    | string
+    | string[]
+    | {
+        type: 'struct';
+        [k: string]: BigNumberish;
+      };
+};
+export declare type Calldata = string[];

package/types/lib.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 = BigNumberish[];
+export declare type Signature = string[];
 export declare type RawCalldata = BigNumberish[];
 export declare type DeployContractPayload = {
   contract: CompiledContract | string;
@@ -15,11 +15,11 @@ export declare type Invocation = {
   calldata?: RawCalldata;
   signature?: Signature;
 };
-export declare type ExecuteInvocation = Omit<Invocation, 'signature'>;
+export declare type Call = Omit<Invocation, 'signature'>;
 export declare type InvocationsDetails = {
   nonce?: BigNumberish;
+  maxFee?: BigNumberish;
 };
-export declare type Call = Omit<Invocation, 'signature' | 'nonce'>;
 export declare type Status =
   | 'NOT_RECEIVED'
   | 'RECEIVED'

package/utils/ellipticCurve.js

@@ -136,7 +136,7 @@ function sign(keyPair, msgHash) {
     (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.MAX_ECDSA_VAL)),
     'w'
   );
-  return [r, s];
+  return [r.toString(), s.toString()];
 }
 exports.sign = sign;
 function chunkArray(arr, n) {

package/utils/hash.d.ts

@@ -1,6 +1,9 @@
 import BN from 'bn.js';
 
+import { Call } from '../types';
 import { BigNumberish } from './number';
+export declare const transactionPrefix: string;
+export declare const transactionVersion = 0;
 /**
  * Function to get the starknet keccak hash from a string
  *
@@ -9,13 +12,19 @@ import { BigNumberish } from './number';
  * @returns starknet keccak hash as BigNumber
  */
 export declare function starknetKeccak(value: string): BN;
+/**
+ * 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 declare function getSelectorFromName(funcName: string): string;
 export declare function pedersen(input: [BigNumberish, BigNumberish]): string;
 export declare function computeHashOnElements(data: BigNumberish[]): string;
-export declare function hashCalldata(calldata: string[]): string;
-export declare function hashMessage(
+export declare function hashMulticall(
   account: string,
-  to: string,
-  selector: string,
-  calldata: string[],
-  nonce: string
+  transactions: Call[],
+  nonce: string,
+  maxFee: string
 ): string;

package/utils/hash.js

@@ -39,11 +39,13 @@ var __importDefault =
     return mod && mod.__esModule ? mod : { default: mod };
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.hashMessage =
-  exports.hashCalldata =
+exports.hashMulticall =
   exports.computeHashOnElements =
   exports.pedersen =
+  exports.getSelectorFromName =
   exports.starknetKeccak =
+  exports.transactionVersion =
+  exports.transactionPrefix =
     void 0;
 var keccak_1 = require('ethereum-cryptography/keccak');
 var minimalistic_assert_1 = __importDefault(require('minimalistic-assert'));
@@ -51,6 +53,9 @@ var constants_1 = require('../constants');
 var ellipticCurve_1 = require('./ellipticCurve');
 var encode_1 = require('./encode');
 var number_1 = require('./number');
+var shortString_1 = require('./shortString');
+exports.transactionPrefix = (0, shortString_1.encodeShortString)('StarkNet Transaction');
+exports.transactionVersion = 0;
 function keccakHex(value) {
   return (0, encode_1.addHexPrefix)(
     (0, encode_1.buf2hex)((0, keccak_1.keccak256)((0, encode_1.utf8ToArray)(value)))
@@ -67,6 +72,18 @@ function starknetKeccak(value) {
   return (0, number_1.toBN)(keccakHex(value)).and(constants_1.MASK_250);
 }
 exports.starknetKeccak = starknetKeccak;
+/**
+ * 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
+ */
+function getSelectorFromName(funcName) {
+  // sometimes BigInteger pads the hex string with zeros, which isnt allowed in the starknet api
+  return (0, number_1.toHex)(starknetKeccak(funcName));
+}
+exports.getSelectorFromName = getSelectorFromName;
 var constantPoints = constants_1.CONSTANT_POINTS.map(function (coords) {
   return ellipticCurve_1.ec.curve.point(coords[0], coords[1]);
 });
@@ -99,12 +116,27 @@ function computeHashOnElements(data) {
     .toString();
 }
 exports.computeHashOnElements = computeHashOnElements;
-function hashCalldata(calldata) {
-  return computeHashOnElements(calldata);
-}
-exports.hashCalldata = hashCalldata;
-function hashMessage(account, to, selector, calldata, nonce) {
-  var calldataHash = hashCalldata(calldata);
-  return computeHashOnElements([account, to, selector, calldataHash, nonce]);
+function hashMulticall(account, transactions, nonce, maxFee) {
+  var hashArray = transactions
+    .map(function (_a) {
+      var contractAddress = _a.contractAddress,
+        entrypoint = _a.entrypoint,
+        calldata = _a.calldata;
+      return [
+        contractAddress,
+        getSelectorFromName(entrypoint),
+        computeHashOnElements(calldata || []),
+      ];
+    })
+    .map(number_1.bigNumberishArrayToDecimalStringArray)
+    .map(computeHashOnElements);
+  return computeHashOnElements([
+    exports.transactionPrefix,
+    account,
+    computeHashOnElements(hashArray),
+    nonce,
+    maxFee,
+    exports.transactionVersion,
+  ]);
 }
-exports.hashMessage = hashMessage;
+exports.hashMulticall = hashMulticall;

package/utils/number.d.ts

@@ -4,6 +4,7 @@ export declare function isHex(hex: string): boolean;
 export declare function toBN(number: BigNumberish, base?: number | 'hex'): BN;
 export declare function toHex(number: BN): string;
 export declare function hexToDecimalString(hex: string): string;
+export declare function toFelt(num: BigNumberish): string;
 export declare function assertInRange(
   input: BigNumberish,
   lowerBound: BigNumberish,

package/utils/number.js

@@ -1,4 +1,41 @@
 'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        Object.defineProperty(o, k2, {
+          enumerable: true,
+          get: function () {
+            return m[k];
+          },
+        });
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null)
+      for (var k in mod)
+        if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+  };
 var __importDefault =
   (this && this.__importDefault) ||
   function (mod) {
@@ -7,12 +44,13 @@ var __importDefault =
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.bigNumberishArrayToDecimalStringArray =
   exports.assertInRange =
+  exports.toFelt =
   exports.hexToDecimalString =
   exports.toHex =
   exports.toBN =
   exports.isHex =
     void 0;
-var bn_js_1 = __importDefault(require('bn.js'));
+var bn_js_1 = __importStar(require('bn.js'));
 var minimalistic_assert_1 = __importDefault(require('minimalistic-assert'));
 var encode_1 = require('./encode');
 function isHex(hex) {
@@ -33,6 +71,13 @@ function hexToDecimalString(hex) {
   return toBN('0x' + hex.replace(/^0x/, '')).toString();
 }
 exports.hexToDecimalString = hexToDecimalString;
+function toFelt(num) {
+  if ((0, bn_js_1.isBN)(num)) {
+    return num.toString();
+  }
+  return toBN(num).toString();
+}
+exports.toFelt = toFelt;
 /*
  Asserts input is equal to or greater then lowerBound and lower then upperBound.
  Assert message specifies inputName.

package/utils/stark.d.ts

@@ -1,4 +1,4 @@
-import { CompressedProgram, Program, Signature } from '../types';
+import { Calldata, CompressedProgram, Program, RawArgs, Signature } from '../types';
 /**
  * Function to compress compiled cairo program
  *
@@ -7,14 +7,7 @@ import { CompressedProgram, Program, Signature } from '../types';
  * @returns Compressed cairo program
  */
 export declare function compressProgram(jsonProgram: Program | string): CompressedProgram;
-/**
- * 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 declare function getSelectorFromName(funcName: string): string;
 export declare function randomAddress(): string;
 export declare function makeAddress(input: string): string;
 export declare function formatSignature(sig?: Signature): string[];
+export declare function compileCalldata(args: RawArgs): Calldata;

package/utils/stark.js

@@ -1,15 +1,48 @@
 '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 __spreadArray =
+  (this && this.__spreadArray) ||
+  function (to, from, pack) {
+    if (pack || arguments.length === 2)
+      for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+    return to.concat(ar || Array.prototype.slice.call(from));
+  };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.formatSignature =
+exports.compileCalldata =
+  exports.formatSignature =
   exports.makeAddress =
   exports.randomAddress =
-  exports.getSelectorFromName =
   exports.compressProgram =
     void 0;
 var pako_1 = require('pako');
 var ellipticCurve_1 = require('./ellipticCurve');
 var encode_1 = require('./encode');
-var hash_1 = require('./hash');
 var json_1 = require('./json');
 var number_1 = require('./number');
 /**
@@ -26,18 +59,6 @@ function compressProgram(jsonProgram) {
   return (0, encode_1.btoaUniversal)(compressedProgram);
 }
 exports.compressProgram = compressProgram;
-/**
- * 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
- */
-function getSelectorFromName(funcName) {
-  // sometimes BigInteger pads the hex string with zeros, which isnt allowed in the starknet api
-  return (0, number_1.toHex)((0, hash_1.starknetKeccak)(funcName));
-}
-exports.getSelectorFromName = getSelectorFromName;
 function randomAddress() {
   var randomKeyPair = (0, ellipticCurve_1.genKeyPair)();
   return (0, ellipticCurve_1.getStarkKey)(randomKeyPair);
@@ -62,3 +83,31 @@ function formatSignature(sig) {
   }
 }
 exports.formatSignature = formatSignature;
+function compileCalldata(args) {
+  return Object.values(args).flatMap(function (value) {
+    if (Array.isArray(value))
+      return __spreadArray(
+        [(0, number_1.toBN)(value.length).toString()],
+        __read(
+          value.map(function (x) {
+            return (0, number_1.toBN)(x).toString();
+          })
+        ),
+        false
+      );
+    if (typeof value === 'object' && 'type' in value)
+      return Object.entries(value)
+        .filter(function (_a) {
+          var _b = __read(_a, 1),
+            k = _b[0];
+          return k !== 'type';
+        })
+        .map(function (_a) {
+          var _b = __read(_a, 2),
+            v = _b[1];
+          return (0, number_1.toBN)(v).toString();
+        });
+    return (0, number_1.toBN)(value).toString();
+  });
+}
+exports.compileCalldata = compileCalldata;

package/utils/transaction.d.ts

@@ -0,0 +1,19 @@
+import { ParsedStruct } from '../contract';
+import { Call } from '../types';
+/**
+ * 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 declare const transformCallsToMulticallArrays: (calls: Call[]) => {
+  callArray: ParsedStruct[];
+  calldata: string[];
+};
+/**
+ * Transforms a list of calls in the full flattened calldata expected
+ * by the __execute__ protocol.
+ * @param calls
+ * @returns
+ */
+export declare const fromCallsToExecuteCalldata: (calls: Call[]) => string[];