@lunatest/core 0.1.0 → 0.1.1

package/dist/presets/wallet/demo_sepolia.lua

@@ -0,0 +1,66 @@
+return {
+  manifest = {
+    id = "demo_sepolia",
+    label = "Demo Sepolia Wallet",
+    description = "Seeded Luna Wallet for Sepolia demos.",
+    kind = "wallet",
+    supportedChains = { 11155111 },
+    defaultSession = {
+      enabled = false,
+      connected = false,
+      chainId = "0xaa36a7",
+      accounts = { "0x1111111111111111111111111111111111111111" },
+      permissions = {},
+      assets = {
+        nativeBalance = "1",
+        tokens = {},
+      },
+    },
+    paramsSchema = {
+      {
+        key = "address",
+        label = "Address",
+        type = "address",
+        required = true,
+        default = "0x1111111111111111111111111111111111111111",
+      },
+      {
+        key = "chainId",
+        label = "Chain",
+        type = "chainId",
+        required = true,
+        default = 11155111,
+        options = { 11155111 },
+      },
+      {
+        key = "nativeBalance",
+        label = "Native Balance",
+        type = "string",
+        default = "1",
+      },
+    },
+    recommendedControls = { "address", "nativeBalance" },
+  },
+
+  materialize = function(params)
+    local address = params.address or "0x1111111111111111111111111111111111111111"
+    local chainId = tonumber(params.chainId or 11155111)
+    local nativeBalance = tostring(params.nativeBalance or "1")
+
+    return {
+      resolvedParams = {
+        address = address,
+        chainId = chainId,
+        nativeBalance = nativeBalance,
+      },
+      defaultSession = {
+        chainId = string.format("0x%x", chainId),
+        accounts = { address },
+        assets = {
+          nativeBalance = nativeBalance,
+          tokens = {},
+        },
+      },
+    }
+  end,
+}

package/dist/presets/wallet/empty_wallet.lua

@@ -0,0 +1,54 @@
+return {
+  manifest = {
+    id = "empty_wallet",
+    label = "Empty Wallet",
+    description = "Disconnected or zero-state wallet baseline.",
+    kind = "wallet",
+    supportedChains = { 1, 11155111 },
+    defaultSession = {
+      enabled = false,
+      connected = false,
+      chainId = "0x1",
+      accounts = { "0x1111111111111111111111111111111111111111" },
+      permissions = {},
+      assets = {
+        nativeBalance = "0",
+        tokens = {},
+      },
+    },
+    paramsSchema = {
+      {
+        key = "address",
+        label = "Address",
+        type = "address",
+        required = true,
+        default = "0x1111111111111111111111111111111111111111",
+      },
+      {
+        key = "chainId",
+        label = "Chain",
+        type = "chainId",
+        required = true,
+        default = 1,
+        options = { 1, 11155111 },
+      },
+    },
+    recommendedControls = { "address", "chainId" },
+  },
+
+  materialize = function(params)
+    local address = params.address or "0x1111111111111111111111111111111111111111"
+    local chainId = tonumber(params.chainId or 1)
+
+    return {
+      resolvedParams = {
+        address = address,
+        chainId = chainId,
+      },
+      defaultSession = {
+        chainId = string.format("0x%x", chainId),
+        accounts = { address },
+      },
+    }
+  end,
+}

package/dist/provider/luna-provider.d.ts

@@ -1,3 +1,4 @@
+import { type LunaWalletSession } from "@lunatest/contracts";
 export type Eip1193Request = {
     method: string;
     params?: unknown[];
@@ -6,6 +7,7 @@ export type LunaProviderOptions = {
     chainId?: string;
     accounts?: string[];
     balances?: Record<string, string>;
+    wallet?: Partial<LunaWalletSession>;
     callHandler?: (input: Record<string, unknown>) => Promise<string> | string;
 };
 type ProviderListener = (...args: unknown[]) => void;
@@ -13,6 +15,7 @@ export declare class LunaProvider {
     private chainId;
     private accounts;
     private balances;
+    private wallet;
     private callHandler?;
     private txCounter;
     private subCounter;

package/dist/provider/luna-provider.js

@@ -1,10 +1,9 @@
-function normalizeAddress(value) {
-    return value.toLowerCase();
-}
+import { createLunaWalletSession, extractPermissionKeys, normalizeAddress, normalizeWalletPermissions, } from "@lunatest/contracts";
 export class LunaProvider {
     chainId;
     accounts;
     balances;
+    wallet;
     callHandler;
     txCounter;
     subCounter;
@@ -17,6 +16,14 @@ export class LunaProvider {
             normalizeAddress(key),
             value,
         ]));
+        this.wallet = createLunaWalletSession({
+            chainId: options.wallet?.chainId ?? this.chainId,
+            accounts: options.wallet?.accounts ?? this.accounts,
+            connected: options.wallet?.connected ??
+                (options.wallet ? false : this.accounts.length > 0),
+            enabled: options.wallet?.enabled ?? true,
+            permissions: options.wallet?.permissions,
+        });
         this.callHandler = options.callHandler;
         this.txCounter = 1n;
         this.subCounter = 1;
@@ -52,10 +59,35 @@ export class LunaProvider {
     async request(payload) {
         const method = payload.method;
         if (method === "eth_chainId") {
-            return this.chainId;
+            return this.wallet.enabled ? this.wallet.chainId : this.chainId;
         }
         if (method === "eth_accounts") {
-            return this.accounts;
+            if (!this.wallet.enabled) {
+                return this.accounts;
+            }
+            const hasAccountsPermission = this.wallet.permissions.some((permission) => permission.parentCapability === "eth_accounts");
+            if (!this.wallet.connected || !hasAccountsPermission) {
+                return [];
+            }
+            return [...this.wallet.accounts];
+        }
+        if (method === "eth_requestAccounts") {
+            const previousAccounts = this.wallet.connected
+                ? [...this.wallet.accounts]
+                : [];
+            this.wallet.connected = true;
+            this.wallet.permissions = normalizeWalletPermissions([
+                ...this.wallet.permissions,
+                "eth_accounts",
+            ]);
+            this.accounts = [...this.wallet.accounts];
+            this.emit("accountsChanged", [...this.wallet.accounts]);
+            if (previousAccounts.length === 0 && this.wallet.accounts.length > 0) {
+                this.emit("connect", {
+                    chainId: this.wallet.chainId,
+                });
+            }
+            return [...this.wallet.accounts];
         }
         if (method === "eth_getBalance") {
             const [address] = payload.params ?? [];
@@ -104,9 +136,38 @@ export class LunaProvider {
                 throw new Error("wallet_switchEthereumChain requires chainId");
             }
             this.chainId = chainId;
+            this.wallet.chainId = chainId;
             this.emit("chainChanged", chainId);
             return null;
         }
+        if (method === "wallet_requestPermissions") {
+            const keys = extractPermissionKeys(payload.params);
+            this.wallet.permissions = normalizeWalletPermissions([
+                ...this.wallet.permissions,
+                ...keys,
+            ]);
+            if (keys.includes("eth_accounts")) {
+                this.wallet.connected = true;
+                this.accounts = [...this.wallet.accounts];
+                this.emit("accountsChanged", [...this.wallet.accounts]);
+            }
+            return [...this.wallet.permissions];
+        }
+        if (method === "wallet_getPermissions") {
+            return [...this.wallet.permissions];
+        }
+        if (method === "wallet_revokePermissions") {
+            const keys = new Set(extractPermissionKeys(payload.params));
+            const revoked = this.wallet.permissions.filter((permission) => keys.has(permission.parentCapability));
+            this.wallet.permissions = this.wallet.permissions.filter((permission) => !keys.has(permission.parentCapability));
+            if (keys.has("eth_accounts")) {
+                this.wallet.connected = false;
+                this.emit("accountsChanged", []);
+            }
+            return revoked.map((permission) => ({
+                parentCapability: permission.parentCapability,
+            }));
+        }
         if (method === "eth_subscribe") {
             const id = `0xsub${this.subCounter.toString(16).padStart(4, "0")}`;
             this.subCounter += 1;

package/dist/runner/assert.js

@@ -2,7 +2,29 @@ function format(value) {
     return JSON.stringify(value, null, 2);
 }
 function deepEqual(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+            return false;
+        }
+        return left.every((item, index) => deepEqual(item, right[index]));
+    }
+    if (typeof left === "object" &&
+        left !== null &&
+        typeof right === "object" &&
+        right !== null) {
+        const leftRecord = left;
+        const rightRecord = right;
+        const leftKeys = Object.keys(leftRecord).sort();
+        const rightKeys = Object.keys(rightRecord).sort();
+        if (!deepEqual(leftKeys, rightKeys)) {
+            return false;
+        }
+        return leftKeys.every((key) => deepEqual(leftRecord[key], rightRecord[key]));
+    }
+    return false;
 }
 function buildResult(expected, actual) {
     const pass = deepEqual(expected, actual);

package/dist/runtime/bridge.js

@@ -14,6 +14,9 @@ function isPlainObject(value) {
         Object.getPrototypeOf(value) === Object.prototype);
 }
 function cloneSupported(value) {
+    if (value === undefined) {
+        return undefined;
+    }
     if (value === null ||
         typeof value === "string" ||
         typeof value === "number" ||
@@ -21,13 +24,18 @@ function cloneSupported(value) {
         return value;
     }
     if (Array.isArray(value)) {
-        return value.map((item) => cloneSupported(item));
+        return value.map((item) => {
+            if (item === undefined) {
+                throw new Error("Unsupported value type in array: undefined");
+            }
+            return cloneSupported(item);
+        });
     }
     if (isPlainObject(value)) {
         const cloned = {};
         for (const [key, nested] of Object.entries(value)) {
             if (nested === undefined) {
-                throw new Error(`Unsupported value type at ${key}: undefined`);
+                continue;
             }
             Object.defineProperty(cloned, key, {
                 value: cloneSupported(nested),

package/dist/runtime/engine.js

@@ -54,8 +54,9 @@ export async function createRuntime(rawOptions = {}) {
                 throw new Error(`Function not found: ${targetName}`);
             }
             const normalizedArgs = toLuaArgs(args);
-            const orderedArgs = Object.values(normalizedArgs);
-            const result = await Promise.resolve(target(...orderedArgs));
+            const result = isPlainObject(normalizedArgs) && Object.keys(normalizedArgs).length === 0
+                ? await Promise.resolve(target())
+                : await Promise.resolve(target(normalizedArgs));
             return fromLuaValue(result);
         },
         register(name, hostFn) {
@@ -83,3 +84,6 @@ export async function createRuntime(rawOptions = {}) {
         },
     };
 }
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/runtime/scenario-runtime.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { CoverageMetadata } from "@lunatest/contracts";
 import { type RouteMock } from "@lunatest/contracts";
 export type { RouteMock } from "@lunatest/contracts";
 export declare const LuaConfigSchema: z.ZodObject<{
@@ -11,6 +12,12 @@ export declare const LuaConfigSchema: z.ZodObject<{
     when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     then_ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     then_state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    not_present: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    coverage: z.ZodOptional<z.ZodObject<{
+        features: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        states: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        components: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
     intercept: z.ZodOptional<z.ZodObject<{
         routes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             endpointType: z.ZodLiteral<"ethereum">;
@@ -58,6 +65,7 @@ export declare const LuaConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$loose>;
 export type LuaConfig = z.infer<typeof LuaConfigSchema>;
+export type { CoverageMetadata };
 export type ScenarioRuntime = {
     getConfig: () => LuaConfig;
     getRouteMocks: () => RouteMock[];

package/dist/runtime/scenario-runtime.js

@@ -1,6 +1,13 @@
 import { z } from "zod";
 import { deepClone, deepMerge } from "@lunatest/contracts";
 const StringRecordSchema = z.record(z.string(), z.unknown());
+const CoverageMetadataSchema = z
+    .object({
+    features: z.array(z.string().min(1)).optional(),
+    states: z.array(z.string().min(1)).optional(),
+    components: z.array(z.string().min(1)).optional(),
+})
+    .partial();
 const EthereumRouteSchema = z.object({
     endpointType: z.literal("ethereum"),
     method: z.string().min(1),
@@ -69,6 +76,8 @@ export const LuaConfigSchema = z
     when: StringRecordSchema.optional(),
     then_ui: StringRecordSchema.optional(),
     then_state: StringRecordSchema.optional(),
+    not_present: z.array(z.string().min(1)).optional(),
+    coverage: CoverageMetadataSchema.optional(),
     intercept: z
         .object({
         routes: z.array(RouteMockSchema).optional(),

package/dist/scenario/index.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { CoverageMetadata } from "@lunatest/contracts";
 declare const StageSchema: z.ZodObject<{
     name: z.ZodString;
     on: z.ZodOptional<z.ZodString>;
@@ -17,9 +18,15 @@ declare const ScenarioSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     not_present: z.ZodOptional<z.ZodArray<z.ZodString>>;
     timing_ms: z.ZodOptional<z.ZodNumber>;
+    coverage: z.ZodOptional<z.ZodObject<{
+        features: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        states: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        components: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
 }, z.core.$loose>;
 export type ScenarioStage = z.infer<typeof StageSchema>;
 export type ParsedScenario = z.infer<typeof ScenarioSchema>;
+export type { CoverageMetadata };
 export type StageMachine = {
     current: () => ScenarioStage;
     next: () => ScenarioStage;
@@ -40,4 +47,3 @@ export type VirtualClock = {
 export declare function parseScenario(input: unknown): ParsedScenario;
 export declare function createStageMachine(stages: ScenarioStage[]): StageMachine;
 export declare function createVirtualClock(initialMs?: number): VirtualClock;
-export {};

package/dist/scenario/index.js

@@ -1,5 +1,12 @@
 import { z } from "zod";
 const RecordValueSchema = z.record(z.string(), z.unknown());
+const CoverageMetadataSchema = z
+    .object({
+    features: z.array(z.string().min(1)).optional(),
+    states: z.array(z.string().min(1)).optional(),
+    components: z.array(z.string().min(1)).optional(),
+})
+    .partial();
 const StageSchema = z.object({
     name: z.string().min(1),
     on: z.string().min(1).optional(),
@@ -18,6 +25,7 @@ const ScenarioSchema = z
     stages: z.array(StageSchema).optional(),
     not_present: z.array(z.string().min(1)).optional(),
     timing_ms: z.number().int().nonnegative().optional(),
+    coverage: CoverageMetadataSchema.optional(),
 })
     .passthrough();
 export function parseScenario(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunatest/core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -11,6 +11,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js",
+      "default": "./dist/browser.js"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -28,9 +33,14 @@
   "devDependencies": {
     "fast-check": "^4.5.3"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/songforthemute/lunatest",
+    "directory": "packages/core"
+  },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node ./scripts/copy-preset-assets.mjs",
     "test": "vitest run",
-    "lint": "tsc -p tsconfig.json --noEmit"
+    "lint": "tsc -p tsconfig.lint.json --pretty false"
   }
 }