@acala-network/chopsticks-core 0.8.0-0

package/lib/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/lib/utils/set-storage.d.ts

@@ -0,0 +1,7 @@
+import { HexString } from '@polkadot/util/types';
+import { Blockchain } from '../blockchain';
+type RawStorageValues = [string, string | null][];
+type StorageConfig = Record<string, Record<string, any>>;
+export type StorageValues = RawStorageValues | StorageConfig;
+export declare const setStorage: (chain: Blockchain, storage: StorageValues, blockHash?: HexString) => Promise<HexString>;
+export {};

package/lib/utils/set-storage.js

@@ -0,0 +1,65 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 = (chain, storage, blockHash) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield chain.getBlock(blockHash);
+    if (!block)
+        throw Error(`Cannot find block ${blockHash || 'latest'}`);
+    let storageItems;
+    if (Array.isArray(storage)) {
+        storageItems = storage;
+    }
+    else {
+        storageItems = objectToStorageItems(yield block.meta, storage);
+    }
+    block.pushStorageLayer().setAll(storageItems);
+    return block.hash;
+});

package/lib/utils/time-travel.d.ts

@@ -0,0 +1,5 @@
+import { Blockchain } from '../blockchain';
+export declare const getCurrentSlot: (chain: Blockchain) => Promise<number>;
+export declare const getCurrentTimestamp: (chain: Blockchain) => Promise<number>;
+export declare const getSlotDuration: (chain: Blockchain) => Promise<number>;
+export declare const timeTravel: (chain: Blockchain, timestamp: number) => Promise<void>;

package/lib/utils/time-travel.js

@@ -0,0 +1,67 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { hexToU8a, u8aToHex } from '@polkadot/util';
+import { compactHex } from '.';
+import { getAuraSlotDuration } from '../executor';
+import { setStorage } from './set-storage';
+export const getCurrentSlot = (chain) => __awaiter(void 0, void 0, void 0, function* () {
+    const meta = yield chain.head.meta;
+    // use raw key here because some chain did not expose those storage to metadata
+    const slotRaw = meta.consts.babe
+        ? yield chain.head.get('0x1cb6f36e027abb2091cfb5110ab5087f06155b3cd9a8c9e5e9a23fd5dc13a5ed') // babe.currentSlot
+        : yield chain.head.get('0x57f8dc2f5ab09467896f47300f04243806155b3cd9a8c9e5e9a23fd5dc13a5ed'); // aura.currentSlot
+    if (!slotRaw)
+        throw new Error('Cannot find current slot');
+    return meta.registry.createType('Slot', hexToU8a(slotRaw)).toNumber();
+});
+export const getCurrentTimestamp = (chain) => __awaiter(void 0, void 0, void 0, function* () {
+    const meta = yield chain.head.meta;
+    const currentTimestampRaw = (yield chain.head.get(compactHex(meta.query.timestamp.now()))) || '0x';
+    return meta.registry.createType('u64', hexToU8a(currentTimestampRaw)).toNumber();
+});
+export const getSlotDuration = (chain) => __awaiter(void 0, void 0, void 0, function* () {
+    const meta = yield chain.head.meta;
+    return meta.consts.babe
+        ? meta.consts.babe.expectedBlockTime.toNumber()
+        : meta.query.aura
+            ? getAuraSlotDuration(yield chain.head.wasm, meta.registry)
+            : 12000;
+});
+export const timeTravel = (chain, timestamp) => __awaiter(void 0, void 0, void 0, function* () {
+    const meta = yield chain.head.meta;
+    const slotDuration = yield getSlotDuration(chain);
+    const newSlot = Math.floor(timestamp / slotDuration);
+    // new timestamp
+    const storage = [
+        [compactHex(meta.query.timestamp.now()), u8aToHex(meta.registry.createType('u64', timestamp).toU8a())],
+    ];
+    if (meta.consts.babe) {
+        // new slot
+        storage.push([
+            compactHex(meta.query.babe.currentSlot()),
+            u8aToHex(meta.registry.createType('Slot', newSlot).toU8a()),
+        ]);
+        // new epoch
+        const epochDuration = meta.consts.babe.epochDuration.toNumber();
+        const newEpoch = Math.floor(timestamp / epochDuration);
+        storage.push([
+            compactHex(meta.query.babe.epochIndex()),
+            u8aToHex(meta.registry.createType('u64', newEpoch).toU8a()),
+        ]);
+    }
+    else if (meta.query.aura) {
+        // new slot
+        storage.push([
+            compactHex(meta.query.aura.currentSlot()),
+            u8aToHex(meta.registry.createType('Slot', newSlot).toU8a()),
+        ]);
+    }
+    yield setStorage(chain, storage);
+});

package/lib/xcm/downward.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from '../blockchain';
+export declare const connectDownward: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;

package/lib/xcm/downward.js

@@ -0,0 +1,34 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { hexToU8a } from '@polkadot/util';
+import { compactHex, getParaId } from '../utils';
+import { logger } from '.';
+import { setStorage } from '../utils/set-storage';
+export const connectDownward = (relaychain, parachain) => __awaiter(void 0, void 0, void 0, function* () {
+    const meta = yield relaychain.head.meta;
+    const paraId = yield getParaId(parachain);
+    const downwardMessageQueuesKey = compactHex(meta.query.dmp.downwardMessageQueues(paraId));
+    yield relaychain.headState.subscribeStorage([downwardMessageQueuesKey], (head, pairs) => __awaiter(void 0, void 0, void 0, function* () {
+        const value = pairs[0][1];
+        if (!value)
+            return;
+        const meta = yield head.meta;
+        const downwardMessageQueuesKey = compactHex(meta.query.dmp.downwardMessageQueues(paraId));
+        // clear relaychain message queue
+        yield setStorage(relaychain, [[downwardMessageQueuesKey, null]], head.hash);
+        const downwardMessages = meta.registry
+            .createType('Vec<PolkadotCorePrimitivesInboundDownwardMessage>', hexToU8a(value))
+            .toJSON();
+        if (downwardMessages.length === 0)
+            return;
+        logger.debug({ downwardMessages }, 'downward_message');
+        parachain.submitDownwardMessages(downwardMessages);
+    }));
+});

package/lib/xcm/horizontal.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from '../blockchain';
+export declare const connectHorizontal: (parachains: Record<number, Blockchain>) => Promise<void>;

package/lib/xcm/horizontal.js

@@ -0,0 +1,34 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { hexToU8a } from '@polkadot/util';
+import { compactHex } from '../utils';
+import { logger } from '.';
+export const connectHorizontal = (parachains) => __awaiter(void 0, void 0, void 0, function* () {
+    for (const [id, chain] of Object.entries(parachains)) {
+        const meta = yield chain.head.meta;
+        const hrmpOutboundMessagesKey = compactHex(meta.query.parachainSystem.hrmpOutboundMessages());
+        yield chain.headState.subscribeStorage([hrmpOutboundMessagesKey], (head, pairs) => __awaiter(void 0, void 0, void 0, function* () {
+            const value = pairs[0][1];
+            if (!value)
+                return;
+            const meta = yield head.meta;
+            const outboundHrmpMessage = meta.registry
+                .createType('Vec<PolkadotCorePrimitivesOutboundHrmpMessage>', hexToU8a(value))
+                .toJSON();
+            logger.info({ outboundHrmpMessage }, 'outboundHrmpMessage');
+            for (const { recipient, data } of outboundHrmpMessage) {
+                const receiver = parachains[recipient];
+                if (receiver) {
+                    receiver.submitHorizontalMessages(Number(id), [{ sentAt: head.number, data }]);
+                }
+            }
+        }));
+    }
+});

package/lib/xcm/index.d.ts

@@ -0,0 +1,9 @@
+import { Blockchain } from '../blockchain';
+export declare const logger: import("pino").default.Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+}>;
+export declare const connectVertical: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;
+export declare const connectParachains: (parachains: Blockchain[]) => Promise<void>;

package/lib/xcm/index.js

@@ -0,0 +1,29 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { connectDownward } from './downward';
+import { connectHorizontal } from './horizontal';
+import { connectUpward } from './upward';
+import { defaultLogger } from '../logger';
+import { getParaId } from '../utils';
+export const logger = defaultLogger.child({ name: 'xcm' });
+export const connectVertical = (relaychain, parachain) => __awaiter(void 0, void 0, void 0, function* () {
+    yield connectDownward(relaychain, parachain);
+    yield connectUpward(parachain, relaychain);
+    logger.info(`Connected relaychain '${yield relaychain.api.getSystemChain()}' with parachain '${yield parachain.api.getSystemChain()}'`);
+});
+export const connectParachains = (parachains) => __awaiter(void 0, void 0, void 0, function* () {
+    const list = {};
+    for (const chain of parachains) {
+        const paraId = yield getParaId(chain);
+        list[paraId.toNumber()] = chain;
+    }
+    yield connectHorizontal(list);
+    logger.info(`Connected parachains [${Object.keys(list)}]`);
+});

package/lib/xcm/upward.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from '../blockchain';
+export declare const connectUpward: (parachain: Blockchain, relaychain: Blockchain) => Promise<void>;

package/lib/xcm/upward.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { hexToU8a } from '@polkadot/util';
+import { compactHex, getParaId } from '../utils';
+export const connectUpward = (parachain, relaychain) => __awaiter(void 0, void 0, void 0, function* () {
+    const meta = yield parachain.head.meta;
+    const paraId = (yield getParaId(parachain)).toNumber();
+    const upwardMessagesKey = compactHex(meta.query.parachainSystem.upwardMessages());
+    yield parachain.headState.subscribeStorage([upwardMessagesKey], (_head, pairs) => __awaiter(void 0, void 0, void 0, function* () {
+        const value = pairs[0][1];
+        if (!value)
+            return;
+        const meta = yield relaychain.head.meta;
+        const upwardMessages = meta.registry.createType('Vec<Bytes>', hexToU8a(value));
+        if (upwardMessages.length === 0)
+            return;
+        relaychain.submitUpwardMessages(paraId, upwardMessages.map((x) => x.toHex()));
+    }));
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@acala-network/chopsticks-core",
+  "version": "0.8.0-0",
+  "author": "Bryan Chen <xlchen1291@gmail.com>",
+  "license": "Apache-2.0",
+  "scripts": {
+    "clean": "rm -rf lib tsconfig.tsbuildinfo",
+    "build": "tsc -p ./tsconfig.json"
+  },
+  "dependencies": {
+    "@acala-network/chopsticks-executor": "0.8.0-0",
+    "@polkadot/api": "^10.9.1",
+    "axios": "^1.4.0",
+    "eventemitter3": "^5.0.1",
+    "localforage": "^1.10.0",
+    "lodash": "^4.17.21",
+    "pino": "^8.14.1",
+    "pino-pretty": "^10.0.1",
+    "sql.js": "^1.8.0",
+    "sqlite3": "^5.1.6",
+    "typeorm": "^0.3.17",
+    "zod": "^3.21.4"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.195",
+    "@types/sql.js": "^1",
+    "typescript": "^5.1.6"
+  },
+  "files": [
+    "lib"
+  ],
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./*": {
+      "types": "./lib/*.d.ts",
+      "default": "./lib/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "stableVersion": "0.7.3"
+}