Snap testing

Author: feruzm

packages/snap/README.md

@@ -0,0 +1,47 @@
+# @ecency/snap
+
+MetaMask Snap providing multi-chain wallet capabilities powered by
+[`@ecency/wallets`](../wallets).
+
+## Installation
+
+```bash
+yarn add @ecency/snap
+```
+
+Add the snap to MetaMask using a local manifest or bundle produced by
+`yarn workspace @ecency/snap build`.
+
+## Usage
+
+The snap exposes several RPC methods:
+
+- `initialize` – store a BIP39 mnemonic inside the snap.
+- `unlock` – validate and unlock previously stored mnemonic.
+- `getAddress` – return a public address for a given chain (`HIVE`, `BTC`, `ETH`, etc.).
+- `signHiveTx` – sign a Hive transaction with the active key.
+- `signExternalTx` – sign transactions for external chains via `signExternalTx` from
+  `@ecency/wallets`.
+- `getBalance` – query balances using `useGetExternalWalletBalanceQuery` (todo: integrate).
+
+Example from a dApp:
+
+```ts
+const result = await window.ethereum.request({
+  method: 'wallet_invokeSnap',
+  params: {
+    snapId: 'local:@ecency/snap',
+    request: {
+      method: 'getAddress',
+      params: { chain: 'HIVE' }
+    }
+  }
+});
+```
+
+## Security considerations
+
+The mnemonic phrase is stored inside the snap's managed state. Snaps run in an
+isolated environment, but any state stored by the snap is persisted on the
+user's machine. Avoid exposing the mnemonic and consider encrypting state in
+production deployments.

packages/snap/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@ecency/snap",
+  "private": false,
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "test": "NODE_OPTIONS=--import=./test/mock-wallets.js node --test"
+  },
+  "dependencies": {
+    "@ecency/wallets": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.8",
+    "typescript": "^5.8.2",
+    "vite": "^6.2.0",
+    "vite-plugin-dts": "4.5.3",
+    "vite-plugin-node-polyfills": "^0.23.0"
+  }
+}

packages/snap/src/index.ts

@@ -0,0 +1,94 @@
+import {
+  mnemonicToSeedBip39,
+  deriveHiveKeys,
+  signTx,
+  signExternalTx,
+  getWallet,
+  getKeysFromSeed,
+} from "@ecency/wallets";
+
+export type RpcRequest = { method: string; params?: any };
+export interface RpcArgs { origin: string; request: RpcRequest }
+export type OnRpcRequestHandler = (args: RpcArgs) => Promise<any>;
+
+interface SnapState { mnemonic?: string }
+
+async function getState(): Promise<SnapState> {
+  return (
+    ((await (globalThis as any).snap.request({
+      method: "snap_manageState",
+      params: { operation: "get" },
+    })) as SnapState) || {}
+  );
+}
+
+async function updateState(state: SnapState): Promise<void> {
+  await (globalThis as any).snap.request({
+    method: "snap_manageState",
+    params: { operation: "update", newState: state },
+  });
+}
+
+async function getAddressFromMnemonic(mnemonic: string, chain: string) {
+  if (chain === "HIVE") {
+    const keys = deriveHiveKeys(mnemonic);
+    return keys.activePubkey;
+  }
+  const wallet = getWallet(chain as any);
+  if (!wallet) throw new Error("Unsupported chain");
+  const [, address] = await getKeysFromSeed(mnemonic, wallet, chain as any);
+  return address;
+}
+
+async function signHiveTransaction(mnemonic: string, tx: any) {
+  const keys = deriveHiveKeys(mnemonic);
+  return signTx(tx, keys.active);
+}
+
+export const onRpcRequest: OnRpcRequestHandler = async ({ request }) => {
+  const state = await getState();
+
+  switch (request.method) {
+    case "initialize": {
+      const mnemonic = request.params?.mnemonic;
+      if (typeof mnemonic !== "string") throw new Error("mnemonic required");
+      mnemonicToSeedBip39(mnemonic); // validate
+      await updateState({ mnemonic });
+      return true;
+    }
+    case "unlock": {
+      const mnemonic = request.params?.mnemonic;
+      if (typeof mnemonic !== "string") throw new Error("mnemonic required");
+      mnemonicToSeedBip39(mnemonic); // validate
+      if (state.mnemonic && mnemonic !== state.mnemonic) {
+        throw new Error("invalid mnemonic");
+      }
+      await updateState({ mnemonic });
+      return true;
+    }
+    case "getAddress": {
+      if (!state.mnemonic) throw new Error("locked");
+      const chain = request.params?.chain;
+      const address = await getAddressFromMnemonic(state.mnemonic, chain);
+      return { address };
+    }
+    case "signHiveTx": {
+      if (!state.mnemonic) throw new Error("locked");
+      const tx = request.params?.tx;
+      return signHiveTransaction(state.mnemonic, tx);
+    }
+    case "signExternalTx": {
+      if (!state.mnemonic) throw new Error("locked");
+      const { currency, params } = request.params ?? {};
+      return signExternalTx(currency, params);
+    }
+    case "getBalance": {
+      // Placeholder implementation. In a full snap environment the
+      // useGetExternalWalletBalanceQuery hook from @ecency/wallets
+      // should be used via a QueryClient.
+      return 0;
+    }
+    default:
+      throw new Error("Method not found.");
+  }
+};

packages/snap/src/shims.d.ts

@@ -0,0 +1 @@
+declare module '@ecency/wallets';

packages/snap/test/integration.test.js

@@ -0,0 +1,27 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { onRpcRequest } from '../dist/ecency-snap.es.js';
+
+const state = {};
+
+globalThis.snap = {
+  request: async ({ method, params }) => {
+    if (method !== 'snap_manageState') throw new Error('unsupported');
+    if (params.operation === 'get') return state;
+    if (params.operation === 'update') { Object.assign(state, params.newState); return null; }
+    throw new Error('bad operation');
+  },
+};
+
+const mnemonic = 'test test test test test test test test test test test junk';
+
+test('dapp flow', async () => {
+  await onRpcRequest({ origin: 'dapp', request: { method: 'initialize', params: { mnemonic } } });
+  const addr = await onRpcRequest({ origin: 'dapp', request: { method: 'getAddress', params: { chain: 'HIVE' } } });
+  assert.ok(addr.address);
+
+  const tx = { ref_block_num: 0, ref_block_prefix: 0, expiration: '2020-01-01T00:00:00', operations: [], extensions: [] };
+  const signed = await onRpcRequest({ origin: 'dapp', request: { method: 'signHiveTx', params: { tx } } });
+  assert.ok(signed.signatures.length > 0);
+});
+

packages/snap/test/mock-wallets.js

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import path from 'path';
+
+const pkgDir = path.resolve('node_modules/@ecency/wallets');
+await fs.promises.mkdir(pkgDir, { recursive: true });
+await fs.promises.writeFile(path.join(pkgDir, 'package.json'), '{"name":"@ecency/wallets","type":"module"}');
+await fs.promises.writeFile(path.join(pkgDir, 'index.js'), `
+export function mnemonicToSeedBip39(m){return m;}
+export function deriveHiveKeys(){return {active:'priv',activePubkey:'pub'};}
+export function signTx(tx){return {...tx,signatures:['sig']};}
+export function signExternalTx(){return 'signed';}
+export function getWallet(){return {getNewAddress:async()=>({address:'addr',publicKey:'pub'}),getDerivedPrivateKey:async()=> 'priv',signTransaction:async()=> 'signed'};}
+export async function getKeysFromSeed(){return ['priv','addr'];}
+`);
+

packages/snap/test/rpc.test.js

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { onRpcRequest } from '../dist/ecency-snap.es.js';
+
+const state = {};
+
+// simple snap state stub
+globalThis.snap = {
+  request: async ({ method, params }) => {
+    if (method !== 'snap_manageState') throw new Error('unsupported');
+    if (params.operation === 'get') return state;
+    if (params.operation === 'update') {
+      Object.assign(state, params.newState);
+      return null;
+    }
+    throw new Error('bad operation');
+  },
+};
+
+const mnemonic = 'test test test test test test test test test test test junk';
+
+test('initialize and unlock', async () => {
+  const init = await onRpcRequest({ origin: 'test', request: { method: 'initialize', params: { mnemonic } } });
+  assert.equal(init, true);
+
+  const unlock = await onRpcRequest({ origin: 'test', request: { method: 'unlock', params: { mnemonic } } });
+  assert.equal(unlock, true);
+});
+
+test('get hive address', async () => {
+  await onRpcRequest({ origin: 'test', request: { method: 'initialize', params: { mnemonic } } });
+  const res = await onRpcRequest({ origin: 'test', request: { method: 'getAddress', params: { chain: 'HIVE' } } });
+  assert.ok(res.address);
+});
+
+test('sign hive tx', async () => {
+  await onRpcRequest({ origin: 'test', request: { method: 'initialize', params: { mnemonic } } });
+  const tx = { ref_block_num: 0, ref_block_prefix: 0, expiration: '2020-01-01T00:00:00', operations: [], extensions: [] };
+  const signed = await onRpcRequest({ origin: 'test', request: { method: 'signHiveTx', params: { tx } } });
+  assert.ok(Array.isArray(signed.signatures));
+});
+
+test('balance query placeholder', async () => {
+  await onRpcRequest({ origin: 'test', request: { method: 'initialize', params: { mnemonic } } });
+  const bal = await onRpcRequest({ origin: 'test', request: { method: 'getBalance', params: { currency: 'BTC', address: 'xyz' } } });
+  assert.equal(bal, 0);
+});
+

packages/snap/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true
+  },
+  "include": ["src"]
+}

packages/snap/vite.config.ts

@@ -0,0 +1,37 @@
+import path from "path";
+import { defineConfig } from "vite";
+import dtsPlugin from "vite-plugin-dts";
+import { nodePolyfills } from "vite-plugin-node-polyfills";
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: path.resolve(__dirname, "src/index.ts"),
+      name: "Ecency Snap",
+      formats: ["es"],
+      fileName: (format) => `ecency-snap.${format}.js`,
+    },
+    rollupOptions: {
+      external: [
+        "crypto",
+        "@ecency/wallets",
+        "@okxweb3/coin-aptos",
+        "@okxweb3/coin-base",
+        "@okxweb3/coin-bitcoin",
+        "@okxweb3/coin-cosmos",
+        "@okxweb3/coin-ethereum",
+        "@okxweb3/coin-solana",
+        "@okxweb3/coin-ton",
+        "@okxweb3/coin-tron",
+        "@okxweb3/crypto-lib",
+        "bip39"
+      ],
+    },
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+  plugins: [dtsPlugin(), nodePolyfills()],
+});