dedot 0.4.1 → 0.5.0

package/README.md

@@ -2,12 +2,19 @@
 
 Delightful JavaScript/TypeScript client for [Polkadot](https://polkadot.network/) & [Substrate](https://substrate.io/)
 
-<p align="left">
-  <img src="https://img.shields.io/github/license/dedotdev/dedot?style=flat-square"/>
-  <img src="https://img.shields.io/github/actions/workflow/status/dedotdev/dedot/run-tests.yml?label=unit%20tests&style=flat-square"/>
-  <img src="https://img.shields.io/github/actions/workflow/status/dedotdev/dedot/zombienet-tests.yml?label=e2e%20tests&style=flat-square"/>
-  <img src="https://img.shields.io/github/package-json/v/dedotdev/dedot?filename=packages%2Fapi%2Fpackage.json&style=flat-square"/>
-</p>
+![Version][ico-version]
+![Unit test][ico-unit-test]
+![E2E test][ico-e2e-test]
+![License][ico-license]
+[![Chat on Telegram][ico-telegram]][link-telegram]
+
+[ico-telegram]: https://img.shields.io/badge/Dedot-2CA5E0.svg?style=flat-square&logo=telegram&label=Telegram
+[ico-unit-test]: https://img.shields.io/github/actions/workflow/status/dedotdev/dedot/run-tests.yml?label=unit%20tests&style=flat-square
+[ico-e2e-test]: https://img.shields.io/github/actions/workflow/status/dedotdev/dedot/zombienet-tests.yml?label=e2e%20tests&style=flat-square
+[ico-version]: https://img.shields.io/github/package-json/v/dedotdev/dedot?filename=packages%2Fapi%2Fpackage.json&style=flat-square
+[ico-license]: https://img.shields.io/github/license/dedotdev/dedot?style=flat-square
+
+[link-telegram]: https://t.me/JoinDedot
 
 ---
 
@@ -54,6 +61,7 @@ Delightful JavaScript/TypeScript client for [Polkadot](https://polkadot.network/
 
 ### Getting started
 
+#### Installation & connecting to network
 Follow the below steps to install Dedot to your project.
 
 - Install `dedot` package
@@ -85,56 +93,73 @@ import type { PolkadotApi } from '@dedot/chaintypes';
 
 const run = async () => {
   const provider = new WsProvider('wss://rpc.polkadot.io');
-  const api = await DedotClient.new<PolkadotApi>(provider);
+  const client = await DedotClient.new<PolkadotApi>(provider);
 
   // Call rpc `state_getMetadata` to fetch raw scale-encoded metadata and decode it.
-  const metadata = await api.rpc.state_getMetadata();
+  const metadata = await client.rpc.state_getMetadata();
   console.log('Metadata:', metadata);
 
   // Query on-chain storage
-  const balance = await api.query.system.account(<address>);
+  const balance = await client.query.system.account(<address>);
   console.log('Balance:', balance);
 
 
   // Subscribe to on-chain storage changes
-  const unsub = await api.query.system.number((blockNumber) => {
+  const unsub = await client.query.system.number((blockNumber) => {
     console.log(`Current block number: ${blockNumber}`);
   });
 
   // Get pallet constants
-  const ss58Prefix = api.consts.system.ss58Prefix;
+  const ss58Prefix = client.consts.system.ss58Prefix;
   console.log('Polkadot ss58Prefix:', ss58Prefix);
 
   // Call runtime api
-  const pendingRewards = await api.call.nominationPoolsApi.pendingRewards(<address>)
+  const pendingRewards = await client.call.nominationPoolsApi.pendingRewards(<address>)
   console.log('Pending rewards:', pendingRewards);
 
   // await unsub();
-  // await api.disconnect();
+  // await client.disconnect();
 }
 
 run().catch(console.error);
 ```
 
-- You can also import `dedot` using `require`.
+#### Support CommonJS (`require`)
+
+You can also import `dedot` using `require`.
 
 ```js
 // main.js
 const { DedotClient, WsProvider } = require('dedot');
 // ...
 const provider = new WsProvider('wss://rpc.polkadot.io');
-const api = await DedotClient.new(provider);
+const client = await DedotClient.new(provider);
 ```
 
-- If the JSON-RPC server doesn't support [new](https://paritytech.github.io/json-rpc-interface-spec/introduction.html) JSON-RPC APIs yet, you can connect using the `LegacyClient` which build on top of the legacy JSON-RPC APIs.
+#### Using `LegacyClient` to connect via legacy JSON-RPC APIs
+
+If the JSON-RPC server doesn't support [new JSON-RPC APIs](https://paritytech.github.io/json-rpc-interface-spec/introduction.html) yet, you can connect to the network using the `LegacyClient` which build on top of the [legacy JSON-RPC APIs](https://github.com/w3f/PSPs/blob/master/PSPs/drafts/psp-6.md).
 
 ```typescript
 import { LegacyClient, WsProvider } from 'dedot';
 
 const provider = new WsProvider('wss://rpc.polkadot.io');
-const api = await LegacyClient.new(provider);
+const client = await LegacyClient.new(provider);
 ```
 
+> [!NOTE]
+> The [new JSON-RPC APIs](https://paritytech.github.io/json-rpc-interface-spec/introduction.html) are not well implemented/unstable for RPC Nodes using Polkadot-SDK version < `1.11.0`, so one should connect to the network using `LegacyClient` in such cases. For nodes using Polkadot-SDK version >= `1.11.0`, it's recommended to use `DedotClient` to connect to the network.
+>
+> You can easily check the current node's implementation version by calling RPC `system_version`:
+> ```typescript
+> const version = await client.rpc.system_version();
+> ```
+
+
+> [!NOTE]
+> It's recommended to use `DedotClient` for better performance when you connect to the network using [smoldot](https://www.npmjs.com/package/smoldot) light client via [`SmoldotProvider`](https://github.com/dedotdev/dedot/blob/main/packages/providers/src/smoldot/SmoldotProvider.ts).
+
+
 ### Chain Types & APIs
 
 Each Substrate-based blockchain has their own set of data types & APIs to interact with, so being aware of those types & APIs when working with a blockchain will greatly improve the overall development experience. `dedot` exposes TypeScript's types & APIs for each individual Substrate-based blockchain, we recommend using TypeScript for your project to have the best experience.
@@ -157,19 +182,19 @@ import type { PolkadotApi, KusamaApi, MoonbeamApi, AstarApi } from '@dedot/chain
 
 // ...
 
-const polkadotApi = await DedotClient.new<PolkadotApi>(new WsProvider('wss://rpc.polkadot.io'));
-console.log(await polkadotApi.query.babe.authorities());
+const polkadotClient = await DedotClient.new<PolkadotApi>(new WsProvider('wss://rpc.polkadot.io'));
+console.log(await polkadotClient.query.babe.authorities());
 
-const kusamaApi = await DedotClient.new<KusamaApi>(new WsProvider('wss://kusama-rpc.polkadot.io'));
-console.log(await kusamaApi.query.society.memberCount());
+const kusamaClient = await DedotClient.new<KusamaApi>(new WsProvider('wss://kusama-rpc.polkadot.io'));
+console.log(await kusamaClient.query.society.memberCount());
 
-const moonbeamApi = await DedotClient.new<MoonbeamApi>(new WsProvider('wss://wss.api.moonbeam.network'));
-console.log(await moonbeamApi.query.ethereumChainId.chainId());
+const moonbeamClient = await DedotClient.new<MoonbeamApi>(new WsProvider('wss://wss.api.moonbeam.network'));
+console.log(await moonbeamClient.query.ethereumChainId.chainId());
 
-const astarApi = await DedotClient.new<AstarApi>(new WsProvider('wss://rpc.astar.network'));
-console.log(await astarApi.query.dappsStaking.blockRewardAccumulator());
+const astarClient = await DedotClient.new<AstarApi>(new WsProvider('wss://rpc.astar.network'));
+console.log(await astarClient.query.dappsStaking.blockRewardAccumulator());
 
-const genericApi = await DedotClient.new(new WsProvider('ws://localhost:9944'));
+const client = await DedotClient.new(new WsProvider('ws://localhost:9944'));
 
 // ...
 ```
@@ -183,16 +208,16 @@ npx dedot chaintypes -w wss://rpc.polkadot.io
 
 ### Execute JSON-RPC Methods
 
-RPCs can be executed via `api.rpc` entry point. After creating a `DedotClient` instance with a `ChainApi` interface of the network you want to interact with, all RPC methods of the network will be exposed in the autocompletion/suggestion with format: `api.rpc.method_name(param1, param2, ...)`. E.g: you can find all supported RPC methods for Polkadot network [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/json-rpc.d.ts), similarly for other networks as well.
+RPCs can be executed via `client.rpc` entry point. After creating a `DedotClient` instance with a `ChainApi` interface of the network you want to interact with, all RPC methods of the network will be exposed in the autocompletion/suggestion with format: `client.rpc.method_name(param1, param2, ...)`. E.g: you can find all supported RPC methods for Polkadot network [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/json-rpc.d.ts), similarly for other networks as well.
 
 Examples:
 
 ```typescript
 // Call rpc: `state_getMetadata`
-const metadata = await api.rpc.state_getMetadata(); 
+const metadata = await client.rpc.state_getMetadata(); 
 
 // Call an arbitrary rpc: `module_rpc_name` with arguments ['param1', 'param2']
-const result = await api.rpc.module_rpc_name('param1', 'param2');
+const result = await client.rpc.module_rpc_name('param1', 'param2');
 ```
 
 For advanced users who want to interact directly with server/node via raw JSON-RPC APIs, you can use a light-weight `JsonRpcClient` for this purpose without having to use `DedotClient` or `LegacyClient`.
@@ -210,48 +235,48 @@ const chain = await client.rpc.system_chain();
 
 ### Query On-chain Storage
 
-On-chain storage can be queried via `api.query` entry point. All the available storage entries for a chain are exposed in the `ChainApi` interface for that chain and can be executed with format: `api.query.<pallet>.<storgeEntry>`. E.g: You can find all the available storage queries of Polkadot network [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/query.d.ts), similarly for other networks as well.
+On-chain storage can be queried via `client.query` entry point. All the available storage entries for a chain are exposed in the `ChainApi` interface for that chain and can be executed with format: `client.query.<pallet>.<storgeEntry>`. E.g: You can find all the available storage queries of Polkadot network [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/query.d.ts), similarly for other networks as well.
 
 Examples:
 
 ```typescript
 // Query account balance
-const balance = await api.query.system.account(<address>);
+const balance = await client.query.system.account(<address>);
 
 // Get all events of current block
-const events = await api.query.system.events();
+const events = await client.query.system.events();
 ```
 
 ### Constants
 
-Runtime constants (parameter types) are defined in metadata, and can be inspected via `api.consts` entry point with format: `api.consts.<pallet>.<constantName>`. All available constants are also exposed in the `ChainApi` interface. E.g: Available constants for Polkadot network is defined [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/consts.d.ts), similarly for other networks.
+Runtime constants (parameter types) are defined in metadata, and can be inspected via `client.consts` entry point with format: `client.consts.<pallet>.<constantName>`. All available constants are also exposed in the `ChainApi` interface. E.g: Available constants for Polkadot network is defined [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/consts.d.ts), similarly for other networks.
 
 Examples:
 
 ```typescript
 // Get runtime version
-const runtimeVersion = api.consts.system.version;
+const runtimeVersion = client.consts.system.version;
 
 // Get existential deposit in pallet balances
-const existentialDeposit = api.consts.balances.existentialDeposit;
+const existentialDeposit = client.consts.balances.existentialDeposit;
 ```
 
 ### Runtime APIs
 
-The latest stable Metadata V15 now includes all the runtime apis type information. So for chains that are supported Metadata V15, we can now execute all available runtime apis with syntax `api.call.<runtimeApi>.<methodName>`, those apis are exposed in `ChainApi` interface. E.g: Runtime Apis for Polkadot network is defined [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/runtime.d.ts), similarly for other networks as well.
+The latest stable Metadata V15 now includes all the runtime apis type information. So for chains that are supported Metadata V15, we can now execute all available runtime apis with syntax `client.call.<runtimeApi>.<methodName>`, those apis are exposed in `ChainApi` interface. E.g: Runtime Apis for Polkadot network is defined [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/runtime.d.ts), similarly for other networks as well.
 
 Examples:
 
 ```typescript
 // Get account nonce
-const nonce = await api.call.accountNonceApi.accountNonce(<address>);
+const nonce = await client.call.accountNonceApi.accountNonce(<address>);
 
 // Query transaction payment info
-const tx = api.tx.balances.transferKeepAlive(<address>, 2_000_000_000_000n);
-const queryInfo = await api.call.transactionPaymentApi.queryInfo(tx.toU8a(), tx.length);
+const tx = client.tx.balances.transferKeepAlive(<address>, 2_000_000_000_000n);
+const queryInfo = await client.call.transactionPaymentApi.queryInfo(tx.toU8a(), tx.length);
 
 // Get runtime version
-const runtimeVersion = await api.call.core.version();
+const runtimeVersion = await client.call.core.version();
 ```
 
 For chains that only support Metadata V14, we need to bring in the Runtime Api definitions when initializing the DedotClient instance to encode & decode the calls. You can find all supported Runtime Api definitions in [`dedot/runtime-specs`](https://github.com/dedotdev/dedot/blob/fefe71cf4a04d1433841f5cfc8400a1e2a8db112/packages/runtime-specs/src/all.ts#L21-L39) package.
@@ -261,14 +286,14 @@ Examples:
 ```typescript
 import { RuntimeApis } from 'dedot/runtime-specs';
 
-const api = await DedotClient.new({ provider: new WsProvider('wss://rpc.mynetwork.com'), runtimeApis: RuntimeApis });
+const client = await DedotClient.new({ provider: new WsProvider('wss://rpc.mynetwork.com'), runtimeApis: RuntimeApis });
 
 // Or bring in only the Runtime Api definition that you want to interact with
 import { AccountNonceApi } from 'dedot/runtime-specs';
-const api = await DedotClient.new({ provider: new WsProvider('wss://rpc.mynetwork.com'), runtimeApis: { AccountNonceApi } });
+const client = await DedotClient.new({ provider: new WsProvider('wss://rpc.mynetwork.com'), runtimeApis: { AccountNonceApi } });
 
 // Get account nonce
-const nonce = await api.call.accountNonceApi.accountNonce(<address>);
+const nonce = await client.call.accountNonceApi.accountNonce(<address>);
 ```
 
 You absolutely can define your own Runtime Api definition if you don't find it in the [supported list](https://github.com/dedotdev/dedot/blob/fefe71cf4a04d1433841f5cfc8400a1e2a8db112/packages/runtime-specs/src/all.ts#L21-L39).
@@ -291,7 +316,7 @@ await cryptoWaitReady();
 const keyring = new Keyring({ type: 'sr25519' });
 const alice = keyring.addFromUri('//Alice');
 
-const unsub = await api.tx.balances
+const unsub = await client.tx.balances
     .transferKeepAlive(<destAddress>, 2_000_000_000_000n)
     .signAndSend(alice, async ({ status }) => {
       console.log('Transaction status', status.type);
@@ -309,7 +334,7 @@ const injected = await window.injectedWeb3['polkadot-js'].enable('A cool dapp');
 const account = (await injected.accounts.get())[0];
 const signer = injected.signer;
 
-const unsub = await api.tx.balances
+const unsub = await client.tx.balances
     .transferKeepAlive(<destAddress>, 2_000_000_000_000n)
     .signAndSend(account.address, { signer }, async ({ status }) => {
       console.log('Transaction status', status.type);
@@ -329,7 +354,7 @@ import type { PolkadotRuntimeRuntimeCallLike } from '@dedot/chaintypes/polkadot'
 const account = ...;
 const signer = ...;
 
-const transferTx = api.tx.balances.transferKeepAlive(<destAddress>, 2_000_000_000_000n);
+const transferTx = client.tx.balances.transferKeepAlive(<destAddress>, 2_000_000_000_000n);
 const remarkCall: PolkadotRuntimeRuntimeCallLike = {
   pallet: 'System',
   palletCall: {
@@ -340,7 +365,7 @@ const remarkCall: PolkadotRuntimeRuntimeCallLike = {
   },
 };
 
-const unsub = api.tx.utility.batch([transferTx.call, remarkCall])
+const unsub = client.tx.utility.batch([transferTx.call, remarkCall])
     .signAndSend(account.address, { signer }, async ({ status }) => {
       console.log('Transaction status', status.type);
       if (status.type === 'BestChainBlockIncluded') { // or status.type === 'Finalized'
@@ -360,7 +385,7 @@ import { AccountId32 } from 'dedot/codecs';
 const TWO_TOKENS = 2_000_000_000_000n;
 const destAddress = <bobAddress>;
 
-const api = await DedotClient.new<WestendAssetHubApi>('...westend-assethub-rpc...');
+const client = await DedotClient.new<WestendAssetHubApi>('...westend-assethub-rpc...');
 
 const dest: XcmVersionedLocation = {
   type: 'V3',
@@ -402,7 +427,7 @@ const assets: XcmVersionedAssets = {
 
 const weight: XcmV3WeightLimit = { type: 'Unlimited' };
 
-api.tx.polkadotXcm
+client.tx.polkadotXcm
   .limitedTeleportAssets(dest, beneficiary, assets, 0, weight)
   .signAndSend(alice, { signer, tip: 1_000_000n }, (result) => {
     console.dir(result, { depth: null });
@@ -413,19 +438,19 @@ api.tx.polkadotXcm
 
 ### Events
 
-Events for each pallet emit during runtime operations and are defined in the medata. Available events are also exposed in `ChainApi` interface so we can get information of an event through syntax `api.events.<pallet>.<eventName>`. E.g: Events for Polkadot network can be found [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/events.d.ts), similarly for other network as well.
+Events for each pallet emit during runtime operations and are defined in the medata. Available events are also exposed in `ChainApi` interface so we can get information of an event through syntax `client.events.<pallet>.<eventName>`. E.g: Events for Polkadot network can be found [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/events.d.ts), similarly for other network as well.
 
-This `api.events` is helpful when we want quickly check if an event matches with an event that we're expecting in a list of events, the API also comes with type narrowing for the matched event, so event name & related data of the event are fully typed.
+This `client.events` is helpful when we want quickly check if an event matches with an event that we're expecting in a list of events, the API also comes with type narrowing for the matched event, so event name & related data of the event are fully typed.
 
 Example to list new accounts created in each block:
 
 ```typescript
 // ...
-const ss58Prefix = api.consts.system.ss58Prefix;
-await api.query.system.events(async (eventRecords) => {
-  const newAccountEvents = api.events.system.NewAccount.filter(eventRecords);
+const ss58Prefix = client.consts.system.ss58Prefix;
+await client.query.system.events(async (eventRecords) => {
+  const newAccountEvents = client.events.system.NewAccount.filter(eventRecords);
 
-  console.log(newAccountEvents.length, 'account(s) was created in block', await api.query.system.number());
+  console.log(newAccountEvents.length, 'account(s) was created in block', await client.query.system.number());
 
   newAccountEvents.forEach((event, index) => {
     console.log(`New Account ${index + 1}:`, event.palletEvent.data.account.address(ss58Prefix));
@@ -436,7 +461,7 @@ await api.query.system.events(async (eventRecords) => {
 
 ### Errors
 
-Pallet errors are thrown out when things go wrong in the runtime, those are defined in the metadata. Available errors for each pallet are also exposed in `ChainApi` interface, so we can get information an error through this syntax: `api.errors.<pallet>.<errorName>`. E.g: Available errors for Polkadot network can be found [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/errors.d.ts).
+Pallet errors are thrown out when things go wrong in the runtime, those are defined in the metadata. Available errors for each pallet are also exposed in `ChainApi` interface, so we can get information an error through this syntax: `client.errors.<pallet>.<errorName>`. E.g: Available errors for Polkadot network can be found [here](https://github.com/dedotdev/chaintypes/blob/main/packages/chaintypes/src/polkadot/errors.d.ts).
 
 Similar to events API, this API is helpful when we want to check if an error maches with an error that we're expecting.
 
@@ -444,11 +469,11 @@ Example if an error is `AlreadyExists` from `Assets` pallet:
 
 ```typescript
 // ...
-await api.query.system.events(async (eventRecords) => {
+await client.query.system.events(async (eventRecords) => {
   for (const tx of eventRecords) {
-    if (api.events.system.ExtrinsicFailed.is(tx.event)) {
+    if (client.events.system.ExtrinsicFailed.is(tx.event)) {
       const { dispatchError } = tx.event.palletEvent.data;
-      if (api.errors.assets.AlreadyExists.is(dispatchError)) {
+      if (client.errors.assets.AlreadyExists.is(dispatchError)) {
         console.log('Assets.AlreadyExists error occurred!');
       } else {
         console.log('Other error occurred', dispatchError);
@@ -474,6 +499,11 @@ dedot typink -m ./path/to/metadata.json -o ./where/to-put/generated-types
 After running the command, Types & APIs of the contract will be generated. 
 E.g: if the contract's name is `flipper`, the Types & APIs will be put in a folder named `flipper`, the entry-point interface for the contract will be `FlipperContractApi` in `flipper/index.d.ts` file. An example of Types & APIs for flipper contract can be found [here](https://github.com/dedotdev/dedot/tree/main/zombienet-tests/src/contracts/flipper).
 
+> [!NOTE]
+> If you're connecting to a local [`substrate-contracts-node`](https://github.com/paritytech/substrate-contracts-node/releases) for development, you might want to connect to the network using `LegacyClient` since the latest version of `substrate-contracts-node` ([`v0.41.0`](https://github.com/paritytech/substrate-contracts-node/releases/tag/v0.41.0)) does not working fine/comply with the latest updates for [new JSON-RPC specs](https://paritytech.github.io/json-rpc-interface-spec/introduction.html) for `DedotClient` to work properly.
+> 
+> Following [this instruction](#using-legacyclient-to-connect-via-legacy-json-rpc-apis) to connect to the network via `LegacyClient`.
+
 #### Deploy contracts
 
 Whether it's to deploy a contract from a wasm code or using an existing wasm code hash. You can do it using the `ContractDeployer`.
@@ -709,7 +739,7 @@ While the api style are similar, but there're also some differences you might ne
 ```typescript
 import { ApiPromise, WsProvider } from '@polkadot/api';
 
-const api = await ApiPromise.create({ provider: new WsProvider('wss://rpc.polkadot.io') });
+const client = await ApiPromise.create({ provider: new WsProvider('wss://rpc.polkadot.io') });
 ```
 
 - `dedot`
@@ -718,10 +748,10 @@ const api = await ApiPromise.create({ provider: new WsProvider('wss://rpc.polkad
 import { DedotClient, WsProvider } from 'dedot';
 import type { PolkadotApi } from '@dedot/chaintypes';
 
-const api = await DedotClient.new<PolkadotApi>(new WsProvider('wss://rpc.polkadot.io')); // or DedotClient.create(...) if you prefer
+const client = await DedotClient.new<PolkadotApi>(new WsProvider('wss://rpc.polkadot.io')); // or DedotClient.create(...) if you prefer
 
 // OR
-const api = await DedotClient.new<PolkadotApi>({ provider: new WsProvider('wss://rpc.polkadot.io') });
+const client = await DedotClient.new<PolkadotApi>({ provider: new WsProvider('wss://rpc.polkadot.io') });
 ```
 
 - Notes:
@@ -751,7 +781,7 @@ Unlike `@polkadot/api` where data are wrapped inside a [codec types](https://pol
 E.g 1:
 
 ```typescript
-const runtimeVersion = api.consts.system.version;
+const runtimeVersion = client.consts.system.version;
 
 // @polkadot/api
 const specName: string = runtimeVersion.toJSON().specName; // OR runtimeVersion.specName.toString()
@@ -763,7 +793,7 @@ const specName: string = runtimeVersion.specName;
 E.g 2:
 
 ```typescript
-const balance = await api.query.system.account(<address>);
+const balance = await client.query.system.account(<address>);
 
 // @polkadot/api
 const freeBalance: bigint = balance.data.free.toBigInt();
@@ -776,10 +806,10 @@ E.g 3:
 
 ```typescript
 // @polkadot/api
-const proposalBondMaximum: bigint | undefined = api.consts.treasury.proposalBondMaximum.unwrapOr(undefined)?.toBigInt();
+const proposalBondMaximum: bigint | undefined = client.consts.treasury.proposalBondMaximum.unwrapOr(undefined)?.toBigInt();
 
 // dedot
-const proposalBondMaximum: bigint | undefined = api.consts.treasury.proposalBondMaximum;
+const proposalBondMaximum: bigint | undefined = client.consts.treasury.proposalBondMaximum;
 ```
 
 ### Packages Structure
@@ -813,3 +843,4 @@ Proudly supported by Web3 Foundation Grants Program.
 
 [Apache-2.0](https://github.com/dedotdev/dedot/blob/main/LICENSE)
 
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dedot",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "A delightful JavaScript/TypeScript client for Polkadot & Substrate",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot",
@@ -21,15 +21,15 @@
     "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo"
   },
   "dependencies": {
-    "@dedot/api": "0.4.1",
-    "@dedot/cli": "0.4.1",
-    "@dedot/codecs": "0.4.1",
-    "@dedot/contracts": "0.4.1",
-    "@dedot/providers": "0.4.1",
-    "@dedot/runtime-specs": "0.4.1",
-    "@dedot/shape": "0.4.1",
-    "@dedot/types": "0.4.1",
-    "@dedot/utils": "0.4.1"
+    "@dedot/api": "0.5.0",
+    "@dedot/cli": "0.5.0",
+    "@dedot/codecs": "0.5.0",
+    "@dedot/contracts": "0.5.0",
+    "@dedot/providers": "0.5.0",
+    "@dedot/runtime-specs": "0.5.0",
+    "@dedot/shape": "0.5.0",
+    "@dedot/types": "0.5.0",
+    "@dedot/utils": "0.5.0"
   },
   "exports": {
     ".": {
@@ -92,7 +92,7 @@
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "05b2a88dd2c78b17d68f0dd211e50be79e79852e",
+  "gitHead": "968148ade63e07644094fc033be719b320e18a18",
   "module": "./index.js",
   "types": "./index.d.ts"
 }