moonwall 1.0.0-dev.0

package/dist/api/testing/blocks.js

@@ -0,0 +1,147 @@
+import Bottleneck from "bottleneck";
+import { createLogger } from "../../internal/logger.js";
+const logger = createLogger({ name: "test:blocks" });
+const debug = logger.debug.bind(logger);
+export async function createAndFinalizeBlock(api, parentHash, finalize = false) {
+    const startTime = Date.now();
+    // TODO: any/raw rpc request can be removed once api-augment is updated
+    const block = parentHash
+        ? await api.rpc("engine_createBlock", true, finalize, parentHash)
+        : await api.rpc("engine_createBlock", true, finalize);
+    return {
+        duration: Date.now() - startTime,
+        hash: block.hash, // toString doesn't work for block hashes
+        proofSize: block.proof_size, // TODO: casting can be removed once api-augment is updated
+    };
+}
+// Given a deposit amount, returns the amount burned (80%) and deposited to treasury (20%).
+// This is meant to precisely mimic the logic in the Moonbeam runtimes where the burn amount
+// is calculated and the treasury is treated as the remainder. This precision is important to
+// avoid off-by-one errors.
+export function calculateFeePortions(amount) {
+    const burnt = (amount * 80n) / 100n; // 20% goes to treasury
+    return { burnt, treasury: amount - burnt };
+}
+export const getBlockExtrinsic = async (api, blockHash, section, method) => {
+    const apiAt = await api.at(blockHash);
+    const [{ block }, records] = await Promise.all([
+        api.rpc.chain.getBlock(blockHash),
+        apiAt.query.system.events(),
+    ]);
+    const extIndex = block.extrinsics.findIndex((ext) => ext.method.section === section && ext.method.method === method);
+    const extrinsic = extIndex > -1 ? block.extrinsics[extIndex] : null;
+    const events = records
+        .filter(({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(extIndex))
+        .map(({ event }) => event);
+    const resultEvent = events.find((event) => event.section === "system" &&
+        (event.method === "ExtrinsicSuccess" || event.method === "ExtrinsicFailed"));
+    return { block, extrinsic, events, resultEvent };
+};
+export const getBlockTime = (signedBlock) => signedBlock.block.extrinsics.find((item) => item.method.section === "timestamp")
+    .method.args[0].toNumber();
+export const checkBlockFinalized = async (api, number) => {
+    return {
+        number,
+        //@ts-expect-error - remove once pJs exposes this
+        finalized: await api._rpcCore.provider.send("moon_isBlockFinalized", [
+            await api.rpc.chain.getBlockHash(number),
+        ]),
+    };
+};
+const fetchBlockTime = async (api, blockNum) => {
+    const hash = await api.rpc.chain.getBlockHash(blockNum);
+    const block = await api.rpc.chain.getBlock(hash);
+    return getBlockTime(block);
+};
+export const fetchHistoricBlockNum = async (api, blockNumber, targetTime) => {
+    if (blockNumber <= 1) {
+        return 1;
+    }
+    const time = await fetchBlockTime(api, blockNumber);
+    if (time <= targetTime) {
+        return blockNumber;
+    }
+    return fetchHistoricBlockNum(api, blockNumber - Math.ceil((time - targetTime) / 30_000), targetTime);
+};
+export const getBlockArray = async (api, timePeriod, bottleneck) => {
+    /**
+    @brief Returns an sequential array of block numbers from a given period of time in the past
+    @param api Connected ApiPromise to perform queries on
+    @param timePeriod Moment in the past to search until
+    @param limiter Bottleneck rate limiter to throttle requests
+    */
+    let limiter = bottleneck;
+    if (!limiter) {
+        limiter = new Bottleneck({ maxConcurrent: 10, minTime: 100 });
+    }
+    const finalizedHead = await limiter.schedule(() => api.rpc.chain.getFinalizedHead());
+    const signedBlock = await limiter.schedule(() => api.rpc.chain.getBlock(finalizedHead));
+    const lastBlockNumber = signedBlock.block.header.number.toNumber();
+    const lastBlockTime = getBlockTime(signedBlock);
+    const firstBlockTime = lastBlockTime - timePeriod;
+    debug(`Searching for the block at: ${new Date(firstBlockTime)}`);
+    const firstBlockNumber = (await limiter.wrap(fetchHistoricBlockNum)(api, lastBlockNumber, firstBlockTime));
+    const length = lastBlockNumber - firstBlockNumber;
+    return Array.from({ length }, (_, i) => firstBlockNumber + i);
+};
+export function extractWeight(weightV1OrV2) {
+    if ("isSome" in weightV1OrV2) {
+        const weight = weightV1OrV2.unwrap();
+        if ("refTime" in weight) {
+            return weight.refTime.unwrap();
+        }
+        return weight;
+    }
+    if ("refTime" in weightV1OrV2) {
+        return weightV1OrV2.refTime.unwrap();
+    }
+    return weightV1OrV2;
+}
+export function extractPreimageDeposit(request) {
+    const deposit = "deposit" in request ? request.deposit : request;
+    if ("isSome" in deposit && deposit.isSome) {
+        return {
+            accountId: deposit.unwrap()[0].toHex(),
+            amount: deposit.unwrap()[1],
+        };
+    }
+    if ("isNone" in deposit && deposit.isNone) {
+        return undefined;
+    }
+    return {
+        accountId: deposit[0].toHex(),
+        amount: deposit[1],
+    };
+}
+export function mapExtrinsics(extrinsics, records, fees) {
+    return extrinsics.map((extrinsic, index) => {
+        let dispatchError;
+        let dispatchInfo;
+        const events = records
+            .filter(({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index))
+            .map(({ event }) => {
+            if (event.section === "system") {
+                if (event.method === "ExtrinsicSuccess") {
+                    dispatchInfo = event.data[0];
+                }
+                else if (event.method === "ExtrinsicFailed") {
+                    dispatchError = event.data[0];
+                    dispatchInfo = event.data[1];
+                }
+            }
+            return event;
+        });
+        return {
+            dispatchError,
+            dispatchInfo,
+            events,
+            extrinsic,
+            fee: fees ? fees[index] : undefined,
+        };
+    });
+}
+export async function checkTimeSliceForUpgrades(api, blockNumbers, currentVersion) {
+    const apiAt = await api.at(await api.rpc.chain.getBlockHash(blockNumbers[0]));
+    const onChainRt = (await apiAt.query.system.lastRuntimeUpgrade()).unwrap().specVersion;
+    return { result: !onChainRt.eq(currentVersion), specVersion: onChainRt };
+}

package/dist/api/testing/contracts.d.ts

@@ -0,0 +1,5 @@
+import type { CompiledContract } from "../types/index.js";
+import type { Abi } from "viem";
+export declare function getAllCompiledContracts(contractsDir?: string, recurse?: boolean): string[];
+export declare function getCompiled<TAbi extends Abi>(contractPath: string): CompiledContract<TAbi>;
+//# sourceMappingURL=contracts.d.ts.map

package/dist/api/testing/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/api/testing/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,0BAA0B;AAG1D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC,wBAAgB,uBAAuB,CAAC,YAAY,SAAO,EAAE,OAAO,UAAQ,GAAG,MAAM,EAAE,CAmBtF;AAED,wBAAgB,WAAW,CAAC,IAAI,SAAS,GAAG,EAAE,YAAY,EAAE,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAc1F"}

package/dist/api/testing/contracts.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+export function getAllCompiledContracts(contractsDir = "./", recurse = false) {
+    const contractsPath = path.isAbsolute(contractsDir)
+        ? contractsDir
+        : path.join(process.cwd(), contractsDir);
+    const contracts = fs.readdirSync(contractsPath, { withFileTypes: true });
+    let contractNames = [];
+    for (const dirent of contracts) {
+        const fullDirentPath = path.join(contractsPath, dirent.name);
+        if (dirent.isDirectory() && recurse) {
+            contractNames = contractNames.concat(getAllCompiledContracts(fullDirentPath, recurse));
+        }
+        else if (dirent.isFile() && path.extname(dirent.name) === ".json") {
+            contractNames.push(path.basename(dirent.name, ".json"));
+        }
+    }
+    return contractNames;
+}
+export function getCompiled(contractPath) {
+    const filePath = path.join(process.cwd(), `${contractPath}.json`);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Contract name (${contractPath}) doesn't exist in test suite`);
+    }
+    try {
+        const json = fs.readFileSync(filePath, "utf8");
+        return JSON.parse(json);
+    }
+    catch (_error) {
+        throw new Error(`Contract name ${contractPath} is not compiled. Please check compiled json exists`);
+    }
+}

package/dist/api/testing/ethers.d.ts

@@ -0,0 +1,3 @@
+import type { GenericContext, EthersTransactionOptions } from "../types/index.js";
+export declare function createEthersTransaction<TOptions extends EthersTransactionOptions>(context: GenericContext, params: TOptions): Promise<`0x${string}`>;
+//# sourceMappingURL=ethers.d.ts.map

package/dist/api/testing/ethers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ethers.d.ts","sourceRoot":"","sources":["../../../src/api/testing/ethers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,0BAA0B;AAqClF,wBAAsB,uBAAuB,CAAC,QAAQ,SAAS,wBAAwB,EACrF,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,QAAQ,0BAqBjB"}

package/dist/api/testing/ethers.js

@@ -0,0 +1,38 @@
+import { Wallet } from "ethers";
+import { ALITH_ADDRESS } from "../constants/accounts.js";
+const transactionHandlers = {
+    legacy: (blob, params) => {
+        blob.gasPrice = params.gasPrice || "10000000000";
+        blob.gasLimit = params.gasLimit || "200000";
+        blob.type = 0;
+    },
+    eip2930: (blob, params) => {
+        blob.gasPrice = params.gasPrice || "10000000000";
+        blob.gasLimit = params.gasLimit || "200000";
+        blob.accessList = params.accessList || [];
+        blob.type = 1;
+    },
+    eip1559: (blob, params) => {
+        blob.accessList = params.accessList || [];
+        blob.maxFeePerGas = params.maxFeePerGas || "10000000000";
+        blob.maxPriorityFeePerGas = params.maxPriorityFeePerGas || 0;
+        blob.gasLimit = params.gasLimit || "200000";
+        blob.type = 2;
+    },
+};
+export async function createEthersTransaction(context, params) {
+    const nonce = "nonce" in params
+        ? params.nonce
+        : await context.viem().getTransactionCount({ address: ALITH_ADDRESS });
+    const blob = { nonce, ...params };
+    const handler = transactionHandlers[params.txnType || "legacy"];
+    if (!handler) {
+        throw new Error("Unknown transaction type, update createRawEthersTxn fn");
+    }
+    handler(blob, params);
+    const signer = params.privateKey
+        ? new Wallet(params.privateKey, context.ethers().provider)
+        : context.ethers();
+    const txn = await signer.populateTransaction(blob);
+    return (await signer.signTransaction(txn));
+}

package/dist/api/testing/events.d.ts

@@ -0,0 +1,12 @@
+import type { u128 } from "@polkadot/types-codec";
+import type { AccountId20, DispatchError, DispatchInfo, EventRecord } from "@polkadot/types/interfaces";
+export declare function filterAndApply<T>(events: EventRecord[], section: string, methods: string[], onFound: (record: EventRecord) => T): T[];
+export declare function getDispatchError({ event: { data: [dispatchError], }, }: EventRecord): DispatchError;
+export declare function extractError(events?: EventRecord[]): DispatchError | undefined;
+export declare function isExtrinsicSuccessful(events?: EventRecord[]): boolean;
+export declare function extractInfo(events?: EventRecord[]): DispatchInfo | undefined;
+export declare function extractFee(events?: EventRecord[]): {
+    who: AccountId20;
+    amount: u128;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/api/testing/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/api/testing/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,YAAY,EACZ,WAAW,EACZ,MAAM,4BAA4B,CAAC;AAEpC,wBAAgB,cAAc,CAAC,CAAC,EAC9B,MAAM,EAAE,WAAW,EAAE,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,GAClC,CAAC,EAAE,CAIL;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EAAE,EACL,IAAI,EAAE,CAAC,aAAa,CAAC,GACtB,GACF,EAAE,WAAW,GAAG,aAAa,CAE7B;AAMD,wBAAgB,YAAY,CAAC,MAAM,GAAE,WAAW,EAAO,GAAG,aAAa,GAAG,SAAS,CAElF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,WAAW,EAAO,GAAG,OAAO,CAEzE;AAED,wBAAgB,WAAW,CAAC,MAAM,GAAE,WAAW,EAAO,GAAG,YAAY,GAAG,SAAS,CAOhF;AAED,wBAAgB,UAAU,CAAC,MAAM,GAAE,WAAW,EAAO;SAKW,WAAW;YAAU,IAAI;EAExF"}

package/dist/api/testing/events.js

@@ -0,0 +1,23 @@
+export function filterAndApply(events, section, methods, onFound) {
+    return events
+        .filter(({ event }) => section === event.section && methods.includes(event.method))
+        .map((record) => onFound(record));
+}
+export function getDispatchError({ event: { data: [dispatchError], }, }) {
+    return dispatchError;
+}
+function getDispatchInfo({ event: { data, method } }) {
+    return method === "ExtrinsicSuccess" ? data[0] : data[1];
+}
+export function extractError(events = []) {
+    return filterAndApply(events, "system", ["ExtrinsicFailed"], getDispatchError)[0];
+}
+export function isExtrinsicSuccessful(events = []) {
+    return filterAndApply(events, "system", ["ExtrinsicSuccess"], () => true).length > 0;
+}
+export function extractInfo(events = []) {
+    return filterAndApply(events, "system", ["ExtrinsicFailed", "ExtrinsicSuccess"], getDispatchInfo)[0];
+}
+export function extractFee(events = []) {
+    return filterAndApply(events, "balances", ["Withdraw"], ({ event }) => event.data)[0];
+}

package/dist/api/testing/extrinsics.d.ts

@@ -0,0 +1,5 @@
+import type { SubmittableExtrinsic } from "@polkadot/api/types";
+import type { ISubmittableResult } from "@polkadot/types/types";
+import type { KeyringPair } from "@polkadot/keyring/types";
+export declare const signAndSend: (tx: SubmittableExtrinsic<"promise", ISubmittableResult>, account?: KeyringPair, nonce?: number) => Promise<unknown>;
+//# sourceMappingURL=extrinsics.d.ts.map

package/dist/api/testing/extrinsics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extrinsics.d.ts","sourceRoot":"","sources":["../../../src/api/testing/extrinsics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAG3D,eAAO,MAAM,WAAW,GACtB,IAAI,oBAAoB,CAAC,SAAS,EAAE,kBAAkB,CAAC,EACvD,UAAS,WAAmB,EAC5B,cAAU,qBAcT,CAAC"}

package/dist/api/testing/extrinsics.js

@@ -0,0 +1,10 @@
+import { alith } from "../constants/index.js";
+export const signAndSend = async (tx, account = alith, nonce = -1) => new Promise((resolve) => tx.signAndSend(account, { nonce }, ({ status }) => {
+    if (status.isInBlock) {
+        process.stdout.write("Extrinsic submitted and included in block, waiting for finalization...");
+    }
+    if (status.isFinalized) {
+        process.stdout.write("✅\n");
+        resolve(true);
+    }
+}));

package/dist/api/testing/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./blocks.js";
+export * from "./contracts.js";
+export * from "./ethers.js";
+export * from "./events.js";
+export * from "./extrinsics.js";
+export * from "./jumping.js";
+export * from "./providers.js";
+export * from "./viem.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/api/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/testing/index.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,+BAA+B;AAC/B,4BAA4B;AAC5B,4BAA4B;AAC5B,gCAAgC;AAChC,6BAA6B;AAC7B,+BAA+B;AAC/B,0BAA0B"}

package/dist/api/testing/index.js

@@ -0,0 +1,8 @@
+export * from "./blocks.js";
+export * from "./contracts.js";
+export * from "./ethers.js";
+export * from "./events.js";
+export * from "./extrinsics.js";
+export * from "./jumping.js";
+export * from "./providers.js";
+export * from "./viem.js";

package/dist/api/testing/jumping.d.ts

@@ -0,0 +1,8 @@
+import type { ApiPromise } from "@polkadot/api";
+export declare function jumpBlocksDev(polkadotJsApi: ApiPromise, blocks: number): Promise<void>;
+export declare function jumpRoundsDev(polkadotJsApi: ApiPromise, count: number): Promise<string | null>;
+export declare function jumpToRoundDev(polkadotJsApi: ApiPromise, round: number): Promise<string | null>;
+export declare function jumpRoundsChopsticks(polkadotJsApi: ApiPromise, port: number, count: number): Promise<string>;
+export declare function jumpToRoundChopsticks(polkadotJsApi: ApiPromise, port: number, round: number): Promise<string>;
+export declare function jumpBlocksChopsticks(port: number, blockCount: number): Promise<string>;
+//# sourceMappingURL=jumping.d.ts.map

package/dist/api/testing/jumping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jumping.d.ts","sourceRoot":"","sources":["../../../src/api/testing/jumping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAOhD,wBAAsB,aAAa,CAAC,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAO5E;AAED,wBAAsB,aAAa,CACjC,aAAa,EAAE,UAAU,EACzB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAOxB;AAED,wBAAsB,cAAc,CAAC,aAAa,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,0BAiB5E;AAoBD,wBAAsB,oBAAoB,CAAC,aAAa,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,mBAMhG;AAED,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,UAAU,EACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,mBAId;AAED,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,mBAE1E"}

package/dist/api/testing/jumping.js

@@ -0,0 +1,78 @@
+import WebSocket from "ws";
+//**************************
+// DEV
+//**************************
+export async function jumpBlocksDev(polkadotJsApi, blocks) {
+    let blockCount = blocks;
+    while (blockCount > 0) {
+        await polkadotJsApi.rpc.engine.createBlock(true, true);
+        blockCount--;
+    }
+}
+export async function jumpRoundsDev(polkadotJsApi, count) {
+    // Calculate the number of blocks to create via arithmetic
+    const round = (await polkadotJsApi.query.parachainStaking.round()).current
+        .addn(count.valueOf())
+        .toNumber();
+    return jumpToRoundDev(polkadotJsApi, round);
+}
+export async function jumpToRoundDev(polkadotJsApi, round) {
+    // Calculate the number of blocks to create via arithmetic
+    let lastBlockHash = "";
+    for (;;) {
+        const currentRound = (await polkadotJsApi.query.parachainStaking.round()).current.toNumber();
+        if (currentRound === round) {
+            return lastBlockHash;
+        }
+        if (currentRound > round) {
+            return null;
+        }
+        lastBlockHash = (await polkadotJsApi.rpc.engine.createBlock(true, true)).blockHash.toString();
+    }
+}
+//**************************
+// CHOPSTICKS
+//**************************
+async function calculateBlocks(polkadotJsApi, targetRound) {
+    const roundInfo = (await polkadotJsApi.query.parachainStaking.round());
+    if (roundInfo.current.toNumber() >= targetRound) {
+        return 0;
+    }
+    const roundsToJump = targetRound - roundInfo.current.toNumber();
+    const heightToJump = roundInfo.first.toNumber() + roundsToJump * roundInfo.length.toNumber();
+    const currentBlock = (await polkadotJsApi.rpc.chain.getHeader()).number.toNumber();
+    return heightToJump - currentBlock;
+}
+export async function jumpRoundsChopsticks(polkadotJsApi, port, count) {
+    const round = (await polkadotJsApi.query.parachainStaking.round()).current
+        .addn(count.valueOf())
+        .toNumber();
+    return jumpToRoundChopsticks(polkadotJsApi, port, round);
+}
+export async function jumpToRoundChopsticks(polkadotJsApi, port, round) {
+    const blockToJump = await calculateBlocks(polkadotJsApi, round);
+    return jumpBlocksChopsticks(port, blockToJump);
+}
+export async function jumpBlocksChopsticks(port, blockCount) {
+    return await sendNewBlockCmd(port, blockCount);
+}
+const sendNewBlockCmd = async (port, count = 1) => {
+    const websocketUrl = `ws://127.0.0.1:${port}`;
+    const socket = new WebSocket(websocketUrl);
+    const result = await new Promise((resolve) => {
+        socket.on("open", () => {
+            socket.send(JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "dev_newBlock",
+                params: [{ count }],
+            }));
+        });
+        socket.on("message", (chunk) => {
+            const data = JSON.parse(chunk.toString());
+            resolve(data.result);
+            socket.close();
+        });
+    });
+    return result;
+};

package/dist/api/testing/providers.d.ts

@@ -0,0 +1,18 @@
+import type { Web3 } from "web3";
+export declare function customWeb3Request(web3: Web3, method: string, params: any[]): Promise<unknown>;
+export interface Web3EthCallOptions {
+    from?: string | number;
+    to: string;
+    value?: number | string | bigint;
+    gas?: number | string;
+    gasPrice?: number | string | bigint;
+    maxPriorityFeePerGas?: number | string | bigint;
+    maxFeePerGas?: number | string | bigint;
+    data?: string;
+    nonce?: number;
+}
+export declare function web3EthCall(web3: Web3, options: Web3EthCallOptions): Promise<unknown>;
+export type EnhancedWeb3 = Web3 & {
+    customRequest: (method: string, params: any[]) => Promise<any>;
+};
+//# sourceMappingURL=providers.d.ts.map

package/dist/api/testing/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../../src/api/testing/providers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAIjC,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,oBAwBhF;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACjC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACpC,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAChD,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,kBAAkB,oBAWxE;AAED,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG;IAChC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CAChE,CAAC"}

package/dist/api/testing/providers.js

@@ -0,0 +1,34 @@
+import { alith } from "../constants/accounts.js";
+import { MIN_GAS_PRICE } from "../constants/chain.js";
+export async function customWeb3Request(web3, method, params) {
+    return new Promise((resolve, reject) => {
+        web3.eth.currentProvider.send({
+            jsonrpc: "2.0",
+            id: 1,
+            method,
+            params,
+        }, (error, result) => {
+            if (error) {
+                reject(`Failed to send custom request (${method} (${params
+                    .map((p) => {
+                    const str = p.toString();
+                    return str.length > 128 ? `${str.slice(0, 96)}...${str.slice(-28)}` : str;
+                })
+                    .join(",")})): ${error.message || error.toString()}`);
+            }
+            resolve(result);
+        });
+    });
+}
+export async function web3EthCall(web3, options) {
+    return await customWeb3Request(web3, "eth_call", [
+        {
+            from: options.from === undefined ? options.from : alith.address,
+            value: options.value,
+            gas: options.gas === undefined ? options.gas : 256000,
+            gasPrice: options.gas === undefined ? options.gas : `0x${MIN_GAS_PRICE}`,
+            to: options.to,
+            data: options.data,
+        },
+    ]);
+}

package/dist/api/testing/viem.d.ts

@@ -0,0 +1,139 @@
+import type { ContractDeploymentOptions, DeepPartial, DevModeContext, GenericContext, ViemTransactionOptions } from "../types/index.js";
+import type { Abi } from "viem";
+import { type BlockTag, type TransactionSerializable } from "viem";
+/**
+ * @name getDevChain
+ * @description This function returns a development chain object for Moonbeam.
+ * @param url - The WebSocket URL of the development chain.
+ *
+ * @returns Returns an object that represents the Moonbeam development chain.
+ * The object includes properties such as the chain's ID, name, network, native currency, and RPC URLs.
+ *
+ * @property id - The ID of the development chain. For Moonbeam Dev, this is 1281.
+ * @property name - The name of the development chain. For this function, it's "Moonbeam Dev".
+ * @property network - The network name of the development chain. For this function, it's "moonbeam".
+ * @property nativeCurrency - An object containing the native currency's details:
+ *      - decimals: The number of decimal places the native currency supports.
+ *      - name: The name of the native currency. For Moonbeam Dev, it's "Glimmer".
+ *      - symbol: The symbol of the native currency. For Moonbeam Dev, it's "GLMR".
+ * @property rpcUrls - An object that includes the RPC URLs for the chain:
+ *      - public: The public HTTP URL(s) for the chain.
+ *      - default: The default HTTP URL(s) for the chain.
+ */
+export declare function getDevChain(url: string): Promise<{
+    readonly id: 1281;
+    readonly name: "Moonbeam Dev";
+    readonly nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Glimmer";
+        readonly symbol: "GLMR";
+    };
+    readonly rpcUrls: {
+        readonly public: {
+            http: string[];
+        };
+        readonly default: {
+            http: string[];
+        };
+    };
+}>;
+/**
+ * Derives a Viem chain object from a given HTTP endpoint.
+ *
+ * @export
+ * @param endpoint The endpoint for the JSON RPC requests.
+ * @param maxRetries Maximum number of retry attempts (default: 3)
+ * @returns A promise that resolves to an object satisfying the Chain interface, which includes
+ * properties such as the chain id, chain name, network name, native currency information,
+ * and RPC URLs.
+ * @throws Will throw an error if the RPC request fails after all retries.
+ * @example
+ * const chain = await deriveViemChain('http://localhost:8545');
+ */
+export declare function deriveViemChain(endpoint: string, maxRetries?: number): Promise<{
+    readonly id: number;
+    readonly name: any;
+    readonly nativeCurrency: {
+        readonly decimals: any;
+        readonly name: any;
+        readonly symbol: any;
+    };
+    readonly rpcUrls: {
+        readonly public: {
+            http: string[];
+        };
+        readonly default: {
+            http: string[];
+        };
+    };
+}>;
+/**
+ * @name deployViemContract
+ * @description This function deploys a contract to the Moonbeam development chain.
+ * @param context - The DevModeContext object.
+ * @param abi - The Application Binary Interface (ABI) of the contract.
+ * @param bytecode - The compiled bytecode of the contract.
+ * @param privateKey - The private key used for the deployment transaction (defaults to ALITH_PRIVATE_KEY).
+ *
+ * @returns Returns an object containing the deployed contract's address, the transaction status, and any logs.
+ *
+ * @throws This function will throw an error if the contract deployment fails.
+ *
+ * @async This function returns a Promise that resolves when the contract has been successfully deployed.
+ *
+ * @property contractAddress - The address of the deployed contract.
+ * @property status - The status of the contract deployment transaction.
+ * @property logs - Any logs produced during the contract deployment transaction.
+ */
+export declare function deployViemContract<TOptions extends ContractDeploymentOptions>(context: DevModeContext, abi: Abi, bytecode: `0x${string}`, options?: TOptions): Promise<{
+    contractAddress: `0x${string}` | null | undefined;
+    status: "success" | "reverted";
+    logs: import("viem").Log<bigint, number, false>[];
+    hash: `0x${string}`;
+}>;
+export type InputAmountFormats = number | bigint | string | `0x${string}`;
+export type TransferOptions = (Omit<TransactionSerializable, "to" | "value"> & {
+    privateKey?: `0x${string}`;
+}) | undefined;
+/**
+ * createRawTransfer function creates and signs a transfer, as a hex string, that can be submitted to the network via public client."
+ *
+ * @export
+ * @template TOptions - Optional parameters of Viem's TransferOptions
+ * @param {DevModeContext} context - the DevModeContext instance
+ * @param {`0x${string}`} to - the destination address of the transfer
+ * @param {InputAmountFormats} value - the amount to transfer. It accepts different formats including number, bigint, string or hexadecimal strings
+ * @param {TOptions} [options] - (optional) additional transaction options
+ * @returns {Promise<`0x${string}`>} - the signed raw transaction in hexadecimal string format
+ */
+export declare function createRawTransfer<TOptions extends TransferOptions>(context: DevModeContext, to: `0x${string}`, value: InputAmountFormats, options?: TOptions): Promise<`0x${string}`>;
+/**
+ * createViemTransaction function creates and signs a raw transaction, as a hex string, that can be submitted to the network via public client."
+ *
+ * @export
+ * @template TOptions - Optional parameters of Viem's TransactionOptions
+ * @param {GenericContext} context - the GenericContext instance
+ * @param {TOptions} options - transaction options including type, privateKey, value, to, chainId, gasPrice, estimatedGas, accessList, data
+ * @returns {Promise<string>} - the signed raw transaction in hexadecimal string format
+ */
+export declare function createViemTransaction<TOptions extends DeepPartial<ViemTransactionOptions>>(context: GenericContext, options: TOptions): Promise<`0x${string}`>;
+/**
+ * checkBalance function checks the balance of a given account.
+ *
+ * @export
+ * @param {DevModeContext} context - the DevModeContext instance
+ * @param {`0x${string}`} [account=ALITH_ADDRESS] - the account address whose balance is to be checked. If no account is provided, it defaults to ALITH_ADDRESS
+ * @returns {Promise<bigint>} - returns a Promise that resolves to the account's balance as a BigInt
+ */
+export declare function checkBalance(context: DevModeContext, account?: `0x${string}`, block?: BlockTag | bigint): Promise<bigint>;
+/**
+ * Sends a raw signed transaction on to RPC node for execution.
+ *
+ * @async
+ * @function
+ * @param {GenericContext} context - The DevModeContext for the Ethereum client interaction.
+ * @param {`0x${string}`} rawTx - The signed and serialized hexadecimal transaction string.
+ * @returns {Promise<any>} A Promise resolving when the transaction is sent or rejecting with an error.
+ */
+export declare function sendRawTransaction(context: GenericContext, rawTx: `0x${string}`): Promise<`0x${string}`>;
+//# sourceMappingURL=viem.d.ts.map

package/dist/api/testing/viem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["../../../src/api/testing/viem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EACzB,WAAW,EACX,cAAc,EACd,cAAc,EACd,sBAAsB,EACvB,0BAA0B;AAC3B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAChC,OAAO,EACL,KAAK,QAAQ,EAEb,KAAK,uBAAuB,EAI7B,MAAM,MAAM,CAAC;AAOd;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;GAiB5C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,GAAE,MAAU;;;;;;;;;;;;;;;;GA2C7E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,SAAS,yBAAyB,EAEjF,OAAO,EAAE,cAAc,EACvB,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,KAAK,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,QAAQ;;;;;GAoCnB;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,MAAM,EAAE,CAAC;AAE1E,MAAM,MAAM,eAAe,GACvB,CAAC,IAAI,CAAC,uBAAuB,EAAE,IAAI,GAAG,OAAO,CAAC,GAAG;IAC/C,UAAU,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;CAC5B,CAAC,GACF,SAAS,CAAC;AAEd;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,SAAS,eAAe,EACtE,OAAO,EAAE,cAAc,EACvB,EAAE,EAAE,KAAK,MAAM,EAAE,EACjB,KAAK,EAAE,kBAAkB,EACzB,OAAO,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAOxB;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,SAAS,WAAW,CAAC,sBAAsB,CAAC,EAC9F,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CA4DxB;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,OAAO,GAAE,KAAK,MAAM,EAAkB,EACtC,KAAK,GAAE,QAAQ,GAAG,MAAiB,GAClC,OAAO,CAAC,MAAM,CAAC,CAMjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,KAAK,MAAM,EAAE,GACnB,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAExB"}