dedot 0.0.1-alpha.28 → 0.0.1-alpha.29

package/README.md

@@ -87,23 +87,25 @@ const api = await Dedot.new('wss://rpc.polkadot.io');
 - [Submit Transactions](#transaction-apis)
 - [Events](#events)
 - [Errors](#errors)
+- [`@polkadot/api` -> `dedot`](#migration-from-polkadotapi-to-dedot)
 - [Credit](#credit)
 
 ### Status
 
-| Feature                                               | Status |
-|-------------------------------------------------------| ----------- |
-| Execute RPC (`api.rpc`)                               | ✅ |
-| Query On-chain Storage (`api.query`)                  | ✅ |
-| Get runtime constants (`api.consts`)                  | ✅ |
-| Runtime APIs (`api.call`)                             | ✅ |
-| Transaction APIs (`api.tx`)                           | ✅ |
-| Events (`api.events`)                                 | ✅ |
-| Errors (`api.errors`)                                 | ✅ |
-| Contract APIs                                         | ⏳ |
-| Metadata v14                                          | ✅ |
-| Metadata v15                                          | ✅ |
-| [RPC v2](https://github.com/dedotdev/dedot/issues/20) | ⏳ |
+| Feature                                                     | Status |
+|-------------------------------------------------------------|--------|
+| Execute RPC (`api.rpc`)                                     | ✅      |
+| Query On-chain Storage (`api.query`)                        | ✅      |
+| Get runtime constants (`api.consts`)                        | ✅      |
+| Runtime APIs (`api.call`)                                   | ✅      |
+| Transaction APIs (`api.tx`)                                 | ✅      |
+| Events (`api.events`)                                       | ✅      |
+| Errors (`api.errors`)                                       | ✅      |
+| Contract APIs                                               | ⏳      |
+| Metadata v14                                                | ✅      |
+| Metadata v15                                                | ✅      |
+| [RPC v2](https://github.com/dedotdev/dedot/issues/20)       | ⏳      |
+| [Extrinsic V5](https://github.com/dedotdev/dedot/issues/55) | ⏳      |
 
 ### Chain Types & APIs
 
@@ -299,6 +301,67 @@ const unsub = api.tx.utility.batch([transferTx.call, remarkCall])
     });
 ```
 
+<details>
+  <summary>Example 4: Teleport WND from Westend Asset Hub to Westend via XCM</summary>
+  
+```typescript
+import { WestendAssetHubApi, XcmVersionedLocation, XcmVersionedAssets, XcmV3WeightLimit } from '@dedot/chaintypes/westendAssetHub';
+import { AccountId32 } from '@dedot/codecs';
+
+const TWO_TOKENS = 2_000_000_000_000n;
+const destAddress = <bobAddress>;
+
+const api = await Dedot.new<WestendAssetHubApi>('...westend-assethub-rpc...');
+
+const dest: XcmVersionedLocation = {
+  tag: 'V3',
+  value: { parents: 1, interior: { tag: 'Here' } },
+};
+
+const beneficiary: XcmVersionedLocation = {
+  tag: 'V3',
+  value: {
+    parents: 0,
+    interior: {
+      tag: 'X1',
+      value: {
+        tag: 'AccountId32',
+        value: { id: new AccountId32(destAddress).raw },
+      },
+    },
+  },
+};
+
+const assets: XcmVersionedAssets = {
+  tag: 'V3',
+  value: [
+    {
+      id: {
+        tag: 'Concrete',
+        value: {
+          parents: 1,
+          interior: { tag: 'Here' },
+        },
+      },
+      fun: {
+        tag: 'Fungible',
+        value: TWO_TOKENS,
+      },
+    },
+  ],
+};
+
+const weight: XcmV3WeightLimit = { tag: 'Unlimited' };
+
+api.tx.polkadotXcm
+  .limitedTeleportAssets(dest, beneficiary, assets, 0, weight)
+  .signAndSend(alice, { signer, tip: 1_000_000n }, (result) => {
+    console.dir(result, { depth: null });
+  });
+```
+</details>
+
+
 ### 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.d.ts), similarly for other network as well.
@@ -347,6 +410,86 @@ await api.query.system.events(async (eventRecords) => {
 // ...
 ```
 
+### Migration from `@polkadot/api` to `dedot`
+`dedot` is inspired by `@polkadot/api`, so both are sharing some common patterns and api styling (eg: api syntax `api.<type>.<module>.<section>`). Although we have experimented some other different api stylings but to our findings and development experience, we find that the api style of `@polkadot/api` is very intuiative and easy to use. We decide the use a similar api styling with `@polkadot/api`, this also helps the migration from `@polkadot/api` to `dedot` easier & faster. 
+
+While the api style are similar, but there're also some differences you might need to be aware of when switching to use `dedot`. 
+
+**Initialize api client**
+- `@polkadot/api`
+```typescript
+import { ApiPromise, WsProvider } from '@polkadot/api';
+
+const api = await ApiPromise.create({ provider: new WsProvider('wss://rpc.polkadot.io') });
+```
+- `dedot`
+```typescript
+import { Dedot } from 'dedot';
+import type { PolkadotApi } from '@dedot/chaintypes';
+
+const api = await Dedot.new<PolkadotApi>('wss://rpc.polkadot.io'); // or Dedot.create(...) if you prefer
+
+// OR you want to have a custom provider
+import { WsProvider } from 'dedot'
+const api = await Dedot.new<PolkadotApi>({ provider: new WsProvider('wss://rpc.polkadot.io') });
+```
+
+- Notes:
+  - Under the hood, a `WsProvider` will be created if you initialize `Dedot` directly with an rpc endpoint.
+  - `dedot` only supports provider can make subscription request (e.g: via Websocket).
+  - We recommend specifying the `ChainApi` interface (e.g: [`PolkadotApi`](https://github.com/dedotdev/dedot/blob/02d7bca4c3c3d12c9591ea43b3410daf8e5aacbb/packages/chaintypes/src/polkadot/index.d.ts) in the example above) of the chain that you want to interact with. This enable apis & types suggestion/autocompletion for that particular chain (via IntelliSense). If you don't specify a `ChainApi` interface, the default [`SubstrateApi`](https://github.com/dedotdev/dedot/blob/a762faf8f6af40d3e4ef163bd538b270a5ca31e8/packages/chaintypes/src/substrate/index.d.ts) interface will be used.
+
+**Type system**
+
+Unlike `@polkadot/api` where data are wrapped inside a [codec types](https://polkadot.js.org/docs/api/start/types.basics), so we always need to unwrap the data before using it (e.g: via `.unwrap()`, `.toNumber()`, `.toString()`, `.toJSON()` ...). `dedot` leverages the native TypeScript type system to represent scale-codec types, so you can use the data directly without extra handling/unwrapping. The table below is a mapping between scale-codec types and TypeScript types that we're using for `dedot`:
+
+
+| Scale Codec                                             | TypeScript (`dedot`)                                                                                                           |
+|---------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------|
+| `u8`, `u16`, `u32`, `i8`, `i16`, `i32`                  | `number`                                                                                                                       |
+| `u64`, `u128`, `u256`, `i64`, `i128`, `i256`            | `bigint` (native [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt), not bn.js) |
+| `bool`                                                  | `boolean` (true, false)                                                                                                        |
+| `Option<T>`                                             | `T \| undefined`                                                                                                               |
+| `Result<Ok, Err>`                                       | `{ isOk: true; isErr?: false; value: Ok } \| { isOk?: false; isErr: true; err: Err }`                                          |
+| `Vec<T>`                                                | `Array<T>`                                                                                                                     |
+| `str`                                                   | `string`                                                                                                                       |
+| Tuple: `(A, B)`, `()`                                   | `[A, B]`, `[]`                                                                                                                 |
+| Struct: `struct { field_1: u8, field_2: str }`          | `{ field_1: number, field_2: string}`                                                                                          |
+| Enum: `enum { Variant1(u8), Variant2(bool), Variant3 }` | `{ tag: 'Variant1', value: number } \| { tag: 'Variant2', value: boolean } \| { tag: 'Variant2' }`                             |
+| FlatEnum: `enum { Variant1, Variant2 }`                 | `'Variant1' \| 'Variant2'`                                                                                                     |
+
+E.g 1:
+```typescript
+const runtimeVersion = api.consts.system.version;
+
+// @polkadot/api
+const specName: string = runtimeVersion.toJSON().specName; // OR runtimeVersion.specName.toString()
+
+// dedot
+const specName: string = runtimeVersion.specName;
+```
+
+E.g 2: 
+```typescript
+const balance = await api.query.system.account(<address>);
+
+// @polkadot/api
+const freeBalance: bigint = balance.data.free.toBigInt();
+
+// dedot
+const freeBalance: bigint = balance.data.free;
+```
+
+E.g 3:
+```typescript
+// @polkadot/api
+const proposalBondMaximum: bigint | undefined = api.consts.treasury.proposalBondMaximum.unwrapOr(undefined)?.toBigInt();
+
+// dedot
+const proposalBondMaximum: bigint | undefined = api.consts.treasury.proposalBondMaximum;
+```
+
+
 ### Credit
 
 `dedot` take a lot of inspirations from project [@polkadot/api](https://github.com/polkadot-js/api). A big thank to all the maintainers/contributors of this awesome library.

package/cjs/client/Dedot.js

@@ -3,9 +3,8 @@ 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 util_1 = require("@polkadot/util");
+const index_js_1 = require("../executor/index.js");
+const proxychain_js_1 = require("../proxychain.js");
 const storage_1 = require("@dedot/storage");
 const utils_1 = require("@dedot/utils");
 exports.KEEP_ALIVE_INTERVAL = 10_000; // in ms
@@ -18,7 +17,7 @@ exports.SUPPORTED_METADATA_VERSIONS = [15, 14];
  * ### Initialize API instance and interact with substrate-based network
  * ```typescript
  * import { Dedot } from 'dedot';
- * import { PolkadotApi } from '@dedot/chaintypes/polkadot';
+ * import type { PolkadotApi } from '@dedot/chaintypes/polkadot';
  *
  * const run = async () => {
  *   const api = await Dedot.new<PolkadotApi>('wss://rpc.polkadot.io');
@@ -49,9 +48,10 @@ exports.SUPPORTED_METADATA_VERSIONS = [15, 14];
  * run().catch(console.error);
  * ```
  */
-class Dedot {
+class Dedot extends utils_1.EventEmitter {
     #provider;
     #options;
+    #ready;
     #registry;
     #metadata;
     #metadataLatest;
@@ -69,8 +69,10 @@ class Dedot {
      * @protected
      */
     constructor(options) {
+        super();
         this.#options = this.#normalizeOptions(options);
         this.#provider = this.#getProvider();
+        this.#ready = this.#handleProviderEvents();
     }
     /**
      * Factory method to create a new Dedot instance
@@ -79,23 +81,50 @@ class Dedot {
      */
     static async create(options) {
         const api = new Dedot(options);
-        if (api.provider instanceof rpc_provider_1.WsProvider) {
-            await api.provider.isReady;
-        }
-        await api.init();
-        return api;
+        return api.untilReady().then(() => api);
     }
     /**
      * Alias for __Dedot.create__
+     *
      * @param options
      */
     static async new(options) {
         return Dedot.create(options);
     }
+    async untilReady() {
+        await this.#ready;
+    }
+    #handleProviderEvents() {
+        return new Promise((resolve, reject) => {
+            const onConnect = () => {
+                this.#onConnected()
+                    .then(resolve)
+                    .catch((e) => this.#onError(e).finally(reject));
+            };
+            this.provider.on('connected', onConnect);
+            this.provider.on('disconnected', this.#onDisconnected.bind(this));
+            this.provider.on('error', this.#onError.bind(this));
+            if (this.provider.isConnected) {
+                onConnect();
+            }
+        });
+    }
+    async #onConnected() {
+        this.emit('connected');
+        await this.#initialize();
+        this.emit('ready');
+    }
+    async #onDisconnected() {
+        await this.#unsubscribeUpdates();
+        this.emit('disconnected');
+    }
+    async #onError(e) {
+        this.emit('error', e);
+    }
     /**
      * Initialize APIs before usage
      */
-    async init() {
+    async #initialize() {
         await this.#initializeLocalCache();
         // Fetching node information
         let [genesisHash, runtimeVersion, chainName, chainProps, metadata] = await Promise.all([
@@ -161,7 +190,7 @@ class Dedot {
             }
         }
         if (shouldUpdateCache && this.#localCache) {
-            await this.#localCache.set(metadataKey, (0, util_1.u8aToHex)(codecs_1.$Metadata.tryEncode(metadata)));
+            await this.#localCache.set(metadataKey, (0, utils_1.u8aToHex)(codecs_1.$Metadata.tryEncode(metadata)));
         }
         if (!metadata) {
             throw new Error('Cannot load metadata');
@@ -246,18 +275,23 @@ class Dedot {
     }
     #normalizeOptions(options) {
         if (typeof options === 'string') {
-            return { endpoint: options };
+            return { ...this.#getDefaultOptions(), endpoint: options };
         }
         else {
             let { metadata } = options || {};
             if (metadata && typeof metadata === 'string') {
                 metadata = {
-                    [exports.CATCH_ALL_METADATA_KEY]: (0, util_1.hexAddPrefix)(metadata),
+                    [exports.CATCH_ALL_METADATA_KEY]: metadata,
                 };
             }
-            return { ...options, metadata };
+            return { ...this.#getDefaultOptions(), ...options, metadata };
         }
     }
+    #getDefaultOptions() {
+        return {
+            throwOnUnknownApi: true,
+        };
+    }
     #getProvider() {
         const { provider, endpoint } = this.#options;
         if (provider) {
@@ -290,7 +324,7 @@ class Dedot {
      */
     get rpc() {
         // TODO add executable carrier to support calling arbitrary rpc methods via api.rpc(<method>)
-        return (0, proxychain_1.newProxyChain)({ executor: new executor_1.RpcExecutor(this) });
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.RpcExecutor(this) });
     }
     /**
      * @description Entry-point for inspecting constants (parameter types) for all pallets (modules).
@@ -301,7 +335,7 @@ class Dedot {
      * ```
      */
     get consts() {
-        return (0, proxychain_1.newProxyChain)({ executor: new executor_1.ConstantExecutor(this) });
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.ConstantExecutor(this) });
     }
     /**
      * @description Entry-point for executing query to on-chain storage.
@@ -312,31 +346,54 @@ class Dedot {
      * ```
      */
     get query() {
-        return (0, proxychain_1.newProxyChain)({ executor: new executor_1.StorageQueryExecutor(this) });
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.StorageQueryExecutor(this) });
     }
     queryAt(blockHash) {
-        return (0, proxychain_1.newProxyChain)({ executor: new executor_1.StorageQueryExecutor(this, blockHash) });
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.StorageQueryExecutor(this, blockHash) });
     }
     /**
      * @description Entry-point for inspecting errors from metadata
      */
     get errors() {
-        return (0, proxychain_1.newProxyChain)({ executor: new executor_1.ErrorExecutor(this) });
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.ErrorExecutor(this) });
     }
     /**
      * @description Entry-point for inspecting events from metadata
      */
     get events() {
-        return (0, proxychain_1.newProxyChain)({ executor: new executor_1.EventExecutor(this) });
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.EventExecutor(this) });
     }
+    /**
+     * @description Entry-point for executing runtime api
+     *
+     * ```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 call() {
-        return (0, proxychain_1.newProxyChain)({ executor: new executor_1.RuntimeApiExecutor(this) });
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.RuntimeApiExecutor(this) });
     }
     callAt(blockHash) {
-        return (0, proxychain_1.newProxyChain)({ executor: new executor_1.RuntimeApiExecutor(this, blockHash) });
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.RuntimeApiExecutor(this, blockHash) });
     }
+    /**
+     * @description Entry-point for executing on-chain transactions
+     *
+     * ```typescript
+     * // Make a transfer balance transaction
+     * api.tx.balances.transferKeepAlive(<address>, <amount>)
+     *    .signAndSend(<keyPair|address>, { signer }, ({ status }) => {
+     *      console.log('Transaction status', status.tag);
+     *    });
+     * ```
+     */
     get tx() {
-        return (0, proxychain_1.newProxyChain)({ executor: new executor_1.TxExecutor(this) });
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.TxExecutor(this) });
     }
     /**
      * @description Current provider for api connection
@@ -371,6 +428,12 @@ class Dedot {
         this.#metadataLatest = metadata.latest;
         this.#registry = new codecs_1.PortableRegistry(this.#metadataLatest);
     }
+    /**
+     * @description Connect to blockchain node
+     */
+    async connect() {
+        await this.#provider.connect();
+    }
     /**
      * @description Disconnect to blockchain node
      */

package/cjs/client/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Dedot"), exports);
+__exportStar(require("./Dedot.js"), exports);

package/cjs/executor/ConstantExecutor.js

@@ -1,20 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstantExecutor = void 0;
-const util_1 = require("@polkadot/util");
-const Executor_1 = require("./Executor");
+const Executor_js_1 = require("./Executor.js");
+const utils_1 = require("@dedot/utils");
 /**
  * @name ConstantExecutor
  *
  * Find & decode the constant value from metadata
  */
-class ConstantExecutor extends Executor_1.Executor {
-    execute(pallet, constantName) {
+class ConstantExecutor extends Executor_js_1.Executor {
+    doExecute(pallet, constantName) {
         const targetPallet = this.getPallet(pallet);
-        const constantDef = targetPallet.constants.find((one) => (0, util_1.stringCamelCase)(one.name) === constantName);
-        if (!constantDef) {
-            throw new Error(`Constant ${constantName} not found in pallet ${pallet}`);
-        }
+        const constantDef = targetPallet.constants.find((one) => (0, utils_1.stringCamelCase)(one.name) === constantName);
+        (0, utils_1.assert)(constantDef, new utils_1.UnknownApiError(`Constant ${constantName} not found in pallet ${pallet}`));
         const $codec = this.registry.findCodec(constantDef.typeId);
         return $codec.tryDecode(constantDef.value);
     }

package/cjs/executor/ErrorExecutor.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorExecutor = void 0;
-const Executor_1 = require("./Executor");
+const Executor_js_1 = require("./Executor.js");
 const utils_1 = require("@dedot/utils");
-const util_1 = require("@polkadot/util");
 /**
  * @name ErrorExecutor
  * @description Find pallet error information from metadata
  */
-class ErrorExecutor extends Executor_1.Executor {
-    execute(pallet, errorName) {
+class ErrorExecutor extends Executor_js_1.Executor {
+    doExecute(pallet, errorName) {
         const targetPallet = this.getPallet(pallet);
         const errorTypeId = targetPallet.error;
-        (0, utils_1.assert)(errorTypeId, `Not found error with id ${errorTypeId} in pallet ${pallet}`);
+        (0, utils_1.assert)(errorTypeId, new utils_1.UnknownApiError(`Not found error with id ${errorTypeId} in pallet ${pallet}`));
         const errorDef = this.#getErrorDef(errorTypeId, errorName);
         return {
             meta: {
@@ -21,11 +20,11 @@ class ErrorExecutor extends Executor_1.Executor {
                 palletIndex: targetPallet.index,
             },
             is: (errorInfo) => {
-                if ((0, util_1.isObject)(errorInfo) && errorInfo.tag === 'Module') {
+                if ((0, utils_1.isObject)(errorInfo) && errorInfo.tag === 'Module') {
                     errorInfo = errorInfo.value;
                 }
-                if ((0, util_1.isObject)(errorInfo) && (0, util_1.isNumber)(errorInfo.index) && (0, util_1.isHex)(errorInfo.error)) {
-                    return errorInfo.index === targetPallet.index && (0, util_1.hexToU8a)(errorInfo.error)[0] === errorDef.index;
+                if ((0, utils_1.isObject)(errorInfo) && (0, utils_1.isNumber)(errorInfo.index) && (0, utils_1.isHex)(errorInfo.error)) {
+                    return errorInfo.index === targetPallet.index && (0, utils_1.hexToU8a)(errorInfo.error)[0] === errorDef.index;
                 }
                 return false;
             },
@@ -33,11 +32,11 @@ class ErrorExecutor extends Executor_1.Executor {
     }
     #getErrorDef(errorTypeId, errorName) {
         const def = this.metadata.types[errorTypeId];
-        (0, utils_1.assert)(def, `Error def not found for id ${errorTypeId}`);
+        (0, utils_1.assert)(def, new utils_1.UnknownApiError(`Error def not found for id ${errorTypeId}`));
         const { tag, value } = def.type;
-        (0, utils_1.assert)(tag === 'Enum', `Error type should be an enum, found: ${tag}`);
-        const errorDef = value.members.find(({ name }) => (0, util_1.stringPascalCase)(name) === errorName);
-        (0, utils_1.assert)(errorDef, `Error def not found for ${errorName}`);
+        (0, utils_1.assert)(tag === 'Enum', new utils_1.UnknownApiError(`Error type should be an enum, found: ${tag}`));
+        const errorDef = value.members.find(({ name }) => (0, utils_1.stringPascalCase)(name) === errorName);
+        (0, utils_1.assert)(errorDef, new utils_1.UnknownApiError(`Error def not found for ${errorName}`));
         return {
             ...errorDef,
             fieldCodecs: errorDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),

package/cjs/executor/EventExecutor.js

@@ -1,26 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventExecutor = void 0;
-const Executor_1 = require("./Executor");
-const util_1 = require("@polkadot/util");
+const Executor_js_1 = require("./Executor.js");
 const utils_1 = require("@dedot/utils");
 /**
  * @name EventExecutor
  * @description Find pallet event information from metadata
  */
-class EventExecutor extends Executor_1.Executor {
-    execute(pallet, errorName) {
+class EventExecutor extends Executor_js_1.Executor {
+    doExecute(pallet, errorName) {
         const targetPallet = this.getPallet(pallet);
         const eventTypeId = targetPallet.event;
-        (0, utils_1.assert)(eventTypeId, `Not found event with id ${eventTypeId} in pallet ${pallet}`);
+        (0, utils_1.assert)(eventTypeId, new utils_1.UnknownApiError(`Not found event with id ${eventTypeId} in pallet ${pallet}`));
         const eventDef = this.#getEventDef(eventTypeId, errorName);
         const is = (event) => {
-            const palletCheck = (0, util_1.stringCamelCase)(event.pallet) === pallet;
+            const palletCheck = (0, utils_1.stringCamelCase)(event.pallet) === pallet;
             if (typeof event.palletEvent === 'string') {
-                return palletCheck && (0, util_1.stringPascalCase)(event.palletEvent) === errorName;
+                return palletCheck && (0, utils_1.stringPascalCase)(event.palletEvent) === errorName;
             }
             else if (typeof event.palletEvent === 'object') {
-                return palletCheck && (0, util_1.stringPascalCase)(event.palletEvent.name) === errorName;
+                return palletCheck && (0, utils_1.stringPascalCase)(event.palletEvent.name) === errorName;
             }
             return false;
         };
@@ -39,11 +38,11 @@ class EventExecutor extends Executor_1.Executor {
     }
     #getEventDef(eventTypeId, errorName) {
         const def = this.metadata.types[eventTypeId];
-        (0, utils_1.assert)(def, `Event def not found for id ${eventTypeId}`);
+        (0, utils_1.assert)(def, new utils_1.UnknownApiError(`Event def not found for id ${eventTypeId}`));
         const { tag, value } = def.type;
-        (0, utils_1.assert)(tag === 'Enum', `Event type should be an enum, found: ${tag}`);
-        const eventDef = value.members.find(({ name }) => (0, util_1.stringPascalCase)(name) === errorName);
-        (0, utils_1.assert)(eventDef, `Event def not found for ${errorName}`);
+        (0, utils_1.assert)(tag === 'Enum', new utils_1.UnknownApiError(`Event type should be an enum, found: ${tag}`));
+        const eventDef = value.members.find(({ name }) => (0, utils_1.stringPascalCase)(name) === errorName);
+        (0, utils_1.assert)(eventDef, new utils_1.UnknownApiError(`Event def not found for ${errorName}`));
         return {
             ...eventDef,
             fieldCodecs: eventDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),

package/cjs/executor/Executor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Executor = void 0;
-const util_1 = require("@polkadot/util");
+const utils_1 = require("@dedot/utils");
 /**
  * @name Executor
  * @description Execution abstraction for a specific action
@@ -28,12 +28,21 @@ class Executor {
     get metadata() {
         return this.api.metadataLatest;
     }
-    getPallet(name, throwErr = true) {
-        const targetPallet = this.metadata.pallets.find((p) => (0, util_1.stringCamelCase)(p.name) === name);
-        if (!targetPallet && throwErr) {
-            throw new Error(`Pallet not found: ${name}`);
-        }
+    getPallet(name) {
+        const targetPallet = this.metadata.pallets.find((p) => (0, utils_1.stringCamelCase)(p.name) === name);
+        (0, utils_1.assert)(targetPallet, new utils_1.UnknownApiError(`Pallet not found: ${name}`));
         return targetPallet;
     }
+    execute(...paths) {
+        try {
+            return this.doExecute(...paths);
+        }
+        catch (e) {
+            if (!this.api.options.throwOnUnknownApi && e instanceof utils_1.UnknownApiError) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
 }
 exports.Executor = Executor;

package/cjs/executor/RpcExecutor.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcExecutor = void 0;
-const util_1 = require("@polkadot/util");
 const specs_1 = require("@dedot/specs");
 const utils_1 = require("@dedot/utils");
-const Executor_1 = require("./Executor");
+const Executor_js_1 = require("./Executor.js");
 const isOptionalParam = (param) => {
     return param.isOptional || param.name.startsWith('Option<');
 };
@@ -13,14 +12,14 @@ const isOptionalParam = (param) => {
  * @description Execute a rpc based from an RPC spec,
  * if a spec is not found we execute an arbitrary rpc method
  */
-class RpcExecutor extends Executor_1.Executor {
-    execute(section, method) {
+class RpcExecutor extends Executor_js_1.Executor {
+    doExecute(section, method) {
         const maybeRpcName = `${section}_${method}`;
         const callSpec = (0, specs_1.findRpcSpec)(maybeRpcName) || (0, specs_1.findAliasRpcSpec)(maybeRpcName);
         const rpcName = callSpec?.name || `${section}_${method}`;
         const isSubscription = !!callSpec?.pubsub;
         const fnRpc = async (...args) => {
-            (0, utils_1.assert)(callSpec, 'Rpc spec not found');
+            (0, utils_1.assert)(callSpec, new utils_1.UnknownApiError('Rpc spec not found'));
             this.checkRpcInputs(callSpec, args);
             const { params } = callSpec;
             const formattedInputs = args.map((input, index) => this.tryEncode(params[index], input));
@@ -28,10 +27,10 @@ class RpcExecutor extends Executor_1.Executor {
             return this.tryDecode(callSpec, result);
         };
         const fnSubRpc = async (...args) => {
-            (0, utils_1.assert)(callSpec, 'Rpc spec not found');
+            (0, utils_1.assert)(callSpec, new utils_1.UnknownApiError('Rpc spec not found'));
             const inArgs = args.slice();
             const callback = inArgs.pop();
-            (0, utils_1.assert)((0, util_1.isFunction)(callback), 'A callback is required for subscription');
+            (0, utils_1.assert)((0, utils_1.isFunction)(callback), 'A callback is required for subscription');
             this.checkRpcInputs(callSpec, inArgs);
             const onNewMessage = (error, result) => {
                 if (error) {
@@ -68,14 +67,11 @@ class RpcExecutor extends Executor_1.Executor {
             // We use `undefined` to represent Option::None in the client
             return undefined;
         }
-        const { type, isScale, codec } = callSpec;
+        const { isScale, codec } = callSpec;
         if (isScale) {
             (0, utils_1.assert)(codec, 'Codec not found to decode response');
             return codec.tryDecode(raw);
         }
-        if ((0, utils_1.isNativeType)(type)) {
-            return raw;
-        }
         return raw;
     }
     tryEncode(paramSpec, value) {
@@ -85,7 +81,7 @@ class RpcExecutor extends Executor_1.Executor {
                 return null;
             }
             (0, utils_1.assert)(codec, 'Codec not found to encode params');
-            return (0, util_1.u8aToHex)(codec.tryEncode(value));
+            return (0, utils_1.u8aToHex)(codec.tryEncode(value));
         }
         // TODO generalize this!
         if (value && value['toJSON']) {