@acala-network/chopsticks-core 0.8.5-5 → 0.9.0

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

@@ -0,0 +1,166 @@
+import { ResponseError } from '../shared';
+import { defaultLogger } from '../../logger';
+import { isPrefixedChildKey, prefixedChildKey, stripChildPrefix } from '../../utils';
+const logger = defaultLogger.child({ name: 'rpc-state' });
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return runtime version
+ */
+export const state_getRuntimeVersion = async (context, [hash]) => {
+    const block = await context.chain.getBlock(hash);
+    return block?.runtimeVersion || null;
+};
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return metadata
+ */
+export const state_getMetadata = async (context, [hash]) => {
+    const block = await context.chain.getBlock(hash);
+    return block?.metadata || null;
+};
+/**
+ * @param context
+ * @param params - [`key`, `blockhash`]
+ *
+ * @return storage value
+ */
+export const state_getStorage = async (context, [key, hash]) => {
+    const block = await context.chain.getBlock(hash);
+    const value = (await block?.get(key)) || null;
+    return value || null;
+};
+/**
+ * @param context
+ * @param params - [`prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+export const state_getKeysPaged = async (context, [prefix, pageSize, startKey, hash]) => {
+    const block = await context.chain.getBlock(hash);
+    return block?.getKeysPaged({ prefix, pageSize, startKey });
+};
+/**
+ * @param context
+ * @param params - [`keys`, `blockhash`]
+ *
+ * @return storage values
+ */
+export const state_queryStorageAt = async (context, [keys, hash]) => {
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        return [];
+    }
+    const values = await Promise.all(keys.map(async (key) => [key, await block.get(key).then((val) => val || null)]));
+    return [
+        {
+            block: block.hash,
+            changes: values,
+        },
+    ];
+};
+/**
+ * @param context
+ * @param params - [`method`, `data`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export const state_call = async (context, [method, data, hash]) => {
+    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 resp.result;
+};
+/**
+ * @return subscription id
+ */
+export const state_subscribeRuntimeVersion = async (context, _params, { subscribe }) => {
+    let update = (_block) => { };
+    const id = await context.chain.headState.subscrubeRuntimeVersion((block) => update(block));
+    const callback = subscribe('state_runtimeVersion', id);
+    update = async (block) => callback(await block.runtimeVersion);
+    setTimeout(() => {
+        context.chain.head.runtimeVersion.then(callback);
+    }, 50);
+    return id;
+};
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+export const state_unsubscribeRuntimeVersion = async (_context, [subid], { unsubscribe }) => {
+    unsubscribe(subid);
+};
+/**
+ * @param context
+ * @param params - [`keys`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export const state_subscribeStorage = async (context, [keys], { subscribe }) => {
+    let update = (_block, _pairs) => { };
+    const id = await context.chain.headState.subscribeStorage(keys, (block, pairs) => update(block, pairs));
+    const callback = subscribe('state_storage', id, () => context.chain.headState.unsubscribeStorage(id));
+    update = async (block, pairs) => {
+        logger.trace({ hash: block.hash }, 'state_subscribeStorage');
+        callback({
+            block: block.hash,
+            changes: pairs,
+        });
+    };
+    (async () => {
+        const pairs = await Promise.all(keys.map(async (key) => {
+            const val = await context.chain.head.get(key);
+            return [key, val || null];
+        }));
+        callback({
+            block: context.chain.head.hash,
+            changes: pairs,
+        });
+    })();
+    return id;
+};
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+export const state_unsubscribeStorage = async (_context, [subid], { unsubscribe }) => {
+    unsubscribe(subid);
+};
+/**
+ * @param context
+ * @param params - [`child`, `key`, `blockhash`]
+ *
+ * @return storage valuse
+ */
+export const childstate_getStorage = async (context, [child, key, hash]) => {
+    if (!isPrefixedChildKey(child)) {
+        throw new ResponseError(-32000, 'Client error: Invalid child storage key');
+    }
+    const block = await context.chain.getBlock(hash);
+    const value = await block?.get(prefixedChildKey(child, key));
+    return value || null;
+};
+/**
+ * @param context
+ * @param params - [`child`, `prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+export const childstate_getKeysPaged = async (context, [child, prefix, pageSize, startKey, hash]) => {
+    if (!isPrefixedChildKey(child)) {
+        throw new ResponseError(-32000, 'Client error: Invalid child storage key');
+    }
+    const block = await context.chain.getBlock(hash);
+    return block
+        ?.getKeysPaged({ prefix: prefixedChildKey(child, prefix), pageSize, startKey: prefixedChildKey(child, startKey) })
+        .then((keys) => keys.map(stripChildPrefix));
+};

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

@@ -0,0 +1,48 @@
+import { hexToU8a } from '@polkadot/util';
+export const system_localPeerId = async () => '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY';
+export const system_nodeRoles = async () => ['Full'];
+export const system_localListenAddresses = async () => [];
+export const system_chain = async (context) => {
+    return context.chain.api.getSystemChain();
+};
+export const system_properties = async (context) => {
+    return context.chain.api.getSystemProperties();
+};
+export const system_name = async (context) => {
+    return context.chain.api.getSystemName();
+};
+export const system_version = async (_context) => {
+    return 'chopsticks-v1';
+};
+export const system_chainType = async (_context) => {
+    return 'Development';
+};
+export const system_health = async () => {
+    return {
+        peers: 0,
+        isSyncing: false,
+        shouldHavePeers: false,
+    };
+};
+/**
+ * @param context
+ * @param params - [`extrinsic`, `at`]
+ *
+ * @return ApplyExtrinsicResult (see `@polkadot/types/interfaces`) in hash
+ */
+export const system_dryRun = async (context, [extrinsic, at]) => {
+    const { outcome } = await context.chain.dryRunExtrinsic(extrinsic, at);
+    return outcome.toHex();
+};
+/**
+ * @param context
+ * @param params - [`address`]
+ */
+export const system_accountNextIndex = async (context, [address]) => {
+    const head = context.chain.head;
+    const registry = await head.registry;
+    const account = registry.createType('AccountId', address);
+    const result = await head.call('AccountNonceApi_account_nonce', [account.toHex()]);
+    const nonce = registry.createType('Index', hexToU8a(result.result)).toNumber();
+    return nonce + context.chain.txPool.pendingExtrinsicsBy(address).length;
+};

package/dist/esm/schema/index.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export const genesisSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    properties: z.object({
+        ss58Format: z.number().optional(),
+        tokenDecimals: z.union([z.number(), z.array(z.number())]).optional(),
+        tokenSymbol: z.union([z.string(), z.array(z.string())]).optional(),
+    }),
+    genesis: z.object({ raw: z.object({ top: z.record(z.string()) }) }),
+});

package/dist/esm/setup.js

@@ -0,0 +1,71 @@
+import '@polkadot/types-codec';
+import { HttpProvider, WsProvider } from '@polkadot/rpc-provider';
+import { Api } from './api';
+import { Blockchain } from './blockchain';
+import { InherentProviders, ParaInherentEnter, SetBabeRandomness, SetNimbusAuthorInherent, SetTimestamp, SetValidationData, } from './blockchain/inherent';
+import { defaultLogger } from './logger';
+export const setup = async (options) => {
+    let provider;
+    if (options.genesis) {
+        provider = options.genesis;
+    }
+    else if (/^(https|http):\/\//.test(options.endpoint || '')) {
+        provider = new HttpProvider(options.endpoint);
+    }
+    else {
+        provider = new WsProvider(options.endpoint);
+    }
+    const api = new Api(provider);
+    await api.isReady;
+    let blockHash;
+    if (options.block == null) {
+        blockHash = await api.getBlockHash().then((hash) => {
+            if (!hash) {
+                // should not happen, but just in case
+                throw new Error('Cannot find block hash');
+            }
+            return hash;
+        });
+    }
+    else if (typeof options.block === 'string' && options.block.startsWith('0x')) {
+        blockHash = options.block;
+    }
+    else if (Number.isInteger(+options.block)) {
+        blockHash = await api.getBlockHash(Number(options.block)).then((hash) => {
+            if (!hash) {
+                throw new Error(`Cannot find block hash for ${options.block}`);
+            }
+            return hash;
+        });
+    }
+    else {
+        throw new Error(`Invalid block number or hash: ${options.block}`);
+    }
+    defaultLogger.debug({ ...options, blockHash }, 'Args');
+    const header = await api.getHeader(blockHash);
+    if (!header) {
+        throw new Error(`Cannot find header for ${blockHash}`);
+    }
+    const inherents = new InherentProviders(new SetTimestamp(), [
+        new SetValidationData(),
+        new ParaInherentEnter(),
+        new SetNimbusAuthorInherent(),
+        new SetBabeRandomness(),
+    ]);
+    return new Blockchain({
+        api,
+        buildBlockMode: options.buildBlockMode,
+        inherentProvider: inherents,
+        db: options.db,
+        header: {
+            hash: blockHash,
+            number: Number(header.number),
+        },
+        mockSignatureHost: options.mockSignatureHost,
+        allowUnresolvedImports: options.allowUnresolvedImports,
+        runtimeLogLevel: options.runtimeLogLevel,
+        registeredTypes: options.registeredTypes || {},
+        offchainWorker: options.offchainWorker,
+        maxMemoryBlockCount: options.maxMemoryBlockCount,
+    });
+};

package/dist/esm/utils/decoder.js

@@ -0,0 +1,95 @@
+import '@polkadot/types-codec';
+import { blake2AsHex } from '@polkadot/util-crypto';
+import { hexToU8a, u8aToHex } from '@polkadot/util';
+import _ from 'lodash';
+const _CACHE = {};
+const getCache = (uid) => {
+    if (!_CACHE[uid]) {
+        _CACHE[uid] = new Map();
+    }
+    return _CACHE[uid];
+};
+const getStorageEntry = (meta, block, key) => {
+    const cache = getCache(block.chain.uid);
+    for (const [prefix, storageEntry] of cache.entries()) {
+        if (key.startsWith(prefix))
+            return storageEntry;
+    }
+    for (const module of Object.values(meta.query)) {
+        for (const storage of Object.values(module)) {
+            const keyPrefix = u8aToHex(storage.keyPrefix());
+            if (key.startsWith(keyPrefix)) {
+                cache.set(keyPrefix, storage);
+                return storage;
+            }
+        }
+    }
+    return undefined;
+};
+export const decodeKey = (meta, block, key) => {
+    const storage = getStorageEntry(meta, block, key);
+    const decodedKey = meta.registry.createType('StorageKey', key);
+    if (storage) {
+        decodedKey.setMeta(storage.meta);
+        return { storage, decodedKey };
+    }
+    return {};
+};
+export const decodeKeyValue = (meta, block, key, value, toHuman = true) => {
+    const { storage, decodedKey } = decodeKey(meta, block, key);
+    if (!storage || !decodedKey) {
+        return { [key]: value };
+    }
+    const decodeValue = () => {
+        if (!value)
+            return null;
+        if (storage.section === 'substrate' && storage.method === 'code') {
+            return `:code blake2_256 ${blake2AsHex(value, 256)} (${hexToU8a(value).length} bytes)`;
+        }
+        return meta.registry.createType(decodedKey.outputType, hexToU8a(value))[toHuman ? 'toHuman' : 'toJSON']();
+    };
+    switch (decodedKey.args.length) {
+        case 2: {
+            return {
+                [storage.section]: {
+                    [storage.method]: {
+                        [decodedKey.args[0].toString()]: {
+                            [decodedKey.args[1].toString()]: decodeValue(),
+                        },
+                    },
+                },
+            };
+        }
+        case 1: {
+            return {
+                [storage.section]: {
+                    [storage.method]: {
+                        [decodedKey.args[0].toString()]: decodeValue(),
+                    },
+                },
+            };
+        }
+        default:
+            return {
+                [storage.section]: {
+                    [storage.method]: decodeValue(),
+                },
+            };
+    }
+};
+/**
+ * Decode block storage diff
+ * @param block Block to compare storage diff
+ * @param diff Storage diff
+ * @returns decoded old state and new state
+ */
+export const decodeBlockStorageDiff = async (block, diff) => {
+    const oldState = {};
+    const newState = {};
+    const meta = await block.meta;
+    for (const [key, value] of diff) {
+        _.merge(oldState, decodeKeyValue(meta, block, key, (await block.get(key))));
+        _.merge(newState, decodeKeyValue(meta, block, key, value));
+    }
+    return [oldState, newState];
+};

package/dist/esm/utils/index.js

@@ -0,0 +1,91 @@
+import { compactStripLength, u8aToHex } from '@polkadot/util';
+import { hexAddPrefix, hexStripPrefix } from '@polkadot/util/hex';
+export * from './set-storage';
+export * from './time-travel';
+export * from './decoder';
+export async function fetchKeys(getKeys, processKey) {
+    const processKeys = async (keys) => {
+        for (const key of keys) {
+            await processKey(key);
+        }
+        if (keys.length > 0) {
+            return keys[keys.length - 1];
+        }
+        return undefined;
+    };
+    const keys = await getKeys();
+    let nextKey = await processKeys(keys);
+    while (nextKey) {
+        const keys = await getKeys(nextKey.toHex());
+        nextKey = await processKeys(keys);
+    }
+}
+export async function fetchKeysToArray(getKeys) {
+    const res = [];
+    await fetchKeys(getKeys, (key) => res.push(key));
+    return res;
+}
+export const compactHex = (value) => {
+    return u8aToHex(compactStripLength(value)[1]);
+};
+export const getParaId = async (chain) => {
+    const meta = await chain.head.meta;
+    const id = await chain.head.read('u32', meta.query.parachainInfo.parachainId);
+    if (!id) {
+        throw new Error('Cannot find parachain id');
+    }
+    return id;
+};
+export const isUrl = (url) => {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+export function defer() {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+    });
+    return deferred;
+}
+// Chopsticks treats both main storage and child storage as a key-value store
+// The difference is that child storage keys are prefixed with the child storage key
+// :child_storage:default: as hex string
+const DEFAULT_CHILD_STORAGE = '0x3a6368696c645f73746f726167653a64656661756c743a';
+// length of the child storage key
+const CHILD_LENGTH = DEFAULT_CHILD_STORAGE.length + 64;
+// returns a key that is prefixed with the child storage key
+export const prefixedChildKey = (prefix, key) => prefix + hexStripPrefix(key);
+// returns true if the key is a child storage key
+export const isPrefixedChildKey = (key) => key.startsWith(DEFAULT_CHILD_STORAGE);
+// returns a key that is split into the child storage key and the rest
+export const splitChildKey = (key) => {
+    if (!key.startsWith(DEFAULT_CHILD_STORAGE))
+        return [];
+    if (key.length < CHILD_LENGTH)
+        return [];
+    const child = key.slice(0, CHILD_LENGTH);
+    const rest = key.slice(CHILD_LENGTH);
+    return [child, hexAddPrefix(rest)];
+};
+// returns a key that is stripped of the child storage key
+export const stripChildPrefix = (key) => {
+    const [child, storageKey] = splitChildKey(key);
+    if (!child)
+        return key;
+    return storageKey;
+};
+export const printRuntimeLogs = (logs) => {
+    if (!logs.length)
+        return;
+    console.group('RuntimeLogs:');
+    for (const log of logs) {
+        console.log(log);
+    }
+    console.groupEnd();
+};

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

@@ -0,0 +1,61 @@
+import _ from 'lodash';
+// 0x + 32 module + 32 method
+export const PREFIX_LENGTH = 66;
+export default class KeyCache {
+    constructor() {
+        this.ranges = [];
+    }
+    feed(keys) {
+        const _keys = keys.filter((key) => key.length >= PREFIX_LENGTH);
+        if (_keys.length === 0)
+            return;
+        const startKey = _keys[0].slice(PREFIX_LENGTH);
+        const endKey = _keys[_keys.length - 1].slice(PREFIX_LENGTH);
+        const grouped = _.groupBy(_keys, (key) => key.slice(0, PREFIX_LENGTH));
+        for (const [prefix, keys] of Object.entries(grouped)) {
+            const ranges = this.ranges.filter((range) => range.prefix === prefix);
+            if (ranges.length === 0) {
+                // no existing range with prefix
+                this.ranges.push({ prefix, keys: keys.map((i) => i.slice(PREFIX_LENGTH)) });
+                continue;
+            }
+            let merged = false;
+            for (const range of ranges) {
+                const startPosition = _.sortedIndex(range.keys, startKey);
+                if (startPosition >= 0 && range.keys[startPosition] === startKey) {
+                    // found existing range with prefix
+                    range.keys.splice(startPosition, keys.length, ...keys.map((i) => i.slice(PREFIX_LENGTH)));
+                    merged = true;
+                    break;
+                }
+                const endPosition = _.sortedIndex(range.keys, endKey);
+                if (endPosition >= 0 && range.keys[endPosition] === endKey) {
+                    // found existing range with prefix
+                    range.keys.splice(0, endPosition + 1, ...keys.map((i) => i.slice(PREFIX_LENGTH)));
+                    merged = true;
+                    break;
+                }
+            }
+            // insert new prefix with range
+            if (!merged) {
+                this.ranges.push({ prefix, keys: keys.map((i) => i.slice(PREFIX_LENGTH)) });
+            }
+        }
+        // TODO: merge ranges if they overlap
+    }
+    async next(startKey) {
+        if (startKey.length < PREFIX_LENGTH)
+            return;
+        const prefix = startKey.slice(0, PREFIX_LENGTH);
+        const key = startKey.slice(PREFIX_LENGTH);
+        for (const range of this.ranges.filter((range) => range.prefix === prefix)) {
+            const index = _.sortedIndex(range.keys, key);
+            if (range.keys[index] !== key)
+                continue;
+            const nextKey = range.keys[index + 1];
+            if (nextKey) {
+                return [prefix, nextKey].join('');
+            }
+        }
+    }
+}

package/dist/esm/utils/proof.js

@@ -0,0 +1,33 @@
+import { hexToU8a, u8aConcat, u8aToHex } from '@polkadot/util';
+import { xxhashAsU8a } from '@polkadot/util-crypto';
+export const WELL_KNOWN_KEYS = {
+    EPOCH_INDEX: '0x1cb6f36e027abb2091cfb5110ab5087f38316cbf8fa0da822a20ac1c55bf1be3',
+    CURRENT_BLOCK_RANDOMNESS: '0x1cb6f36e027abb2091cfb5110ab5087fd077dfdb8adb10f78f10a5df8742c545',
+    ONE_EPOCH_AGO_RANDOMNESS: '0x1cb6f36e027abb2091cfb5110ab5087f7ce678799d3eff024253b90e84927cc6',
+    TWO_EPOCHS_AGO_RANDOMNESS: '0x1cb6f36e027abb2091cfb5110ab5087f7a414cb008e0e61e46722aa60abdd672',
+    CURRENT_SLOT: '0x1cb6f36e027abb2091cfb5110ab5087f06155b3cd9a8c9e5e9a23fd5dc13a5ed',
+    ACTIVE_CONFIG: '0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385',
+};
+const hash = (prefix, suffix) => {
+    return u8aToHex(u8aConcat(hexToU8a(prefix), xxhashAsU8a(suffix, 64), suffix));
+};
+export const dmqMqcHead = (paraId) => {
+    const prefix = '0x63f78c98723ddc9073523ef3beefda0c4d7fefc408aac59dbfe80a72ac8e3ce5';
+    return hash(prefix, paraId.toU8a());
+};
+export const upgradeGoAheadSignal = (paraId) => {
+    const prefix = '0xcd710b30bd2eab0352ddcc26417aa1949e94c040f5e73d9b7addd6cb603d15d3';
+    return hash(prefix, paraId.toU8a());
+};
+export const hrmpIngressChannelIndex = (paraId) => {
+    const prefix = '0x6a0da05ca59913bc38a8630590f2627c1d3719f5b0b12c7105c073c507445948';
+    return hash(prefix, paraId.toU8a());
+};
+export const hrmpEgressChannelIndex = (paraId) => {
+    const prefix = '0x6a0da05ca59913bc38a8630590f2627cf12b746dcf32e843354583c9702cc020';
+    return hash(prefix, paraId.toU8a());
+};
+export const hrmpChannels = (channelId) => {
+    const prefix = '0x6a0da05ca59913bc38a8630590f2627cb6604cff828a6e3f579ca6c59ace013d';
+    return hash(prefix, channelId.toU8a());
+};

package/dist/esm/utils/set-storage.js

@@ -0,0 +1,56 @@
+import { StorageKey } from '@polkadot/types';
+import { stringCamelCase } from '@polkadot/util/string';
+import { u8aToHex } from '@polkadot/util';
+import { StorageValueKind } from '../blockchain/storage-layer';
+function objectToStorageItems(meta, storage) {
+    const storageItems = [];
+    for (const sectionName in storage) {
+        const section = storage[sectionName];
+        const pallet = meta.query[stringCamelCase(sectionName)];
+        if (!pallet)
+            throw Error(`Cannot find pallet ${sectionName}`);
+        for (const storageName in section) {
+            const storage = section[storageName];
+            if (storageName === '$removePrefix') {
+                for (const mapName of storage) {
+                    const storageEntry = pallet[stringCamelCase(mapName)];
+                    if (!storageEntry)
+                        throw Error(`Cannot find storage ${mapName} in pallet ${sectionName}`);
+                    const prefix = storageEntry.keyPrefix();
+                    storageItems.push([u8aToHex(prefix), StorageValueKind.DeletedPrefix]);
+                }
+                continue;
+            }
+            const storageEntry = pallet[stringCamelCase(storageName)];
+            if (!storageEntry)
+                throw Error(`Cannot find storage ${storageName} in pallet ${sectionName}`);
+            if (storageEntry.meta.type.isPlain) {
+                const key = new StorageKey(meta.registry, [storageEntry]);
+                const type = storageEntry.meta.modifier.isOptional ? `Option<${key.outputType}>` : key.outputType;
+                storageItems.push([key.toHex(), storage ? meta.registry.createType(type, storage).toHex() : null]);
+            }
+            else {
+                for (const [keys, value] of storage) {
+                    const key = new StorageKey(meta.registry, [storageEntry, keys]);
+                    const type = storageEntry.meta.modifier.isOptional ? `Option<${key.outputType}>` : key.outputType;
+                    storageItems.push([key.toHex(), value ? meta.registry.createType(type, value).toHex() : null]);
+                }
+            }
+        }
+    }
+    return storageItems;
+}
+export const setStorage = async (chain, storage, blockHash) => {
+    const block = await chain.getBlock(blockHash);
+    if (!block)
+        throw Error(`Cannot find block ${blockHash || 'latest'}`);
+    let storageItems;
+    if (Array.isArray(storage)) {
+        storageItems = storage;
+    }
+    else {
+        storageItems = objectToStorageItems(await block.meta, storage);
+    }
+    block.pushStorageLayer().setAll(storageItems);
+    return block.hash;
+};