dedot 0.0.1-alpha.26 → 0.0.1-alpha.27

package/README.md

@@ -1,6 +1,6 @@
 # dedot
 
-A fast & lightweight JavaScript/TypeScript client for [Polkadot](https://polkadot.network/) & [Substrate](https://substrate.io/)
+A 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"/>
@@ -46,8 +46,7 @@ const run = async () => {
   console.log('Metadata:', metadata);
 
   // Query on-chain storage
-  const address = '14...';
-  const balance = await api.query.system.account(address);
+  const balance = await api.query.system.account(<address>);
   console.log('Balance:', balance);
 
 
@@ -58,7 +57,11 @@ const run = async () => {
 
   // Get pallet constants
   const ss58Prefix = api.consts.system.ss58Prefix;
-  console.log('Polkadot ss58Prefix:', ss58Prefix)
+  console.log('Polkadot ss58Prefix:', ss58Prefix);
+
+  // Call runtime api
+  const pendingRewards = await api.call.nominationPoolsApi.pendingRewards(<address>)
+  console.log('Pending rewards:', pendingRewards);
 
   // await unsub();
   // await api.disconnect();
@@ -80,8 +83,8 @@ const api = await Dedot.new('wss://rpc.polkadot.io');
 - [Execute RPC Methods](#execute-rpc-methods)
 - [Query On-chain Storage](#query-on-chain-storage)
 - [Constants](#constants)
-- [Runtime APIs ⏳](#runtime-apis)
-- [Submit Transactions ⏳](#submit-transactions)
+- [Runtime APIs](#runtime-apis)
+- [Submit Transactions](#transaction-apis)
 - [Events](#events)
 - [Errors](#errors)
 - [Credit](#credit)
@@ -91,10 +94,10 @@ const api = await Dedot.new('wss://rpc.polkadot.io');
 | Feature                                               | Status |
 |-------------------------------------------------------| ----------- |
 | Execute RPC (`api.rpc`)                               | ✅ |
-| Query on-chain storage (`api.query`)                  | ✅ |
+| Query On-chain Storage (`api.query`)                  | ✅ |
 | Get runtime constants (`api.consts`)                  | ✅ |
-| Runtime APIs (`api.call`)                             | ⏳ |
-| Transaction APIs (`api.tx`)                           | ⏳ |
+| Runtime APIs (`api.call`)                             | ✅ |
+| Transaction APIs (`api.tx`)                           | ✅ |
 | Events (`api.events`)                                 | ✅ |
 | Errors (`api.errors`)                                 | ✅ |
 | Contract APIs                                         | ⏳ |
@@ -139,11 +142,22 @@ const genericApi = await Dedot.new('ws://localhost:9944');
 // ...
 ```
 
-In alpha test version, we only support `ChainApi` interfaces for 4 networks (Polkadot, Kusama, Moonbeam & Astar), we plan to expand this list to support more Substrate-based blockchains in the near future.
+Supported `ChainApi` interfaces are defined [here](https://github.com/dedotdev/dedot/blob/main/packages/chaintypes/src/index.ts), you can also generate the `ChainApi` interface for the chain you want to connect with using `@dedot/cli`.
+
+```shell
+# Install @dedot/cli via yarn
+yarn add -D @dedot/cli
+
+# Or via npm
+npm i -D @dedot/cli
+
+# Generate ChainApi interface for Polkadot network via rpc endpoint: wss://rpc.polkadot.io
+npx dedot chaintypes -w wss://rpc.polkadot.io
+```
 
 ### Execute RPC Methods
 
-RPCs can be execute via `api.rpc` entry point. After creating a `Dedot` 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.<module>.<methodName>`. E.g: you can find all supported RPC methods for Polkadot network [here](https://github.com/dedotdev/dedot/blob/main/packages/chaintypes/src/polkadot/rpc.ts), similarly for other networks as well.
+RPCs can be executed via `api.rpc` entry point. After creating a `Dedot` 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.<module>.<methodName>`. E.g: you can find all supported RPC methods for Polkadot network [here](https://github.com/dedotdev/dedot/blob/main/packages/chaintypes/src/polkadot/rpc.d.ts), similarly for other networks as well.
 
 Examples:
 ```typescript
@@ -156,7 +170,7 @@ const result = await api.rpc.module.rpc_name('param1', 'param2');
 
 ### Query On-chain Storage
 
-On-chain storage can be query 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 execute with format: `api.query.<pallet>.<storgeEntry>`. E.g: You can find all the available storage queries of Polkadot network [here](https://github.com/dedotdev/dedot/blob/main/packages/chaintypes/src/polkadot/query.ts), similarly for other networks as well.
+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/dedot/blob/main/packages/chaintypes/src/polkadot/query.d.ts), similarly for other networks as well.
 
 Examples:
 ```typescript
@@ -168,7 +182,7 @@ const events = await api.query.system.events();
 ```
 ### Constants
 
-Runtime constants (parameter types) are defined in metadata, and can be inspect 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/dedot/blob/main/packages/chaintypes/src/polkadot/consts.ts), similarly for other networks.
+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/dedot/blob/main/packages/chaintypes/src/polkadot/consts.d.ts), similarly for other networks.
 
 Examples:
 ```typescript
@@ -181,15 +195,113 @@ const existentialDeposit = api.consts.balances.existentialDeposit;
 
 ### Runtime APIs
 
-⏳ _coming soon_
+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/dedot/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>);
+
+// 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);
+
+// Get runtime version
+const runtimeVersion = await api.call.core.version();
+```
+
+For chains that only support Metadata V14, we need to bring in the Runtime Api definitions when initializing the Dedot client instance to encode & decode the calls. You can find all supported Runtime Api definitions in [`@dedot/specs`](https://github.com/dedotdev/dedot/blob/60de0fed8ba19c67a7e174c6168a127fdbf6caef/packages/specs/src/runtime/all.ts#L21-L39) package.
+
+Examples:
+```typescript
+import { RuntimeApis } from '@dedot/specs';
+const api = await Dedot.new({ endpoint: 'wss://rpc.mynetwork.com', runtimeApis: RuntimeApis });
+
+// Or bring in only the Runtime Api definition that you want to interact with
+import { AccountNonceApi } from '@dedot/specs';
+const api = await Dedot.new({ endpoint: 'wss://rpc.mynetwork.com', runtimeApis: { AccountNonceApi } });
+
+// Get account nonce
+const nonce = await api.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/60de0fed8ba19c67a7e174c6168a127fdbf6caef/packages/specs/src/runtime/all.ts#L21-L39).
+
+### Transaction APIs
 
-### Submit Transactions
+Transaction apis are designed to be compatible with [`IKeyringPair`](https://github.com/polkadot-js/api/blob/3bdf49b0428a62f16b3222b9a31bfefa43c1ca55/packages/types/src/types/interfaces.ts#L15-L21) and [`Signer`](https://github.com/polkadot-js/api/blob/3bdf49b0428a62f16b3222b9a31bfefa43c1ca55/packages/types/src/types/extrinsic.ts#L135-L150) interfaces, so you can sign the transactions with accounts created by a [`Keyring`](https://github.com/polkadot-js/common/blob/22aab4a4e62944a2cf8c885f50be2c1b842813ec/packages/keyring/src/keyring.ts#L41-L40) or from any [Polkadot{.js}-based](https://github.com/polkadot-js/extension?tab=readme-ov-file#api-interface) wallet extensions.
 
-⏳ _coming soon_
+All transaction apis are exposed in `ChainApi` interface and can be access with syntax: `api.tx.<pallet>.<transactionName>`. E.g: Available transaction apis for Polkadot network are defined [here](https://github.com/dedotdev/dedot/blob/516c5dd948ac89ef53644b7fb1f62df1727adadb/packages/chaintypes/src/polkadot/tx.d.ts), similarly for other networks as well.
+
+Example 1: Sign transaction with a Keying account
+```typescript
+import { cryptoWaitReady } from '@polkadot/util-crypto';
+import { Keyring } from '@polkadot/keyring';
+...
+await cryptoWaitReady();
+const keyring = new Keyring({ type: 'sr25519' });
+const alice = keyring.addFromUri('//Alice');
+
+const unsub = await api.tx.balances
+    .transferKeepAlive(<destAddress>, 2_000_000_000_000n)
+    .signAndSend(alice, async ({ status }) => {
+      console.log('Transaction status', status.tag);
+      if (status.tag === 'InBlock') {
+        console.log(`Transaction completed at block hash ${status.value}`);
+        await unsub();
+      }
+    });
+```
+
+Example 2: Sign transaction using `Signer` from Polkadot{.js} wallet extension
+```typescript
+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
+    .transferKeepAlive(<destAddress>, 2_000_000_000_000n)
+    .signAndSend(account.address, { signer }, async ({ status }) => {
+      console.log('Transaction status', status.tag);
+      if (status.tag === 'InBlock') {
+        console.log(`Transaction completed at block hash ${status.value}`);
+        await unsub();
+      }
+    });
+```
+
+Example 3: Submit a batch transaction
+```typescript
+import type { PolkadotRuntimeRuntimeCallLike } from '@dedot/chaintypes/polkadot';
+
+// Omit the detail for simplicity
+const account = ...;
+const signer = ...;
+
+const transferTx = api.tx.balances.transferKeepAlive(<destAddress>, 2_000_000_000_000n);
+const remarkCall: PolkadotRuntimeRuntimeCallLike = {
+  pallet: 'System',
+  palletCall: {
+    name: 'RemarkWithEvent',
+    params: {
+      remark: 'Hello Dedot!',
+    },
+  },
+};
+
+const unsub = api.tx.utility.batch([transferTx.call, remarkCall])
+    .signAndSend(account.address, { signer }, async ({ status }) => {
+      console.log('Transaction status', status.tag);
+      if (status.tag === 'InBlock') {
+        console.log(`Transaction completed at block hash ${status.value}`);
+        await unsub();
+      }
+    });
+```
 
 ### 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/dedot/blob/main/packages/chaintypes/src/polkadot/events.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 `api.events.<pallet>.<eventName>`. E.g: Events for Polkadot network can be found [here](https://github.com/dedotdev/dedot/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.
 
@@ -213,7 +325,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/dedot/blob/main/packages/chaintypes/src/polkadot/errors.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: `api.errors.<pallet>.<errorName>`. E.g: Available errors for Polkadot network can be found [here](https://github.com/dedotdev/dedot/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.
 

package/cjs/client/Dedot.js

@@ -1,16 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dedot = exports.SUPPORTED_METADATA_VERSIONS = exports.CATCH_ALL_METADATA_KEY = exports.KEEP_ALIVE_INTERVAL = void 0;
 const rpc_provider_1 = require("@polkadot/rpc-provider");
 const codecs_1 = require("@dedot/codecs");
 const executor_1 = require("../executor");
 const proxychain_1 = require("../proxychain");
-const utils_1 = require("@dedot/utils");
-const localforage_1 = __importDefault(require("localforage"));
 const util_1 = require("@polkadot/util");
+const storage_1 = require("@dedot/storage");
+const utils_1 = require("@dedot/utils");
 exports.KEEP_ALIVE_INTERVAL = 10_000; // in ms
 exports.CATCH_ALL_METADATA_KEY = `RAW_META/ALL`;
 exports.SUPPORTED_METADATA_VERSIONS = [15, 14];
@@ -54,8 +51,8 @@ exports.SUPPORTED_METADATA_VERSIONS = [15, 14];
  */
 class Dedot {
     #provider;
-    #registry;
     #options;
+    #registry;
     #metadata;
     #metadataLatest;
     #genesisHash;
@@ -74,7 +71,6 @@ class Dedot {
     constructor(options) {
         this.#options = this.#normalizeOptions(options);
         this.#provider = this.#getProvider();
-        this.#registry = new codecs_1.CodecRegistry();
     }
     /**
      * Factory method to create a new Dedot instance
@@ -117,24 +113,18 @@ class Dedot {
         this.#subscribeUpdates();
     }
     async #initializeLocalCache() {
+        if (!this.#options.cacheMetadata)
+            return;
         // Initialize local cache
-        if (this.#options.cacheMetadata) {
-            try {
-                // TODO add a custom driver to support nodejs
-                this.#localCache = localforage_1.default.createInstance({
-                    driver: [localforage_1.default.INDEXEDDB, localforage_1.default.LOCALSTORAGE],
-                    name: 'DedotCache',
-                    storeName: 'LocalCache',
-                });
-                // Verify the storage is working
-                await this.#localCache.setItem('testKey', 'testValue');
-                await this.#localCache.removeItem('testKey');
-            }
-            catch (e) {
-                this.#localCache = undefined;
-                this.#options.cacheMetadata = false;
-                console.error('Cannot initialize local cache in this environment, disable metadata caching');
-            }
+        if (this.#options.cacheStorage) {
+            this.#localCache = this.#options.cacheStorage;
+            return;
+        }
+        try {
+            this.#localCache = new storage_1.LocalStorage();
+        }
+        catch {
+            throw new Error('localStorage is not available for caching, please provide a cacheStorage option');
         }
     }
     async #setupMetadata(preloadMetadata) {
@@ -152,7 +142,7 @@ class Dedot {
             if (this.#localCache && this.#options.cacheMetadata) {
                 if (!metadata) {
                     try {
-                        const cachedRawMetadata = await this.#localCache.getItem(metadataKey);
+                        const cachedRawMetadata = await this.#localCache.get(metadataKey);
                         if (cachedRawMetadata) {
                             metadata = codecs_1.$Metadata.tryDecode(cachedRawMetadata);
                         }
@@ -171,7 +161,7 @@ class Dedot {
             }
         }
         if (shouldUpdateCache && this.#localCache) {
-            await this.#localCache.setItem(metadataKey, (0, util_1.u8aToHex)(codecs_1.$Metadata.tryEncode(metadata)));
+            await this.#localCache.set(metadataKey, (0, util_1.u8aToHex)(codecs_1.$Metadata.tryEncode(metadata)));
         }
         if (!metadata) {
             throw new Error('Cannot load metadata');
@@ -270,17 +260,16 @@ class Dedot {
     }
     #getProvider() {
         const { provider, endpoint } = this.#options;
-        if (provider)
+        if (provider) {
+            (0, utils_1.assert)(provider.hasSubscriptions, 'Only supports RPC Provider can make subscription requests');
             return provider;
+        }
         if (endpoint) {
             if (endpoint.startsWith('ws://') || endpoint.startsWith('wss://')) {
                 return new rpc_provider_1.WsProvider(endpoint);
             }
-            else if (endpoint.startsWith('http://') || endpoint.startsWith('https://')) {
-                return new rpc_provider_1.HttpProvider(endpoint);
-            }
             else {
-                throw new Error('Invalid network endpoint, a valid endpoint should start with `wss://`, `ws://`, `https://` or `http://`');
+                throw new Error('Invalid RPC network endpoint, a valid endpoint should start with `wss://`, `ws://`');
             }
         }
         // TODO support light-client
@@ -368,10 +357,10 @@ class Dedot {
         return !!this.#metadata && !!this.#metadataLatest;
     }
     get metadata() {
-        return (0, utils_1.ensurePresence)(this.#metadata);
+        return this.#metadata;
     }
     get metadataLatest() {
-        return (0, utils_1.ensurePresence)(this.#metadataLatest);
+        return this.#metadataLatest;
     }
     /**
      * Setup metadata for
@@ -380,7 +369,7 @@ class Dedot {
     setMetadata(metadata) {
         this.#metadata = metadata;
         this.#metadataLatest = metadata.latest;
-        this.registry.setMetadata(this.#metadataLatest);
+        this.#registry = new codecs_1.PortableRegistry(this.#metadataLatest);
     }
     /**
      * @description Disconnect to blockchain node

package/cjs/executor/ConstantExecutor.js

@@ -15,7 +15,7 @@ class ConstantExecutor extends Executor_1.Executor {
         if (!constantDef) {
             throw new Error(`Constant ${constantName} not found in pallet ${pallet}`);
         }
-        const $codec = this.registry.findPortableCodec(constantDef.typeId);
+        const $codec = this.registry.findCodec(constantDef.typeId);
         return $codec.tryDecode(constantDef.value);
     }
 }

package/cjs/executor/ErrorExecutor.js

@@ -40,7 +40,7 @@ class ErrorExecutor extends Executor_1.Executor {
         (0, utils_1.assert)(errorDef, `Error def not found for ${errorName}`);
         return {
             ...errorDef,
-            fieldCodecs: errorDef.fields.map(({ typeId }) => this.registry.findPortableCodec(typeId)),
+            fieldCodecs: errorDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
         };
     }
 }

package/cjs/executor/EventExecutor.js

@@ -46,7 +46,7 @@ class EventExecutor extends Executor_1.Executor {
         (0, utils_1.assert)(eventDef, `Event def not found for ${errorName}`);
         return {
             ...eventDef,
-            fieldCodecs: eventDef.fields.map(({ typeId }) => this.registry.findPortableCodec(typeId)),
+            fieldCodecs: eventDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
         };
     }
 }

package/cjs/executor/RpcExecutor.js

@@ -68,9 +68,10 @@ class RpcExecutor extends Executor_1.Executor {
             // We use `undefined` to represent Option::None in the client
             return undefined;
         }
-        const { type, isScale } = callSpec;
+        const { type, isScale, codec } = callSpec;
         if (isScale) {
-            return this.registry.findCodec(type).tryDecode(raw);
+            (0, utils_1.assert)(codec, 'Codec not found to decode response');
+            return codec.tryDecode(raw);
         }
         if ((0, utils_1.isNativeType)(type)) {
             return raw;
@@ -78,13 +79,13 @@ class RpcExecutor extends Executor_1.Executor {
         return raw;
     }
     tryEncode(paramSpec, value) {
-        const { type, isScale, isOptional } = paramSpec;
+        const { isScale, codec, isOptional } = paramSpec;
         if (isScale) {
             if (isOptional && (value === undefined || value === null)) {
                 return null;
             }
-            const $codec = this.registry.findCodec(type);
-            return (0, util_1.u8aToHex)($codec.tryEncode(value));
+            (0, utils_1.assert)(codec, 'Codec not found to encode params');
+            return (0, util_1.u8aToHex)(codec.tryEncode(value));
         }
         // TODO generalize this!
         if (value && value['toJSON']) {

package/cjs/executor/RuntimeApiExecutor.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuntimeApiExecutor = exports.FallbackRuntimeApis = void 0;
+exports.RuntimeApiExecutor = exports.FallbackRuntimeApiSpecs = exports.FallbackRuntimeApis = void 0;
 const Executor_1 = require("./Executor");
 const utils_1 = require("@dedot/utils");
 const util_1 = require("@polkadot/util");
@@ -8,13 +8,14 @@ const specs_1 = require("@dedot/specs");
 exports.FallbackRuntimeApis = [
     ['0x37e397fc7c91f5e4', 2], // Metadata Api v2
 ];
+exports.FallbackRuntimeApiSpecs = { Metadata: specs_1.Metadata };
 class RuntimeApiExecutor extends Executor_1.Executor {
     execute(runtimeApi, method) {
         const runtimeApiName = (0, util_1.stringPascalCase)(runtimeApi);
         const methodName = (0, utils_1.stringSnakeCase)(method);
         const callName = this.#callName({ runtimeApiName, methodName });
         const callSpec = this.#findRuntimeApiMethodSpec(runtimeApiName, methodName);
-        (0, utils_1.assert)(callSpec, `Runtime Api not found: ${callName}`);
+        (0, utils_1.assert)(callSpec, `Runtime api spec not found for ${callName}`);
         const callFn = async (...args) => {
             const { params } = callSpec;
             const formattedInputs = params.map((param, index) => this.tryEncode(param, args[index]));
@@ -42,10 +43,7 @@ class RuntimeApiExecutor extends Executor_1.Executor {
         if (codec)
             return codec;
         if ((0, util_1.isNumber)(typeId)) {
-            return this.registry.findPortableCodec(typeId);
-        }
-        if (type) {
-            return this.registry.findCodec(type);
+            return this.registry.findCodec(typeId);
         }
         throw new Error(error || 'Codec not found');
     }
@@ -56,14 +54,14 @@ class RuntimeApiExecutor extends Executor_1.Executor {
         const targetVersion = this.#findTargetRuntimeApiVersion(runtimeApi);
         if (!(0, util_1.isNumber)(targetVersion))
             return undefined;
-        const userDefinedSpec = this.#findUserDefinedSpec(runtimeApi, method, targetVersion);
+        const userDefinedSpec = this.#findDefinedSpec(this.api.options.runtimeApis, runtimeApi, method, targetVersion);
         if (userDefinedSpec)
             return userDefinedSpec;
         const methodDef = this.#findRuntimeApiMethodDef(runtimeApi, method);
         if (methodDef) {
             return this.#toMethodSpec(runtimeApi, methodDef);
         }
-        return this.#findExternalSpec(runtimeApi, method, targetVersion);
+        return this.#findDefinedSpec(exports.FallbackRuntimeApiSpecs, runtimeApi, method, targetVersion);
     }
     #findRuntimeApiMethodDef(runtimeApi, method) {
         try {
@@ -99,14 +97,10 @@ class RuntimeApiExecutor extends Executor_1.Executor {
             ?.at(1);
         return foundVersion;
     }
-    #findExternalSpec(runtimeApiName, methodName, targetRuntimeApiVersion) {
-        return (0, specs_1.findRuntimeApiMethodSpec)(this.#callName({ runtimeApiName, methodName }), targetRuntimeApiVersion);
-    }
-    #findUserDefinedSpec(runtimeApi, method, runtimeApiVersion) {
-        const userDefinedSpecs = this.api.options.runtime;
-        if (!userDefinedSpecs)
+    #findDefinedSpec(specs, runtimeApi, method, runtimeApiVersion) {
+        if (!specs)
             return undefined;
-        const methodSpecs = (0, specs_1.extractRuntimeApisModule)(userDefinedSpecs).map(specs_1.extractRuntimeApiSpec).flat();
+        const methodSpecs = (0, specs_1.toRuntimeApiSpecs)(specs).map(specs_1.toRuntimeApiMethods).flat();
         return methodSpecs.find(({ runtimeApiName, methodName, version }) => `${(0, util_1.stringPascalCase)(runtimeApiName)}_${(0, utils_1.stringSnakeCase)(methodName)}` === `${runtimeApi}_${method}` &&
             runtimeApiVersion === version);
     }

package/cjs/executor/TxExecutor.js

@@ -6,7 +6,7 @@ const utils_1 = require("@dedot/utils");
 const util_1 = require("@polkadot/util");
 const codecs_1 = require("@dedot/codecs");
 const extrinsic_1 = require("../extrinsic");
-const util_crypto_1 = require("@polkadot/util-crypto");
+const utils_2 = require("@dedot/utils");
 function isKeyringPair(account) {
     return (0, util_1.isFunction)(account.sign);
 }
@@ -20,7 +20,7 @@ exports.isKeyringPair = isKeyringPair;
 function signRaw(signerPair, raw, options) {
     const u8a = (0, util_1.hexToU8a)(raw);
     // Ref: https://github.com/paritytech/polkadot-sdk/blob/943697fa693a4da6ef481ef93df522accb7d0583/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs#L234-L238
-    const toSignRaw = u8a.length > 256 ? (0, util_crypto_1.blake2AsU8a)(u8a, 256) : u8a;
+    const toSignRaw = u8a.length > 256 ? (0, utils_2.blake2AsU8a)(u8a, 256) : u8a;
     return signerPair.sign(toSignRaw, options);
 }
 exports.signRaw = signRaw;
@@ -31,12 +31,12 @@ exports.signRaw = signRaw;
 class TxExecutor extends Executor_1.Executor {
     execute(pallet, functionName) {
         const targetPallet = this.getPallet(pallet);
-        (0, utils_1.assert)(targetPallet.calls, 'Tx call type not found');
+        (0, utils_1.assert)(targetPallet.calls, `Tx calls are not available for pallet ${targetPallet.name}`);
         const txType = this.metadata.types[targetPallet.calls];
-        (0, utils_1.assert)(txType.type.tag === 'Enum', 'Tx type should be enum');
+        (0, utils_1.assert)(txType.type.tag === 'Enum', 'Tx type defs should be enum');
         const isFlatEnum = txType.type.value.members.every((m) => m.fields.length === 0);
         const txCallDef = txType.type.value.members.find((m) => (0, util_1.stringCamelCase)(m.name) === functionName);
-        (0, utils_1.assert)(txCallDef, 'Tx call not found');
+        (0, utils_1.assert)(txCallDef, `Tx call spec not found for ${pallet}.${functionName}`);
         const txCallFn = (...args) => {
             let call;
             if (isFlatEnum) {
@@ -62,7 +62,7 @@ class TxExecutor extends Executor_1.Executor {
         };
         txCallFn.meta = {
             ...txCallDef,
-            fieldCodecs: txCallDef.fields.map(({ typeId }) => this.registry.findPortableCodec(typeId)),
+            fieldCodecs: txCallDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
             pallet: targetPallet.name,
             palletIndex: targetPallet.index,
         };
@@ -91,7 +91,7 @@ class TxExecutor extends Executor_1.Executor {
                     throw new Error('Signer not found. Cannot sign the extrinsic!');
                 }
                 const { signatureTypeId } = this.registry.metadata.extrinsic;
-                const $Signature = this.registry.findPortableCodec(signatureTypeId);
+                const $Signature = this.registry.findCodec(signatureTypeId);
                 this.attachSignature({
                     address: address,
                     signature: $Signature.tryDecode(signature),
@@ -132,7 +132,7 @@ class TxExecutor extends Executor_1.Executor {
                                 api.rpc.chain.getBlock(blockHash),
                                 api.queryAt(blockHash).system.events(),
                             ]);
-                            const txIndex = signedBlock.block.extrinsics.findIndex((tx) => (0, util_crypto_1.blake2AsHex)((0, util_1.hexToU8a)(tx)) === txHash);
+                            const txIndex = signedBlock.block.extrinsics.findIndex((tx) => (0, utils_2.blake2AsHex)((0, util_1.hexToU8a)(tx)) === txHash);
                             (0, utils_1.assert)(txIndex >= 0, 'Extrinsic not found!');
                             const events = blockEvents.filter(({ phase }) => phase.tag === 'ApplyExtrinsic' && phase.value === txIndex);
                             return callback(new extrinsic_1.SubmittableResult({ status, txHash, events, txIndex }));

package/cjs/extrinsic/extensions/ExtraSignedExtension.js

@@ -41,20 +41,20 @@ class ExtraSignedExtension extends SignedExtension_1.SignedExtension {
         return 'ExtraSignedExtension';
     }
     get dataCodec() {
-        const { extraTypeId } = this.api.metadataLatest.extrinsic;
-        return (0, utils_1.ensurePresence)(this.registry.findPortableCodec(extraTypeId));
+        const { extraTypeId } = this.registry.metadata.extrinsic;
+        return (0, utils_1.ensurePresence)(this.registry.findCodec(extraTypeId));
     }
     get additionalSignedCodec() {
-        const $AdditionalSignedCodecs = this.#signedExtensionDefs.map((se) => this.registry.findPortableCodec(se.additionalSigned));
+        const $AdditionalSignedCodecs = this.#signedExtensionDefs.map((se) => this.registry.findCodec(se.additionalSigned));
         return $.Tuple(...$AdditionalSignedCodecs);
     }
     get payloadCodec() {
-        const { callTypeId } = this.api.metadataLatest.extrinsic;
-        const $Call = this.registry.findPortableCodec(callTypeId);
+        const { callTypeId } = this.registry.metadata.extrinsic;
+        const $Call = this.registry.findCodec(callTypeId);
         return $.Tuple($Call, this.dataCodec, this.additionalSignedCodec);
     }
     get #signedExtensionDefs() {
-        return this.api.metadataLatest.extrinsic.signedExtensions;
+        return this.registry.metadata.extrinsic.signedExtensions;
     }
     #getSignedExtensions() {
         return this.#signedExtensionDefs.map((extDef) => {
@@ -70,7 +70,7 @@ class ExtraSignedExtension extends SignedExtension_1.SignedExtension {
     }
     toPayload(call = '0x') {
         const signedExtensions = this.#signedExtensions.map((se) => se.identifier);
-        const { version } = this.api.registry.metadata.extrinsic;
+        const { version } = this.registry.metadata.extrinsic;
         return (0, util_1.objectSpread)({ address: this.options.signerAddress, signedExtensions, version, method: call }, ...this.#signedExtensions.map((se) => se.toPayload()));
     }
     toRawPayload(call = '0x') {

package/cjs/extrinsic/extensions/SignedExtension.js

@@ -20,10 +20,10 @@ class SignedExtension {
         return this.signedExtensionDef.ident;
     }
     get dataCodec() {
-        return (0, utils_1.ensurePresence)(this.api.registry.findPortableCodec(this.signedExtensionDef.typeId));
+        return (0, utils_1.ensurePresence)(this.registry.findCodec(this.signedExtensionDef.typeId));
     }
     get additionalSignedCodec() {
-        return (0, utils_1.ensurePresence)(this.api.registry.findPortableCodec(this.signedExtensionDef.additionalSigned));
+        return (0, utils_1.ensurePresence)(this.registry.findCodec(this.signedExtensionDef.additionalSigned));
     }
     get registry() {
         return this.api.registry;

package/cjs/extrinsic/extensions/known/ChargeAssetTxPayment.js

@@ -18,7 +18,7 @@ class ChargeAssetTxPayment extends SignedExtension_1.SignedExtension {
     toPayload() {
         const { tip, assetId } = this.data;
         return {
-            tip: (0, util_1.bnToHex)(tip, { isLe: false }),
+            tip: (0, utils_1.bnToHex)(tip),
             // @ts-ignore
             assetId: this.#encodeAssetId(assetId),
         };
@@ -30,10 +30,10 @@ class ChargeAssetTxPayment extends SignedExtension_1.SignedExtension {
         return (0, util_1.u8aToHex)(this.$AssetId().tryEncode(assetId));
     }
     $AssetId() {
-        const extensionTypeDef = this.registry.findPortableType(this.signedExtensionDef.typeId);
+        const extensionTypeDef = this.registry.findType(this.signedExtensionDef.typeId);
         (0, utils_1.assert)(extensionTypeDef.type.tag === 'Struct');
         const assetIdTypeDef = extensionTypeDef.type.value.fields.find((f) => f.name === 'asset_id');
-        const $codec = this.registry.findPortableCodec(assetIdTypeDef.typeId);
+        const $codec = this.registry.findCodec(assetIdTypeDef.typeId);
         const codecMetadata = $codec.metadata[0];
         if (codecMetadata.name === '$.option') {
             return codecMetadata.args[0]; // inner shape

package/cjs/extrinsic/extensions/known/ChargeTransactionPayment.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChargeTransactionPayment = void 0;
 const SignedExtension_1 = require("../SignedExtension");
-const util_1 = require("@polkadot/util");
+const utils_1 = require("@dedot/utils");
 class ChargeTransactionPayment extends SignedExtension_1.SignedExtension {
     async init() {
         this.data = this.payloadOptions.tip || 0n;
     }
     toPayload() {
         return {
-            tip: (0, util_1.bnToHex)(this.data, { isLe: false }),
+            tip: (0, utils_1.bnToHex)(this.data),
         };
     }
 }