starknet 3.10.1 → 3.10.2

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [3.10.2](https://github.com/seanjameshan/starknet.js/compare/v3.10.1...v3.10.2) (2022-04-27)
+
+### Bug Fixes
+
+- **tests:** fix getBlock blocks ([c0422b7](https://github.com/seanjameshan/starknet.js/commit/c0422b7d963639d34082731f6efbe3f0dd2c3c4d))
+
 ## [3.10.1](https://github.com/seanjameshan/starknet.js/compare/v3.10.0...v3.10.1) (2022-04-20)
 
 ### Bug Fixes

package/__tests__/provider.test.ts

@@ -10,15 +10,15 @@ describe('defaultProvider', () => {
       expect(typeof GpsStatementVerifier).toBe('string');
       expect(typeof Starknet).toBe('string');
     });
-    test('getBlock(blockHash=0x3bca19c3d5983e21e9537669b15f951f0664f0747a083dc714e0b9648b8575d, blockNumber=undefined)', () => {
+    test('getBlock(blockHash=0x26e33ad2807590b93e98a04e703d7d64d4ead13591b50984ae558bdbe8fbcd2, blockNumber=undefined)', () => {
       return expect(
         defaultProvider.getBlock(
-          '0x3bca19c3d5983e21e9537669b15f951f0664f0747a083dc714e0b9648b8575d'
+          '0x26e33ad2807590b93e98a04e703d7d64d4ead13591b50984ae558bdbe8fbcd2'
         )
       ).resolves.not.toThrow();
     });
-    test('getBlock(blockHash=undefined, blockNumber=36657)', () => {
-      return expect(defaultProvider.getBlock(36657)).resolves.not.toThrow();
+    test('getBlock(blockHash=undefined, blockNumber=168890)', () => {
+      return expect(defaultProvider.getBlock(168890)).resolves.not.toThrow();
     });
     test('getBlock(blockHash=undefined, blockNumber=null)', () => {
       return expect(defaultProvider.getBlock()).resolves.not.toThrow();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "3.10.1",
+  "version": "3.10.2",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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: 6
+---
+
+# 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(providerOrAccount)` _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_.
+
+`contractFacotry.connect(providerOrAccount)` _for changing the provider or account_
+
+`contractFacotry.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>
-

package/www/docs/API/provider.md

@@ -6,5 +6,208 @@ sidebar_position: 1
 
 The **Provider** API allows you to interface with the StarkNet network, without signing transactions or messages.
 
-Typically, these are *read* calls on the blockchain.
+Typically, these are _read_ calls on the blockchain.
 
+## Creating an instance
+
+`new starknet.Provider(optionsOrProvider)`
+
+The options for the provider depends from the network. The structure of the options object is:
+
+- options.**baseUrl** - Base URL of the network
+- options.**feederGatewayUrl** - Feeder Gateway Endpoint of the network
+- options.**gatewayUrl** - Gateway Endpoint
+
+Example:
+
+```
+const provider = new starknet.Provider({
+    baseUrl: 'https://alpha4.starknet.io',
+    feederGatewayUrl: 'feeder_gateway',
+    gatewayUrl: 'gateway',
+})
+```
+
+**This is also default options for the constructor for the **testnet\*\*\*
+
+## Methods
+
+Gets the smart contract address on the network
+
+provider.**getContractAddresses**() => _Promise < GetContractAddressesResponse >_
+
+```
+{
+  Starknet: string;
+  GpsStatementVerifier: string;
+}
+```
+
+<hr/>
+
+provider.**callContract**(call [ , options ]) => _Promise < CallContractResponse >_
+
+Calls a function on the StarkNet contract.
+
+The call object structure:
+
+- call.**contractAddress** - Address of the contract
+- call.**entrypoint** - Entrypoint of the call (method name)
+- call.**calldata** - Payload for the invoking the method
+
+The options object structure:
+
+- options.**blockIdentifier**
+
+###### CallContractResponse
+
+```
+{
+    result: string[];
+}
+```
+
+<hr/>
+
+provider.**getBlock**(blockIdentifire) => _Promise < GetBlockResponse >_
+
+Gets the block information.
+
+###### _GetBlockResponse_
+
+```
+{
+  block_hash: string;
+  parent_block_hash: string;
+  block_number: number;
+  state_root: string;
+  status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+  transation: Transaction[];
+  timestamp: number;
+  transaction_receipts: [];
+}
+```
+
+<hr/>
+
+provider.**getCode**(contractAddress, blockIdentifire) => _Promise < GetCodeResponse >_
+
+Gets the code of the deployed contract.
+
+###### _GetCodeResponse_
+
+```
+{
+  bytecode: string[];
+  abi: Abi;
+}
+```
+
+<hr/>
+
+provider.**getStorageAt**(contractAddress, key, blockIdentifire) => _Promise < any >_
+
+Gets the contract's storage variable at a specific key
+
+<hr/>
+
+provider.**getTransactionStatus**(txHash) => _Promise < GetTransactionStatusResponse >_
+
+Gets the status of a transaction.
+
+###### _GetTransactionStatusResponse_
+
+```
+{
+  tx_status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+  block_hash: string;
+  tx_failure_reason?: {
+    tx_id: number;
+    code: string;
+    error_message: string;
+  }
+}
+```
+
+<hr/>
+
+provider.**getTransactionReceipt**(txHash, txId) => _Promise < TransactionReceipt >_
+
+Gets the status of a transaction.
+
+###### _TransactionReceipt_
+
+```
+{
+  status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+  transaction_hash: string;
+  transaction_index: number;
+  block_hash: string;
+  block_number: 'pending' | null | number;
+  l2_to_l1_messages: string[];
+  events: string[];
+}
+```
+
+<hr/>
+
+provider.**getTransaction**(txHash) => _Promise < GetTransactionResponse >_
+
+Gets the transaction information from a tx hash.
+
+###### _GetTransactionResponse_
+
+```
+{
+    status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+    transaction: Transaction;
+    block_hash: string;
+    block_number: 'pending' | null | number;
+    transaction_index: number;
+    transaction_hash: string;
+}
+```
+
+<hr/>
+
+provider.**getTransactionTrace**(txHash) => _Promise < GetTransactionTraceResponse >_
+
+Gets the transaction trace from a tx hash.
+
+###### _GetTransactionTraceResponse_
+
+```
+{
+  function_invocation: {
+    caller_address: string;
+    contract_address: string;
+    code_address: string;
+    selector: string;
+    calldata: {
+        [inputName: string]: string | string[] | { type: 'struct'; [k: string]: BigNumberish };
+    };
+    result: Array<any>;
+    execution_resources: any;
+    internal_call: Array<any>;
+    events: Array<any>;
+    messages: Array<any>;
+  };
+  signature: Signature;
+}
+```
+
+<hr/>
+
+provider.**deployContract**(payload [ , abi ]) => _Promise < AddTransactionResponse >_
+
+Gets the transaction trace from a tx hash.
+
+###### _AddTransactionResponse_
+
+```
+{
+  code: 'TRANSACTION_RECEIVED';
+  transaction_hash: string;
+  address?: string;
+};
+```

package/www/docs/API/signer.md

@@ -6,3 +6,38 @@ sidebar_position: 3
 
 The **Signer** API allows you to sign transactions and messages, and also allows you to get the public key.
 
+## Creating an instance
+
+`new starknet.Signer(keyPair)`
+
+## Signer Methods
+
+signer.**getPubKey**() => _Promise < string >_
+
+Returns public key of the signer
+
+<hr />
+
+signer.**signTransaction**(transactions, transactionsDetail [ , abi ]) => _Promise < Signature >_
+
+Returns signature of the transaction
+
+###### Signature
+
+```
+string[]
+```
+
+<hr />
+
+signer.**signMessage**(typedData, accountAddress) => _Promise < Signature >_
+
+Returns signature of the transaction
+
+###### Signature
+
+```
+string[]
+```
+
+<hr />

package/www/docusaurus.config.js

@@ -41,8 +41,7 @@ const config = {
         blog: {
           showReadingTime: true,
           // Please change this to your repo.
-          editUrl:
-            'https://github.com/0xs34n/starknet.js',
+          editUrl: 'https://github.com/0xs34n/starknet.js',
         },
         theme: {
           customCss: require.resolve('./src/css/custom.css'),
@@ -70,7 +69,7 @@ const config = {
           {
             position: 'left',
             label: 'Guides',
-            to: '/guides/intro'
+            to: '/guides/intro',
           },
           // {to: '/blog', label: 'Blog', position: 'left'},
           {

package/www/guides/account.md

@@ -17,7 +17,7 @@ import fs from "fs";
 import * as starknet from "starknet";
 ```
 
-##  Generate random key pair.
+## Generate random key pair.
 
 You can also get a key pair from a private key using `getKeyPair(pk: BigNumberish)`
 

package/www/guides/erc20.md

@@ -1,6 +1,7 @@
 ---
 sidebar_position: 3
 ---
+
 # Deploy an ERC20 Contract
 
 Dpeploy the contract and wait for deployment transaction to be accepted on StarkNet
@@ -15,13 +16,16 @@ const erc20Response = await defaultProvider.deployContract({
 console.log("Waiting for Tx to be Accepted on Starknet - ERC20 Deployment...");
 await defaultProvider.waitForTransaction(erc20Response.transaction_hash);
 ```
+
 ## Get the erc20 contract address and create the contact object
+
 ```javascript
 const erc20Address = erc20Response.address;
 const erc20 = new Contract(compiledErc20.abi, erc20Address);
 ```
 
 ## Mint tokens to an account address
+
 ```javascript
 const { transaction_hash: mintTxHash } = await erc20.mint(
   accountContract.address,
@@ -32,6 +36,7 @@ await defaultProvider.waitForTransaction(mintTxHash);
 ```
 
 ## Check balance after mint
+
 ```javascript
 console.log(`Calling StarkNet for accountContract balance...`);
 const balanceBeforeTransfer = await erc20.balance_of(accountContract.address);
@@ -43,6 +48,7 @@ console.log(
 ```
 
 ## Transfer tokens
+
 ```javascript
 // Get the nonce of the account and prepare transfer tx
 console.log(`Calling StarkNet for accountContract nonce...`);
@@ -76,6 +82,7 @@ await defaultProvider.waitForTransaction(transferTxHash);
 ```
 
 ## Check balance after transfer
+
 ```javascript
 // Check balance after transfer - should be 990
 console.log(`Calling StarkNet for accountContract balance...`);

package/www/guides/intro.md

@@ -17,4 +17,5 @@ npm install starknet@next
 Please check the StarkNet documentation <ins>[here](https://www.cairo-lang.org/docs/hello_starknet/intro.html)</ins> to compile starknet contracts.
 
 ## Full example with account & erc20
+
 Please see workshop <ins>[here](https://github.com/0xs34n/starknet.js-workshop)</ins>

package/www/sidebars.js

@@ -14,7 +14,7 @@
 /** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
 const sidebars = {
   // By default, Docusaurus generates a sidebar from the docs folder structure
-  tutorialSidebar: [{type: 'autogenerated', dirName: '.'}],
+  tutorialSidebar: [{ type: 'autogenerated', dirName: '.' }],
 
   // But you can create a sidebar manually
   /*