@acala-network/chopsticks-core 1.0.6-1 → 1.1.0

package/dist/cjs/rpc/substrate/system.js

@@ -5,41 +5,41 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    system_accountNextIndex: function() {
+    get system_accountNextIndex () {
         return system_accountNextIndex;
     },
-    system_chain: function() {
+    get system_chain () {
         return system_chain;
     },
-    system_chainType: function() {
+    get system_chainType () {
         return system_chainType;
     },
-    system_dryRun: function() {
+    get system_dryRun () {
         return system_dryRun;
     },
-    system_health: function() {
+    get system_health () {
         return system_health;
     },
-    system_localListenAddresses: function() {
+    get system_localListenAddresses () {
         return system_localListenAddresses;
     },
-    system_localPeerId: function() {
+    get system_localPeerId () {
         return system_localPeerId;
     },
-    system_name: function() {
+    get system_name () {
         return system_name;
     },
-    system_nodeRoles: function() {
+    get system_nodeRoles () {
         return system_nodeRoles;
     },
-    system_properties: function() {
+    get system_properties () {
         return system_properties;
     },
-    system_version: function() {
+    get system_version () {
         return system_version;
     }
 });

package/dist/cjs/setup.js

@@ -5,14 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    processOptions: function() {
+    get processOptions () {
         return processOptions;
     },
-    setup: function() {
+    get setup () {
         return setup;
     }
 });

package/dist/cjs/utils/decoder.js

@@ -5,20 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    decodeBlockStorageDiff: function() {
+    get decodeBlockStorageDiff () {
         return decodeBlockStorageDiff;
     },
-    decodeKey: function() {
+    get decodeKey () {
         return decodeKey;
     },
-    decodeKeyValue: function() {
+    get decodeKeyValue () {
         return decodeKeyValue;
     },
-    toStorageObject: function() {
+    get toStorageObject () {
         return toStorageObject;
     }
 });

package/dist/cjs/utils/index.js

@@ -5,53 +5,53 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    CHILD_PREFIX_LENGTH: function() {
+    get CHILD_PREFIX_LENGTH () {
         return CHILD_PREFIX_LENGTH;
     },
-    PREFIX_LENGTH: function() {
+    get PREFIX_LENGTH () {
         return PREFIX_LENGTH;
     },
-    compactHex: function() {
+    get compactHex () {
         return compactHex;
     },
-    defer: function() {
+    get defer () {
         return defer;
     },
-    fetchKeys: function() {
+    get fetchKeys () {
         return fetchKeys;
     },
-    fetchKeysToArray: function() {
+    get fetchKeysToArray () {
         return fetchKeysToArray;
     },
-    getCurrentSlot: function() {
+    get getCurrentSlot () {
         return getCurrentSlot;
     },
-    getCurrentTimestamp: function() {
+    get getCurrentTimestamp () {
         return getCurrentTimestamp;
     },
-    getParaId: function() {
+    get getParaId () {
         return getParaId;
     },
-    getSlotDuration: function() {
+    get getSlotDuration () {
         return getSlotDuration;
     },
-    isPrefixedChildKey: function() {
+    get isPrefixedChildKey () {
         return isPrefixedChildKey;
     },
-    isUrl: function() {
+    get isUrl () {
         return isUrl;
     },
-    prefixedChildKey: function() {
+    get prefixedChildKey () {
         return prefixedChildKey;
     },
-    splitChildKey: function() {
+    get splitChildKey () {
         return splitChildKey;
     },
-    stripChildPrefix: function() {
+    get stripChildPrefix () {
         return stripChildPrefix;
     }
 });

package/dist/cjs/utils/proof.js

@@ -5,32 +5,32 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    WELL_KNOWN_KEYS: function() {
+    get WELL_KNOWN_KEYS () {
         return WELL_KNOWN_KEYS;
     },
-    dmqMqcHead: function() {
+    get dmqMqcHead () {
         return dmqMqcHead;
     },
-    hrmpChannels: function() {
+    get hrmpChannels () {
         return hrmpChannels;
     },
-    hrmpEgressChannelIndex: function() {
+    get hrmpEgressChannelIndex () {
         return hrmpEgressChannelIndex;
     },
-    hrmpIngressChannelIndex: function() {
+    get hrmpIngressChannelIndex () {
         return hrmpIngressChannelIndex;
     },
-    paraHead: function() {
+    get paraHead () {
         return paraHead;
     },
-    upgradeGoAheadSignal: function() {
+    get upgradeGoAheadSignal () {
         return upgradeGoAheadSignal;
     },
-    upgradeRestrictionSignal: function() {
+    get upgradeRestrictionSignal () {
         return upgradeRestrictionSignal;
     }
 });

package/dist/cjs/wasm-executor/index.js

@@ -5,38 +5,38 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    calculateStateRoot: function() {
+    get calculateStateRoot () {
         return calculateStateRoot;
     },
-    createProof: function() {
+    get createProof () {
         return createProof;
     },
-    decodeProof: function() {
+    get decodeProof () {
         return decodeProof;
     },
-    destroyWorker: function() {
+    get destroyWorker () {
         return destroyWorker;
     },
-    emptyTaskHandler: function() {
+    get emptyTaskHandler () {
         return emptyTaskHandler;
     },
-    getAuraSlotDuration: function() {
+    get getAuraSlotDuration () {
         return getAuraSlotDuration;
     },
-    getRuntimeVersion: function() {
+    get getRuntimeVersion () {
         return getRuntimeVersion;
     },
-    getWorker: function() {
+    get getWorker () {
         return getWorker;
     },
-    runTask: function() {
+    get runTask () {
         return runTask;
     },
-    taskHandler: function() {
+    get taskHandler () {
         return taskHandler;
     }
 });

package/dist/cjs/xcm/index.js

@@ -5,17 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    connectParachains: function() {
+    get connectParachains () {
         return connectParachains;
     },
-    connectVertical: function() {
+    get connectVertical () {
         return connectVertical;
     },
-    xcmLogger: function() {
+    get xcmLogger () {
         return xcmLogger;
     }
 });

package/dist/esm/chopsticks-provider.js

@@ -12,101 +12,12 @@ const logger = defaultLogger.child({
  * Provider for local chopsticks chain
  */ export class ChopsticksProvider {
     chain;
-    #isConnected;
-    #eventemitter;
+    #isConnected = false;
+    #eventemitter = new EventEmitter();
     #isReadyPromise;
-    #subscriptions;
+    #subscriptions = {};
     constructor(chain){
         this.chain = chain;
-        this.#isConnected = false;
-        this.#eventemitter = new EventEmitter();
-        this.#subscriptions = {};
-        this.clone = ()=>{
-            return new ChopsticksProvider(this.chain);
-        };
-        this.connect = async ()=>{
-            this.#isConnected = true;
-            this.#eventemitter.emit('connected');
-        };
-        this.disconnect = async ()=>{
-            this.#isConnected = false;
-            this.#eventemitter.emit('disconnected');
-        };
-        this.on = (type, sub)=>{
-            this.#eventemitter.on(type, sub);
-            return ()=>{
-                this.#eventemitter.removeListener(type, sub);
-            };
-        };
-        this.subscriptionManager = {
-            subscribe: (method, subid, onCancel = ()=>{})=>{
-                const sub = this.#subscriptions[subid];
-                if (sub) {
-                    sub.onCancel = onCancel;
-                }
-                return (data)=>{
-                    logger.debug('subscribe-callback', method, subid, data);
-                    const sub = this.#subscriptions[subid];
-                    if (sub) {
-                        sub.callback(null, data);
-                    } else {
-                        logger.trace(`Unable to find active subscription=${subid}`);
-                    }
-                };
-            },
-            unsubscribe: (subid)=>{
-                logger.debug('unsubscribe-callback', subid);
-                const sub = this.#subscriptions[subid];
-                if (sub) {
-                    sub.onCancel?.();
-                    delete this.#subscriptions[subid];
-                } else {
-                    logger.trace(`Unable to find active subscription=${subid}`);
-                }
-            }
-        };
-        this.send = async (method, params, _isCacheable, subscription)=>{
-            try {
-                logger.debug('send', {
-                    method,
-                    params
-                });
-                const rpcHandler = providerHandlers[method];
-                if (!rpcHandler) {
-                    logger.error(`Unable to find rpc handler=${method}`);
-                    throw new Error(`Unable to find rpc handler=${method}`);
-                }
-                if (subscription) {
-                    logger.debug('subscribe', {
-                        method,
-                        params
-                    });
-                    const subid = await rpcHandler({
-                        chain: this.chain
-                    }, params, this.subscriptionManager);
-                    if (!subid) {
-                        throw new Error(`Unable to subscribe=${method}`);
-                    }
-                    this.#subscriptions[subid] = {
-                        callback: subscription.callback,
-                        method,
-                        params,
-                        type: subscription.type
-                    };
-                    return subid;
-                }
-                logger.debug('call', {
-                    method,
-                    params
-                });
-                return rpcHandler({
-                    chain: this.chain
-                }, params, this.subscriptionManager);
-            } catch (e) {
-                logger.error('send error.', e);
-                throw e;
-            }
-        };
         this.#isReadyPromise = new Promise((resolve, reject)=>{
             this.#eventemitter.once('connected', resolve);
             this.#eventemitter.once('error', reject);
@@ -133,12 +44,92 @@ const logger = defaultLogger.child({
     get isReady() {
         return this.#isReadyPromise;
     }
-    clone;
-    connect;
-    disconnect;
-    on;
-    subscriptionManager;
-    send;
+    clone = ()=>{
+        return new ChopsticksProvider(this.chain);
+    };
+    connect = async ()=>{
+        this.#isConnected = true;
+        this.#eventemitter.emit('connected');
+    };
+    disconnect = async ()=>{
+        this.#isConnected = false;
+        this.#eventemitter.emit('disconnected');
+    };
+    on = (type, sub)=>{
+        this.#eventemitter.on(type, sub);
+        return ()=>{
+            this.#eventemitter.removeListener(type, sub);
+        };
+    };
+    subscriptionManager = {
+        subscribe: (method, subid, onCancel = ()=>{})=>{
+            const sub = this.#subscriptions[subid];
+            if (sub) {
+                sub.onCancel = onCancel;
+            }
+            return (data)=>{
+                logger.debug('subscribe-callback', method, subid, data);
+                const sub = this.#subscriptions[subid];
+                if (sub) {
+                    sub.callback(null, data);
+                } else {
+                    logger.trace(`Unable to find active subscription=${subid}`);
+                }
+            };
+        },
+        unsubscribe: (subid)=>{
+            logger.debug('unsubscribe-callback', subid);
+            const sub = this.#subscriptions[subid];
+            if (sub) {
+                sub.onCancel?.();
+                delete this.#subscriptions[subid];
+            } else {
+                logger.trace(`Unable to find active subscription=${subid}`);
+            }
+        }
+    };
+    send = async (method, params, _isCacheable, subscription)=>{
+        try {
+            logger.debug('send', {
+                method,
+                params
+            });
+            const rpcHandler = providerHandlers[method];
+            if (!rpcHandler) {
+                logger.error(`Unable to find rpc handler=${method}`);
+                throw new Error(`Unable to find rpc handler=${method}`);
+            }
+            if (subscription) {
+                logger.debug('subscribe', {
+                    method,
+                    params
+                });
+                const subid = await rpcHandler({
+                    chain: this.chain
+                }, params, this.subscriptionManager);
+                if (!subid) {
+                    throw new Error(`Unable to subscribe=${method}`);
+                }
+                this.#subscriptions[subid] = {
+                    callback: subscription.callback,
+                    method,
+                    params,
+                    type: subscription.type
+                };
+                return subid;
+            }
+            logger.debug('call', {
+                method,
+                params
+            });
+            return rpcHandler({
+                chain: this.chain
+            }, params, this.subscriptionManager);
+        } catch (e) {
+            logger.error('send error.', e);
+            throw e;
+        }
+    };
     subscribe(type, method, params, callback) {
         return this.send(method, params, false, {
             callback,

package/dist/esm/rpc/rpc-spec/chainHead_v1.js

@@ -1,3 +1,4 @@
+import { blake2AsHex } from '@polkadot/util-crypto';
 import { defaultLogger } from '../../logger.js';
 import { ResponseError } from '../shared.js';
 const logger = defaultLogger.child({
@@ -216,6 +217,23 @@ async function getDescendantValues(block, params) {
                         }
                         return null;
                     }
+                case 'hash':
+                    {
+                        const value = await block.get(sir.key);
+                        if (value) {
+                            following.get(followSubscription)?.callback({
+                                event: 'operationStorageItems',
+                                operationId,
+                                items: [
+                                    {
+                                        key: sir.key,
+                                        hash: blake2AsHex(value)
+                                    }
+                                ]
+                            });
+                        }
+                        return null;
+                    }
                 case 'descendantsValues':
                     {
                         const { items, next } = await getDescendantValues(block, {
@@ -229,6 +247,25 @@ async function getDescendantValues(block, params) {
                         });
                         return next;
                     }
+                case 'descendantsHashes':
+                    {
+                        const { items, next } = await getDescendantValues(block, {
+                            prefix: sir.key,
+                            startKey: '0x'
+                        });
+                        following.get(followSubscription)?.callback({
+                            event: 'operationStorageItems',
+                            operationId,
+                            items: items.map(({ key, value })=>({
+                                    key,
+                                    hash: value !== undefined ? blake2AsHex(value) : undefined
+                                }))
+                        });
+                        return next ? {
+                            ...next,
+                            isDescendantHashes: true
+                        } : null;
+                    }
                 case 'closestDescendantMerkleValue':
                     {
                         const followingSubscription = following.get(followSubscription);
@@ -249,10 +286,6 @@ async function getDescendantValues(block, params) {
                         });
                         return null;
                     }
-                default:
-                    // TODO
-                    console.warn(`Storage type not implemented ${sir.type}`);
-                    return null;
             }
         };
         const listResult = await Promise.all(items.map(handleStorageItemRequest));
@@ -329,7 +362,10 @@ const limitReached = {
             follower.callback({
                 event: 'operationStorageItems',
                 operationId,
-                items
+                items: params.isDescendantHashes ? items.map(({ key, value })=>({
+                        key,
+                        hash: value !== undefined ? blake2AsHex(value) : value
+                    })) : items
             });
             return next;
         };

package/dist/esm/rpc/substrate/archive.d.ts

@@ -7,5 +7,20 @@ import { type Handler } from '../shared.js';
  * @return Block extrinsics
  */
 export declare const archive_unstable_body: Handler<[HexString], HexString[]>;
+/**
+ * @param context
+ * @param params - [`blockhash`, `method`, `data` ]
+ *
+ * @return {Object} result The call result.
+ * @return {boolean} result.success Whether the call is successful.
+ * @return {string} result.value The call result.
+ */
+export declare const archive_unstable_call: Handler<[
+    HexString,
+    string,
+    HexString
+], {
+    success: boolean;
+    value: `0x${string}`;
+}>;
 export declare const archive_unstable_hashByHeight: Handler<[number | `0x${string}` | `0x${string}`[] | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
-export declare const archive_unstable_call: Handler<[`0x${string}`, `0x${string}`, `0x${string}`], `0x${string}`>;

package/dist/esm/rpc/substrate/archive.js

@@ -1,6 +1,5 @@
 import { ResponseError } from '../shared.js';
 import { chain_getBlockHash } from './chain.js';
-import { state_call } from './state.js';
 /**
  * @param context
  * @param params - [`blockhash`]
@@ -13,5 +12,24 @@ import { state_call } from './state.js';
     }
     return await block.extrinsics;
 };
+/**
+ * @param context
+ * @param params - [`blockhash`, `method`, `data` ]
+ *
+ * @return {Object} result The call result.
+ * @return {boolean} result.success Whether the call is successful.
+ * @return {string} result.value The call result.
+ */ export const archive_unstable_call = async (context, [hash, method, data])=>{
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new ResponseError(1, `Block ${hash} not found`);
+    }
+    const resp = await block.call(method, [
+        data
+    ]);
+    return {
+        success: true,
+        value: resp.result
+    };
+};
 export const archive_unstable_hashByHeight = chain_getBlockHash;
-export const archive_unstable_call = state_call;

package/dist/esm/rpc/substrate/index.d.ts

@@ -66,7 +66,10 @@ declare const handlers: {
     author_unwatchExtrinsic: import("../shared.js").Handler<[string], void>;
     author_pendingExtrinsics: import("../shared.js").Handler<void, import("@polkadot/util/types").HexString[]>;
     archive_unstable_body: import("../shared.js").Handler<[import("@polkadot/util/types").HexString], import("@polkadot/util/types").HexString[]>;
+    archive_unstable_call: import("../shared.js").Handler<[import("@polkadot/util/types").HexString, string, import("@polkadot/util/types").HexString], {
+        success: boolean;
+        value: `0x${string}`;
+    }>;
     archive_unstable_hashByHeight: import("../shared.js").Handler<[number | `0x${string}` | `0x${string}`[] | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
-    archive_unstable_call: import("../shared.js").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], `0x${string}`>;
 };
 export default handlers;

package/dist/esm/utils/key-cache.js

@@ -3,9 +3,8 @@ export default class KeyCache {
     prefixLength;
     constructor(prefixLength){
         this.prefixLength = prefixLength;
-        this.ranges = [];
     }
-    ranges;
+    ranges = [];
     feed(keys) {
         const _keys = keys.filter((key)=>key.length >= this.prefixLength);
         if (_keys.length === 0) return;