starknet 3.9.0 → 3.10.2

package/src/provider/default.ts

@@ -1,6 +1,7 @@
 import axios, { AxiosRequestHeaders } from 'axios';
 import urljoin from 'url-join';
 
+import { StarknetChainId } from '../constants';
 import {
   Abi,
   AddTransactionResponse,
@@ -49,17 +50,24 @@ export class Provider implements ProviderInterface {
 
   public gatewayUrl: string;
 
-  constructor(optionsOrProvider: ProviderOptions | Provider = { network: 'goerli-alpha' }) {
-    if (optionsOrProvider instanceof Provider) {
+  public chainId: StarknetChainId;
+
+  constructor(
+    optionsOrProvider: ProviderOptions | ProviderInterface = { network: 'goerli-alpha' }
+  ) {
+    if (optionsOrProvider instanceof ProviderInterface) {
       this.baseUrl = optionsOrProvider.baseUrl;
       this.feederGatewayUrl = optionsOrProvider.feederGatewayUrl;
       this.gatewayUrl = optionsOrProvider.gatewayUrl;
+      this.chainId =
+        optionsOrProvider.chainId ?? Provider.getChainIdFromBaseUrl(optionsOrProvider.baseUrl);
     } else {
       const baseUrl =
         'baseUrl' in optionsOrProvider
           ? optionsOrProvider.baseUrl
           : Provider.getNetworkFromName(optionsOrProvider.network);
       this.baseUrl = baseUrl;
+      this.chainId = Provider.getChainIdFromBaseUrl(baseUrl);
       this.feederGatewayUrl = urljoin(baseUrl, 'feeder_gateway');
       this.gatewayUrl = urljoin(baseUrl, 'gateway');
     }
@@ -75,6 +83,19 @@ export class Provider implements ProviderInterface {
     }
   }
 
+  protected static getChainIdFromBaseUrl(baseUrl: string): StarknetChainId {
+    try {
+      const url = new URL(baseUrl);
+      if (url.host.includes('mainnet.starknet.io')) {
+        return StarknetChainId.MAINNET;
+      }
+    } catch {
+      // eslint-disable-next-line no-console
+      console.error(`Could not parse baseUrl: ${baseUrl}`);
+    }
+    return StarknetChainId.TESTNET;
+  }
+
   private getFetchUrl(endpoint: keyof Endpoints) {
     const gatewayUrlEndpoints = ['add_transaction'];
 

package/src/provider/interface.ts

@@ -1,3 +1,4 @@
+import { StarknetChainId } from '../constants';
 import type {
   AddTransactionResponse,
   Call,
@@ -21,6 +22,8 @@ export abstract class ProviderInterface {
 
   public abstract gatewayUrl: string;
 
+  public abstract chainId: StarknetChainId;
+
   /**
    * Gets the smart contract address on the goerli testnet.
    *

package/src/signer/default.ts

@@ -1,6 +1,7 @@
 import { Abi, Invocation, InvocationsSignerDetails, KeyPair, Signature } from '../types';
 import { getStarkKey, sign } from '../utils/ellipticCurve';
-import { hashMulticall } from '../utils/hash';
+import { calculcateTransactionHash, getSelectorFromName } from '../utils/hash';
+import { fromCallsToExecuteCalldataWithNonce } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { SignerInterface } from './interface';
 
@@ -25,12 +26,15 @@ export class Signer implements SignerInterface {
     }
     // now use abi to display decoded data somewhere, but as this signer is headless, we can't do that
 
-    const msgHash = hashMulticall(
+    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, transactionsDetail.nonce);
+
+    const msgHash = calculcateTransactionHash(
       transactionsDetail.walletAddress,
-      transactions,
-      transactionsDetail.nonce.toString(),
-      transactionsDetail.maxFee.toString(),
-      transactionsDetail.version.toString()
+      transactionsDetail.version,
+      getSelectorFromName('__execute__'),
+      calldata,
+      transactionsDetail.maxFee,
+      transactionsDetail.chainId
     );
 
     return sign(this.keyPair, msgHash);

package/src/signer/ledger.ts

@@ -4,7 +4,8 @@ import TransportWebHID from '@ledgerhq/hw-transport-webhid';
 
 import { Invocation, InvocationsSignerDetails, Signature } from '../types';
 import { addHexPrefix } from '../utils/encode';
-import { hashMulticall } from '../utils/hash';
+import { calculcateTransactionHash, getSelectorFromName } from '../utils/hash';
+import { fromCallsToExecuteCalldataWithNonce } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { SignerInterface } from './interface';
 
@@ -46,11 +47,15 @@ export class LedgerBlindSigner implements SignerInterface {
     transactions: Invocation[],
     transactionsDetail: InvocationsSignerDetails
   ): Promise<Signature> {
-    const msgHash = hashMulticall(
+    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, transactionsDetail.nonce);
+
+    const msgHash = calculcateTransactionHash(
       transactionsDetail.walletAddress,
-      transactions,
-      transactionsDetail.nonce.toString(),
-      transactionsDetail.maxFee.toString()
+      transactionsDetail.version,
+      getSelectorFromName('__execute__'),
+      calldata,
+      transactionsDetail.maxFee,
+      transactionsDetail.chainId
     );
 
     return this.sign(msgHash);

package/src/types/signer.ts

@@ -1,5 +1,7 @@
+import { StarknetChainId } from '../constants';
 import { InvocationsDetails } from './lib';
 
 export interface InvocationsSignerDetails extends Required<InvocationsDetails> {
   walletAddress: string;
+  chainId: StarknetChainId;
 }

package/src/utils/hash.ts

@@ -2,14 +2,19 @@ import BN from 'bn.js';
 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 {
+  CONSTANT_POINTS,
+  FIELD_PRIME,
+  MASK_250,
+  ONE,
+  StarknetChainId,
+  TransactionHashPrefix,
+  ZERO,
+} from '../constants';
 import { ec } from './ellipticCurve';
 import { addHexPrefix, buf2hex, utf8ToArray } from './encode';
-import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from './number';
-import { encodeShortString } from './shortString';
+import { BigNumberish, toBN, toHex } from './number';
 
-export const transactionPrefix = encodeShortString('StarkNet Transaction');
 export const transactionVersion = 0;
 export const feeTransactionVersion = toBN(2).pow(toBN(128)).add(toBN(transactionVersion));
 
@@ -65,28 +70,65 @@ export function computeHashOnElements(data: BigNumberish[]) {
   return [...data, data.length].reduce((x, y) => pedersen([x, y]), 0).toString();
 }
 
-export function hashMulticall(
-  account: string,
-  transactions: Call[],
-  nonce: string,
-  maxFee: string,
-  version: string | number = transactionVersion
-) {
-  const hashArray = transactions
-    .map(({ contractAddress, entrypoint, calldata }) => [
-      contractAddress,
-      getSelectorFromName(entrypoint),
-      computeHashOnElements(calldata || []),
-    ])
-    .map(bigNumberishArrayToDecimalStringArray)
-    .map(computeHashOnElements);
+// 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
 
-  return computeHashOnElements([
-    transactionPrefix,
-    account,
-    computeHashOnElements(hashArray),
-    nonce,
+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 calculcateTransactionHash(
+  contractAddress: BigNumberish,
+  version: BigNumberish,
+  entryPointSelector: BigNumberish,
+  calldata: BigNumberish[],
+  maxFee: BigNumberish,
+  chainId: StarknetChainId
+): string {
+  return calculateTransactionHashCommon(
+    TransactionHashPrefix.INVOKE,
+    version,
+    contractAddress,
+    entryPointSelector,
+    calldata,
+    maxFee,
+    chainId
+  );
 }

package/src/utils/transaction.ts

@@ -47,3 +47,10 @@ export const fromCallsToExecuteCalldata = (calls: Call[]): string[] => {
     ...calldata,
   ];
 };
+
+export const fromCallsToExecuteCalldataWithNonce = (
+  calls: Call[],
+  nonce: BigNumberish
+): string[] => {
+  return [...fromCallsToExecuteCalldata(calls), toBN(nonce).toString()];
+};

package/types/signer.d.ts

@@ -1,4 +1,6 @@
+import { StarknetChainId } from '../constants';
 import { InvocationsDetails } from './lib';
 export interface InvocationsSignerDetails extends Required<InvocationsDetails> {
   walletAddress: string;
+  chainId: StarknetChainId;
 }

package/utils/hash.d.ts

@@ -1,8 +1,7 @@
 import BN from 'bn.js';
 
-import { Call } from '../types';
+import { StarknetChainId, TransactionHashPrefix } from '../constants';
 import { BigNumberish } from './number';
-export declare const transactionPrefix: string;
 export declare const transactionVersion = 0;
 export declare const feeTransactionVersion: BN;
 /**
@@ -23,10 +22,27 @@ export declare function starknetKeccak(value: string): BN;
 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 hashMulticall(
-  account: string,
-  transactions: Call[],
-  nonce: string,
-  maxFee: string,
-  version?: string | number
+export declare function calculateTransactionHashCommon(
+  txHashPrefix: TransactionHashPrefix,
+  version: BigNumberish,
+  contractAddress: BigNumberish,
+  entryPointSelector: BigNumberish,
+  calldata: BigNumberish[],
+  maxFee: BigNumberish,
+  chainId: StarknetChainId,
+  additionalData?: BigNumberish[]
+): string;
+export declare function calculateDeployTransactionHash(
+  contractAddress: BigNumberish,
+  constructorCalldata: BigNumberish[],
+  version: BigNumberish,
+  chainId: StarknetChainId
+): string;
+export declare function calculcateTransactionHash(
+  contractAddress: BigNumberish,
+  version: BigNumberish,
+  entryPointSelector: BigNumberish,
+  calldata: BigNumberish[],
+  maxFee: BigNumberish,
+  chainId: StarknetChainId
 ): string;

package/utils/hash.js

@@ -39,14 +39,15 @@ var __importDefault =
     return mod && mod.__esModule ? mod : { default: mod };
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.hashMulticall =
+exports.calculcateTransactionHash =
+  exports.calculateDeployTransactionHash =
+  exports.calculateTransactionHashCommon =
   exports.computeHashOnElements =
   exports.pedersen =
   exports.getSelectorFromName =
   exports.starknetKeccak =
   exports.feeTransactionVersion =
   exports.transactionVersion =
-  exports.transactionPrefix =
     void 0;
 var keccak_1 = require('ethereum-cryptography/keccak');
 var minimalistic_assert_1 = __importDefault(require('minimalistic-assert'));
@@ -54,8 +55,6 @@ 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;
 exports.feeTransactionVersion = (0, number_1.toBN)(2)
   .pow((0, number_1.toBN)(128))
@@ -120,30 +119,58 @@ function computeHashOnElements(data) {
     .toString();
 }
 exports.computeHashOnElements = computeHashOnElements;
-function hashMulticall(account, transactions, nonce, maxFee, version) {
-  if (version === void 0) {
-    version = exports.transactionVersion;
+// 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
+function calculateTransactionHashCommon(
+  txHashPrefix,
+  version,
+  contractAddress,
+  entryPointSelector,
+  calldata,
+  maxFee,
+  chainId,
+  additionalData
+) {
+  if (additionalData === void 0) {
+    additionalData = [];
   }
-  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,
+  var calldataHash = computeHashOnElements(calldata);
+  var dataToHash = __spreadArray(
+    [txHashPrefix, version, contractAddress, entryPointSelector, calldataHash, maxFee, chainId],
+    __read(additionalData),
+    false
+  );
+  return computeHashOnElements(dataToHash);
+}
+exports.calculateTransactionHashCommon = calculateTransactionHashCommon;
+function calculateDeployTransactionHash(contractAddress, constructorCalldata, version, chainId) {
+  return calculateTransactionHashCommon(
+    constants_1.TransactionHashPrefix.DEPLOY,
+    version,
+    contractAddress,
+    getSelectorFromName('constructor'),
+    constructorCalldata,
+    constants_1.ZERO,
+    chainId
+  );
+}
+exports.calculateDeployTransactionHash = calculateDeployTransactionHash;
+function calculcateTransactionHash(
+  contractAddress,
+  version,
+  entryPointSelector,
+  calldata,
+  maxFee,
+  chainId
+) {
+  return calculateTransactionHashCommon(
+    constants_1.TransactionHashPrefix.INVOKE,
     version,
-  ]);
+    contractAddress,
+    entryPointSelector,
+    calldata,
+    maxFee,
+    chainId
+  );
 }
-exports.hashMulticall = hashMulticall;
+exports.calculcateTransactionHash = calculcateTransactionHash;

package/utils/transaction.d.ts

@@ -1,4 +1,5 @@
 import { Call, ParsedStruct } from '../types';
+import { BigNumberish } 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.
@@ -16,3 +17,7 @@ export declare const transformCallsToMulticallArrays: (calls: Call[]) => {
  * @returns
  */
 export declare const fromCallsToExecuteCalldata: (calls: Call[]) => string[];
+export declare const fromCallsToExecuteCalldataWithNonce: (
+  calls: Call[],
+  nonce: BigNumberish
+) => string[];

package/utils/transaction.js

@@ -34,7 +34,10 @@ var __spreadArray =
     return to.concat(ar || Array.prototype.slice.call(from));
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.fromCallsToExecuteCalldata = exports.transformCallsToMulticallArrays = void 0;
+exports.fromCallsToExecuteCalldataWithNonce =
+  exports.fromCallsToExecuteCalldata =
+  exports.transformCallsToMulticallArrays =
+    void 0;
 var hash_1 = require('./hash');
 var number_1 = require('./number');
 /**
@@ -97,3 +100,11 @@ var fromCallsToExecuteCalldata = function (calls) {
   );
 };
 exports.fromCallsToExecuteCalldata = fromCallsToExecuteCalldata;
+var fromCallsToExecuteCalldataWithNonce = function (calls, nonce) {
+  return __spreadArray(
+    __spreadArray([], __read((0, exports.fromCallsToExecuteCalldata)(calls)), false),
+    [(0, number_1.toBN)(nonce).toString()],
+    false
+  );
+};
+exports.fromCallsToExecuteCalldataWithNonce = fromCallsToExecuteCalldataWithNonce;

package/utils/typedData/index.d.ts

@@ -56,8 +56,8 @@ export declare const encodeData: <
     primaryType: string;
     domain: {
       version?: string | undefined;
-      name?: string | undefined;
       chainId?: string | number | undefined;
+      name?: string | undefined;
     };
     message: Record<string, unknown>;
   }
@@ -92,8 +92,8 @@ export declare const getStructHash: <
     primaryType: string;
     domain: {
       version?: string | undefined;
-      name?: string | undefined;
       chainId?: string | number | undefined;
+      name?: string | undefined;
     };
     message: Record<string, unknown>;
   }

package/utils/typedData/types.d.ts

@@ -30,8 +30,8 @@ export declare type StarkNetType = Infer<typeof STARKNET_TYPE>;
 export declare const STARKNET_DOMAIN_TYPE: import('superstruct').Struct<
   {
     version?: string | undefined;
-    name?: string | undefined;
     chainId?: string | number | undefined;
+    name?: string | undefined;
   },
   {
     name: import('superstruct').Struct<string | undefined, null>;
@@ -60,8 +60,8 @@ export declare const STARKNET_TYPED_DATA_TYPE: import('superstruct').Struct<
     primaryType: string;
     domain: {
       version?: string | undefined;
-      name?: string | undefined;
       chainId?: string | number | undefined;
+      name?: string | undefined;
     };
     message: Record<string, unknown>;
   },
@@ -85,8 +85,8 @@ export declare const STARKNET_TYPED_DATA_TYPE: import('superstruct').Struct<
     domain: import('superstruct').Struct<
       {
         version?: string | undefined;
-        name?: string | undefined;
         chainId?: string | number | undefined;
+        name?: string | undefined;
       },
       {
         name: import('superstruct').Struct<string | undefined, null>;

package/utils/typedData/utils.d.ts

@@ -20,8 +20,8 @@ export declare const validateTypedData: (data: unknown) => data is {
   primaryType: string;
   domain: {
     version?: string | undefined;
-    name?: string | undefined;
     chainId?: string | number | undefined;
+    name?: string | undefined;
   };
   message: Record<string, unknown>;
 };

package/www/code-examples/account.js

@@ -1,6 +1,5 @@
-
 // Install the latest version of starknet with npm install starknet@next and import starknet
-import * as starknet from "starknet";
+import * as starknet from 'starknet';
 
 // Generate public and private key pair.
 
@@ -8,7 +7,11 @@ const keyPair = starknet.ec.genKeyPair();
 const starkKey = starknet.ec.getStarkKey(keyPair);
 const starkKeyInt = starknet.number.toBN(starknet.encode.removeHexPrefix(starkKey), 16);
 
-const { address: walletAddressLocal } = await provider.deployContract({contract: COMPILED_WALLET_CONTRACT_JSON, constructorCallData: [starkKeyInt], addressSalt: 0});
+const { address: walletAddressLocal } = await provider.deployContract({
+  contract: COMPILED_WALLET_CONTRACT_JSON,
+  constructorCallData: [starkKeyInt],
+  addressSalt: 0,
+});
 
 walletAddress = walletAddressLocal;
 
@@ -28,7 +31,7 @@ const balanceBeforeTransfer = await erc20.call('balance_of', {
   user: walletAddress,
 }).res;
 
-console.log(number.toBN(res).toString())
+console.log(number.toBN(res).toString());
 
 const { nonce } = await wallet.call('get_nonce');
 const msgHash = encode.addHexPrefix(
@@ -59,4 +62,4 @@ const balanceAfterTransfer = await erc20.call('balance_of', {
   user: walletAddress,
 }).res;
 
-console.log('Balance after transfer', balanceAfterTransfer)
+console.log('Balance after transfer', balanceAfterTransfer);

package/www/code-examples/amm.js

@@ -1,37 +1,33 @@
 import { defaultProvider, stark } from 'starknet';
 const { getSelectorFromName } = stark;
 
-
 /**
  * !! IMPORTANT NOTE !! When fees are introduced all function invocations will go through the account account contract and this example will be deprecated.
-**/
+ **/
 
-const CONTRACT_ADDRESS =
-  "0x03e19baa6cb2078631bcdb34844f3f7879449a544c9ce722681a54af08cff4b9";
+const CONTRACT_ADDRESS = '0x03e19baa6cb2078631bcdb34844f3f7879449a544c9ce722681a54af08cff4b9';
 
 /**
  * invokeFunction() example
-**/
+ **/
 
 /** Reset the liquidity pool **/
-const addLiquidityResponse = await defaultProvider.LEGACYinvokeFunction(
-  {
-    contractAddress: CONTRACT_ADDRESS,
-    entrypoint: "init_pool",
-    calldata: ["1000000", "1000000"],
-  }
-);
+const addLiquidityResponse = await defaultProvider.LEGACYinvokeFunction({
+  contractAddress: CONTRACT_ADDRESS,
+  entrypoint: 'init_pool',
+  calldata: ['1000000', '1000000'],
+});
 console.log(addLiquidityResponse);
 
 /**
  * callContract() example
-**/
+ **/
 
 /** Get the balance of the liquidity pool of token A **/
 const poolBalanceTokenA = await defaultProvider.callContract({
   contractAddress: CONTRACT_ADDRESS,
-  entrypoint: "get_pool_token_balance",
-  calldata: ["1"], // Account 1 (no account implemented)
+  entrypoint: 'get_pool_token_balance',
+  calldata: ['1'], // Account 1 (no account implemented)
 });
 const balanceA = poolBalanceTokenA.result[0];
 console.log('token a liquidity pool balance: ', parseInt(balanceA, 16));
@@ -39,11 +35,10 @@ console.log('token a liquidity pool balance: ', parseInt(balanceA, 16));
 /** Get the balance of the liquidity pool of token B **/
 const poolBalanceTokenB = await defaultProvider.callContract({
   contractAddress: CONTRACT_ADDRESS,
-  entrypoint: "get_pool_token_balance",
-  calldata: ["2"],
+  entrypoint: 'get_pool_token_balance',
+  calldata: ['2'],
 });
 const balanceB = poolBalanceTokenB.result[0];
 console.log('token b liquidity pool balance: ', parseInt(balanceB, 16));
 
-
 /** Make a swap */

package/www/code-examples/erc20.js

@@ -1,10 +1,13 @@
-import * as starknet from "starknet";
+import * as starknet from 'starknet';
 
 const keyPair = starknet.ec.genKeyPair();
 const starkKey = starknet.ec.getStarkKey(keyPair);
 const starkKeyInt = starknet.number.toBN(starknet.encode.removeHexPrefix(starkKey), 16);
 
-const deployWalletTx = await provider.deployContract({contract: COMPILED_WALLET_CONTRACT_JSON, constructorCallData: [starkKeyInt], addressSalt: 0});
+const deployWalletTx = await provider.deployContract({
+  contract: COMPILED_WALLET_CONTRACT_JSON,
+  constructorCallData: [starkKeyInt],
+  addressSalt: 0,
+});
 
 await defaultProvider.waitForTx(deployWalletTx.transaction_hash);
-