starknet 3.10.1 → 3.11.0

package/src/utils/address.ts

@@ -1,16 +1,16 @@
+/* eslint-disable no-bitwise */
+import { arrayify } from '@ethersproject/bytes';
+
 import { MASK_251, ZERO } from '../constants';
 import { addHexPrefix, removeHexPrefix } from './encode';
-import { assertInRange } from './number';
+import { pedersen } from './hash';
+import { BigNumberish, assertInRange, toBN, toHex } from './number';
 
-export function addAddressPadding(address: string): string {
-  return addHexPrefix(removeHexPrefix(address).padStart(64, '0'));
+export function addAddressPadding(address: BigNumberish): string {
+  return addHexPrefix(removeHexPrefix(toHex(toBN(address))).padStart(64, '0'));
 }
 
-export function validateAndParseAddress(address: string): string {
-  if (typeof address !== 'string') {
-    throw new Error('Invalid Address Type');
-  }
-
+export function validateAndParseAddress(address: BigNumberish): string {
   assertInRange(address, ZERO, MASK_251, 'Starknet Address');
 
   const result = addAddressPadding(address);
@@ -21,3 +21,24 @@ export function validateAndParseAddress(address: string): string {
 
   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(pedersen([0, address]), { hexPad: 'left' }); // as the hash will be 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/encode.ts

@@ -4,7 +4,7 @@ export const IS_BROWSER = typeof window !== 'undefined';
 const STRING_ZERO = '0';
 
 export function arrayBufferToString(array: ArrayBuffer): string {
-  return String.fromCharCode.apply(null, array as unknown as number[]);
+  return new Uint8Array(array).reduce((data, byte) => data + String.fromCharCode(byte), '');
 }
 
 export function btoaUniversal(b: ArrayBuffer): string {

package/types/api.d.ts

@@ -1,3 +1,5 @@
+import BN from 'bn.js';
+
 import { BlockIdentifier } from '../provider/utils';
 import { BigNumberish } from '../utils/number';
 import {
@@ -42,6 +44,13 @@ export declare type Endpoints = {
     REQUEST: never;
     RESPONSE: GetTransactionTraceResponse;
   };
+  get_transaction_receipt: {
+    QUERY: {
+      transactionHash: string;
+    };
+    REQUEST: never;
+    RESPONSE: TransactionReceiptResponse;
+  };
   get_storage_at: {
     QUERY: {
       contractAddress: string;
@@ -201,7 +210,7 @@ export declare type AddTransactionResponse = {
   transaction_hash: string;
   address?: string;
 };
-export declare type TransactionReceipt = {
+export declare type TransactionReceiptResponse = {
   status: Status;
   transaction_hash: string;
   transaction_index: number;
@@ -211,7 +220,7 @@ export declare type TransactionReceipt = {
   events: string[];
 };
 export declare type EstimateFeeResponse = {
-  amount: number;
+  amount: BN;
   unit: string;
 };
 export declare type RawArgs = {

package/utils/address.d.ts

@@ -1,2 +1,5 @@
-export declare function addAddressPadding(address: string): string;
-export declare function validateAndParseAddress(address: string): string;
+import { BigNumberish } from './number';
+export declare function addAddressPadding(address: BigNumberish): string;
+export declare function validateAndParseAddress(address: BigNumberish): string;
+export declare function getChecksumAddress(address: BigNumberish): string;
+export declare function validateChecksumAddress(address: string): boolean;

package/utils/address.js

@@ -1,17 +1,26 @@
 'use strict';
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.validateAndParseAddress = exports.addAddressPadding = void 0;
+exports.validateChecksumAddress =
+  exports.getChecksumAddress =
+  exports.validateAndParseAddress =
+  exports.addAddressPadding =
+    void 0;
+/* eslint-disable no-bitwise */
+var bytes_1 = require('@ethersproject/bytes');
 var constants_1 = require('../constants');
 var encode_1 = require('./encode');
+var hash_1 = require('./hash');
 var number_1 = require('./number');
 function addAddressPadding(address) {
-  return (0, encode_1.addHexPrefix)((0, encode_1.removeHexPrefix)(address).padStart(64, '0'));
+  return (0, encode_1.addHexPrefix)(
+    (0, encode_1.removeHexPrefix)((0, number_1.toHex)((0, number_1.toBN)(address))).padStart(
+      64,
+      '0'
+    )
+  );
 }
 exports.addAddressPadding = addAddressPadding;
 function validateAndParseAddress(address) {
-  if (typeof address !== 'string') {
-    throw new Error('Invalid Address Type');
-  }
   (0, number_1.assertInRange)(address, constants_1.ZERO, constants_1.MASK_251, 'Starknet Address');
   var result = addAddressPadding(address);
   if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
@@ -20,3 +29,24 @@ function validateAndParseAddress(address) {
   return result;
 }
 exports.validateAndParseAddress = validateAndParseAddress;
+// from https://github.com/ethers-io/ethers.js/blob/fc1e006575d59792fa97b4efb9ea2f8cca1944cf/packages/address/src.ts/index.ts#L12
+function getChecksumAddress(address) {
+  var chars = (0, encode_1.removeHexPrefix)(validateAndParseAddress(address))
+    .toLowerCase()
+    .split('');
+  var hashed = (0, bytes_1.arrayify)((0, hash_1.pedersen)([0, address]), { hexPad: 'left' }); // as the hash will be 251 bits (63 chars) we need to pad it to 64 chars without changing the number value ("left")
+  for (var 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 (0, encode_1.addHexPrefix)(chars.join(''));
+}
+exports.getChecksumAddress = getChecksumAddress;
+function validateChecksumAddress(address) {
+  return getChecksumAddress(address) === address;
+}
+exports.validateChecksumAddress = validateChecksumAddress;

package/utils/encode.js

@@ -50,7 +50,9 @@ exports.utf8ToArray =
 exports.IS_BROWSER = typeof window !== 'undefined';
 var STRING_ZERO = '0';
 function arrayBufferToString(array) {
-  return String.fromCharCode.apply(null, array);
+  return new Uint8Array(array).reduce(function (data, byte) {
+    return data + String.fromCharCode(byte);
+  }, '');
 }
 exports.arrayBufferToString = arrayBufferToString;
 function btoaUniversal(b) {

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);
-

package/www/docs/API/account.md

@@ -9,3 +9,97 @@ An Account extends <ins>[`Provider`](/docs/API/provider)</ins> and inherits all
 It also introduces new methods that allow Accounts to create and verify signatures with a custom <ins>[`Signer`](/docs/API/signer)</ins>.
 
 This API is the primary way to interact with an account contract on StarkNet.
+
+## Creating an instance
+
+For creating new instance of Account, account contract must be deployed. Also there needs to be a Provider instance that will be passed in the constructor and key pair for the account.
+
+`new starknet.Account(Provider, address, starkKeyPair)`
+
+## Account Properties
+
+contract.**address** => _string_
+
+The address of the account contract
+
+## Account methods
+
+account.**getNonce()** => _Promise < string >_
+
+Gets new Nonce for the next transaction
+
+<hr />
+
+account.**estimateFee**(calls [ , options ]) => _Promise < EstimateFeeResponse >_
+
+Gets the estimated fee for the call(s)
+
+The _options_ object may include any of:
+
+- options.**blockIdentifier** - Block Identifier for the transaction
+- options.**nonce** - Nonce for the transaction
+
+###### EstimateFeeResponse
+
+```
+{
+  amount: number;
+  unit: string;
+}
+```
+
+<hr />
+
+account.**execute**(calls [ , abi , transactionsDetail ]) => _Promise < AddTransactionResponse >_
+
+Executes one or multiple calls using the account contract
+
+The _transactionsDetail_ object may include any of:
+
+- transactionsDetail.**maxFee** - Max Fee that that will be used to execute the call(s)
+- transactionsDetail.**nonce** - Nonce for the transaction
+- transactionsDetail.**version** - Version for the transaction (default is 0)
+
+###### AddTransactionResponse
+
+```
+{
+  code: 'TRANSACTION_RECEIVED';
+  transaction_hash: string;
+  address?: string;
+};
+```
+
+<hr />
+
+account.**signMessage**(typedData) => _Promise < Signature >_
+
+Creates a signature from the passed data
+
+###### Signature
+
+```
+string[];
+```
+
+<hr />
+
+account.**hashMessage**(typedData) => _Promise < string >_
+
+Creates a hash from the passed data
+
+<hr />
+
+account.**verifyMessageHash**(hash, signature) => _Promise < boolean >_
+
+Verify a signature of a given hash
+
+**WARNING** This method is not recommended, use verifyMessage instead
+
+<hr />
+
+account.**verifyMessage**(typedData, signature) => _Promise < boolean >_
+
+Verify a signature of a JSON object
+
+<hr />

package/www/docs/API/changelog.md

@@ -0,0 +1,15 @@
+---
+sidebar_position: 7
+---
+
+# CHANGELOG
+
+### Release 3.10.2 (21.04.2022)
+
+- New hash formula for the new account contract version.
+
+  **NOTE**: Update your accounts, old ones will not be supported anymore. For updating with Argent X extension you can check this [link](https://github.com/argentlabs/argent-x/pull/522)
+
+- BUGFIX: [#165](https://github.com/0xs34n/starknet.js/issues/165)
+- BUGFIX: [#151](https://github.com/0xs34n/starknet.js/issues/151)
+- BUGFIX: [#158](https://github.com/0xs34n/starknet.js/issues/158)

package/www/docs/API/contract.md

@@ -8,7 +8,78 @@ Contracts can do data transformations in JavaScript based on an ABI. They can al
 
 Contracts allow you to transform Cairo values, like `Uint256` to `BigNumber`. It could also allow users to pass their own transformers, similar to `JSON.parse`.
 
-## Contract Factory
+## Creating an instance
 
-Contract Factory allow you to deploy contracts onto StarkNet
+`new starknet.Contract(abi, address, providerOrAccount)`
 
+`contract.attach(providerOrAccount)` _for changing the provider or account_
+
+`contract.connect(address)` _for changing the address of the connected contract_
+
+## Contract properties
+
+contract.**address** => _string_
+
+The address the contract was constructed/connected with
+
+contract.**providerOrAcount** => _Provider | Account_
+
+Provider or Account that are used to interact with the network
+
+contract.**deployTransactionHash** => _string | null_
+
+If the Contract object is the result of a ContractFactory deployment, this is the transaction which was used to deploy the contract.
+
+contract.**abi** => _Abi_
+
+The ABI the contract was constructed with
+
+## Contract methods
+
+contract.**deployed**() => _Promise < Contract >_
+
+If the Contract object is the result of a ContractFactory deployment, this method will wait for the transaction to be resolved.
+
+## Meta-Class
+
+A Meta-Class is a Class which has any of its properties determined at run-time. The Contract object uses a Contract's ABI to determine what methods are available, so the following sections describe the generic ways to interact with the properties added at run-time during the Contract constructor.
+
+### Read-Only Methods(constant)
+
+A constant method (denoted view in Cairo) is read-only and evaluates a small amount of EVM code against the current blockchain state. It is therefore free and does not require any fee, but cannot make changes to the blockchain state...
+
+contract.**METHOD_NAME**(...args [ , overrides ]) => _Promise < Result >_
+
+The type of the result depends on the ABI. Result object will be returned with each parameter available positionally and if the parameter is named, it will also be available by its name.
+
+The _overrides_ object for a read-only method may include any of:
+
+- overrides.**blockIdentifier**
+
+### Write Methods (non-constant)
+
+A non-constant method requires a transaction to be signed and requires payment in the form of a fee to be paid.
+
+contract.**METHOD_NAME**(...args [ , overrides ]) => _Promise < AddTransactionResponse >_
+
+Returns a AddTransactionResponse for the transaction after it is sent to the network. This requires the Contract has a signer.
+
+The _overrides_ object for write methods may include any of:
+
+- overrides.**signature** - Signature that will be used for the transaction
+- overrides.**maxFee** - Max Fee for the transaction
+- overrides.**nonce** - Nonce for the transaction
+
+### Write Methods Analysis
+
+There are several options to analyze properties and results of a write method without actually executing it.
+
+contract.estimateGas.**METHOD_NAME**( ...args ) => _Promise < EstimateFeeResponse >_
+
+Returns the estimate units of gas that would be required to execute the METHOD_NAME with args and overrides.
+
+contract.populateTransaction.**METHOD_NAME**( ...args [ , overrides ] ) ⇒ _Invocation_
+
+Returns an _Invocation_ object which represents the transaction that would need to be signed and submitted to the network to execute METHOD_NAME with args and overrides.
+
+The overrides are identical to the overrides above for write methods.

package/www/docs/API/contractFacotry.md

@@ -0,0 +1,42 @@
+---
+sidebar_position: 5
+---
+
+# Contract Factory
+
+Contract Factory allow you to deploy contracts onto StarkNet. To deploy a Contract, additional information is needed that is not available on a Contract object itself.
+
+## Creating an instance
+
+`new starknet.ContractFactory( compiledContract , providerOrAccount, [ , abi ] )`
+
+Creates a new instance of a ContractFactory for the contract described by the _compiledContract_.
+
+`contractFactory.connect(providerOrAccount)` _for changing the provider or account_
+
+`contractFactory.attach(address)` _for changing the address of the connected contract factory_
+
+## Properties
+
+contractFactory.**abi** => _Abi_;
+
+The ABI the contractFactory was constructed with
+
+contractFactory.**compiledContract** => _CompiledContract_;
+
+The compiled contract the contractFactory was constructed with
+
+contractFactory.**providerOrAccount** => _Provider | Account_;
+
+Provider or Account that are used to interact with the network
+
+## Methods
+
+contractFactory.**attach**( address ) ⇒ _Contract_
+
+Return an instance of a Contract attached to address. This is the same as using the Contract constructor with address and this _compiledContract_ and _providerOrAccount_ passed in when creating the ContractFactory.
+
+contractFactory.deploy( constructorCalldata, addressSalt ) ⇒ Promise< Contract >
+Uses the provider to deploy the Contract with constructorCalldata passed into the constructor and returns a Contract which is attached to the address where this contract will be deployed.
+
+The transaction hash can be found at contract.deployTransactionHash, and no interactions should be made until the transaction is resolved.

package/www/docs/API/index.md

@@ -1,4 +1,3 @@
 # StarkNet.js API
 
 This API is based on the <ins>[Starknet.js V3](https://github.com/0xs34n/starknet.js/discussions/102)</ins> Interface write up by <ins>[Janek](https://twitter.com/0xjanek)</ins> of <ins>[Argent](https://www.argent.xyz/)</ins>
-