@vaultkeepr/smart-account 0.1.1

package/dist/index.mjs

@@ -0,0 +1,635 @@
+// src/kernel.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+import { toKernelSmartAccount } from "permissionless/accounts";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+import {
+  createBundlerClient,
+  entryPoint07Address
+} from "viem/account-abstraction";
+
+// src/config.ts
+import { base } from "viem/chains";
+var TARGET_CHAIN = base;
+function getPimlicoApiKey() {
+  let key = "";
+  try {
+    key = process.env.PIMLICO_API_KEY || "";
+  } catch {
+  }
+  if (key) return key;
+  try {
+    key = process.env.NEXT_PUBLIC_PIMLICO_API_KEY || "";
+  } catch {
+  }
+  return key;
+}
+function getPimlicoUrl() {
+  let proxyUrl = "";
+  try {
+    proxyUrl = process.env.PIMLICO_PROXY_URL || "";
+  } catch {
+  }
+  if (!proxyUrl) {
+    try {
+      proxyUrl = process.env.NEXT_PUBLIC_PIMLICO_PROXY_URL || "";
+    } catch {
+    }
+  }
+  if (!proxyUrl) {
+    try {
+      proxyUrl = process.env.EXPO_PUBLIC_PIMLICO_PROXY_URL || "";
+    } catch {
+    }
+  }
+  if (proxyUrl) {
+    return proxyUrl;
+  }
+  throw new Error(
+    "[SmartAccount] Aucun proxy bundler configure. Configurez PIMLICO_PROXY_URL (le fallback direct api.pimlico.io a ete supprime pour ne pas exposer la cle API dans le bundle client)."
+  );
+}
+function isSmartAccountConfigured() {
+  let proxyUrl = "";
+  try {
+    proxyUrl = process.env.PIMLICO_PROXY_URL || "";
+  } catch {
+  }
+  if (!proxyUrl) {
+    try {
+      proxyUrl = process.env.NEXT_PUBLIC_PIMLICO_PROXY_URL || "";
+    } catch {
+    }
+  }
+  if (!proxyUrl) {
+    try {
+      proxyUrl = process.env.EXPO_PUBLIC_PIMLICO_PROXY_URL || "";
+    } catch {
+    }
+  }
+  return !!proxyUrl;
+}
+function getTargetChain() {
+  return TARGET_CHAIN;
+}
+
+// src/kernel.ts
+import { logger, redactAddress } from "@vaultkeepr/logger";
+async function computeSmartAccountAddress(ownerAccount) {
+  const publicClient = createPublicClient({
+    chain: TARGET_CHAIN,
+    transport: http()
+  });
+  const kernelAccount = await toKernelSmartAccount({
+    client: publicClient,
+    owners: [ownerAccount],
+    entryPoint: {
+      address: entryPoint07Address,
+      version: "0.7"
+    }
+  });
+  return kernelAccount.address;
+}
+var _cached = null;
+var _cachedKey = null;
+async function createVaultSmartAccount(params) {
+  const { ownerAccount, mode } = params;
+  const cacheKey = `${mode}:${ownerAccount.address.toLowerCase()}`;
+  if (_cached && _cachedKey === cacheKey) return _cached;
+  const publicClient = createPublicClient({
+    chain: TARGET_CHAIN,
+    transport: http()
+  });
+  const kernelAccount = await toKernelSmartAccount({
+    client: publicClient,
+    owners: [ownerAccount],
+    entryPoint: {
+      address: entryPoint07Address,
+      version: "0.7"
+    }
+  });
+  const pimlicoUrl = getPimlicoUrl();
+  const pimlicoClient = createPimlicoClient({
+    transport: http(pimlicoUrl),
+    entryPoint: {
+      address: entryPoint07Address,
+      version: "0.7"
+    }
+  });
+  const bundlerClient = createBundlerClient({
+    account: kernelAccount,
+    chain: TARGET_CHAIN,
+    transport: http(pimlicoUrl),
+    paymaster: {
+      async getPaymasterData(parameters) {
+        return pimlicoClient.getPaymasterData(parameters);
+      },
+      async getPaymasterStubData(parameters) {
+        return pimlicoClient.getPaymasterStubData(parameters);
+      }
+    },
+    userOperation: {
+      async estimateFeesPerGas() {
+        return (await pimlicoClient.getUserOperationGasPrice()).fast;
+      }
+    }
+  });
+  const result = {
+    address: kernelAccount.address,
+    ownerAddress: ownerAccount.address,
+    ownerAccount,
+    client: bundlerClient,
+    chain: TARGET_CHAIN,
+    mode
+  };
+  _cached = result;
+  _cachedKey = cacheKey;
+  logger.debug(
+    `[SmartAccount] Kernel cr\xE9\xE9 (${mode}) \u2014 SA: ${redactAddress(kernelAccount.address)} | Owner: ${redactAddress(ownerAccount.address)}`
+  );
+  return result;
+}
+function getCachedSmartAccountAddress() {
+  return _cached?.address ?? null;
+}
+function getCachedSmartAccountMode() {
+  return _cached?.mode ?? null;
+}
+function clearSmartAccountCache() {
+  _cached = null;
+  _cachedKey = null;
+}
+
+// src/owner.ts
+import { getHiddenWalletFromPassword, getHiddenWalletLegacy } from "@vaultkeepr/core";
+async function getOwnerFromPassword(password, secretKey) {
+  return getHiddenWalletFromPassword(password, secretKey);
+}
+
+// src/cidRegistry.ts
+import {
+  createPublicClient as createPublicClient2,
+  encodeFunctionData,
+  http as http2
+} from "viem";
+import { logger as logger2 } from "@vaultkeepr/logger";
+var CID_REGISTRY_ABI = [
+  {
+    name: "setCid",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "cid", type: "string" }],
+    outputs: []
+  },
+  {
+    name: "deleteCid",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    name: "getCid",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    name: "hasCid",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "getUpdatedAt",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "nextAllowedUpdate",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "cooldownSeconds",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function getCidRegistryAddress() {
+  let addr = "";
+  try {
+    addr = process.env.CID_REGISTRY_ADDRESS || "";
+  } catch {
+  }
+  if (addr) return addr;
+  try {
+    addr = process.env.NEXT_PUBLIC_CID_REGISTRY_ADDRESS || "";
+  } catch {
+  }
+  if (addr) return addr;
+  try {
+    addr = process.env.EXPO_PUBLIC_CID_REGISTRY_ADDRESS || "";
+  } catch {
+  }
+  if (addr) return addr;
+  return "0x0000000000000000000000000000000000000000";
+}
+function isCidRegistryConfigured() {
+  return getCidRegistryAddress() !== "0x0000000000000000000000000000000000000000" && isSmartAccountConfigured();
+}
+async function publishCidOnChain(smartAccount, cid) {
+  if (!isCidRegistryConfigured()) {
+    logger2.warn(
+      "[CidRegistry] Non configur\xE9, skip on-chain publish"
+    );
+    return null;
+  }
+  try {
+    const calldata = encodeFunctionData({
+      abi: CID_REGISTRY_ABI,
+      functionName: "setCid",
+      args: [cid]
+    });
+    const userOpHash = await smartAccount.client.sendUserOperation({
+      calls: [
+        {
+          to: getCidRegistryAddress(),
+          data: calldata,
+          value: BigInt(0)
+        }
+      ]
+    });
+    logger2.debug(
+      `[CidRegistry] UserOp soumise: ${userOpHash}`
+    );
+    const receipt = await smartAccount.client.waitForUserOperationReceipt({
+      hash: userOpHash
+    });
+    logger2.debug(
+      `[CidRegistry] CID publi\xE9 on-chain \u2014 tx: ${receipt.receipt.transactionHash} | CID: ${cid.slice(0, 20)}...`
+    );
+    return receipt.receipt.transactionHash;
+  } catch (error) {
+    logger2.error("[CidRegistry] Erreur:", error instanceof Error ? error.message : error);
+    return null;
+  }
+}
+async function readCidOnChain(smartAccountAddress) {
+  if (!isCidRegistryConfigured()) return null;
+  try {
+    const publicClient = createPublicClient2({
+      chain: TARGET_CHAIN,
+      transport: http2()
+    });
+    const cid = await publicClient.readContract({
+      address: getCidRegistryAddress(),
+      abi: CID_REGISTRY_ABI,
+      functionName: "getCid",
+      args: [smartAccountAddress]
+    });
+    return cid && cid.length > 0 ? cid : null;
+  } catch (error) {
+    logger2.error("[CidRegistry] Erreur lecture:", error instanceof Error ? error.message : error);
+    return null;
+  }
+}
+
+// src/onChainSync.ts
+import { logger as logger3 } from "@vaultkeepr/logger";
+var DEFAULT_DEBOUNCE_MS = 5 * 60 * 1e3;
+var _pendingCid = null;
+var _pendingSmartAccount = null;
+var _debounceTimer = null;
+var _lastPublishedCid = null;
+var _lastPublishTime = 0;
+var _isPublishing = false;
+function scheduleCidOnChainSync(smartAccount, cid, debounceMs = DEFAULT_DEBOUNCE_MS) {
+  if (!isCidRegistryConfigured()) return;
+  if (cid === _lastPublishedCid) {
+    logger3.debug("[OnChainSync] CID identique, skip");
+    return;
+  }
+  const sa = smartAccount ?? _pendingSmartAccount;
+  if (!sa) {
+    logger3.warn("[OnChainSync] Pas de Smart Account disponible, skip");
+    return;
+  }
+  _pendingCid = cid;
+  _pendingSmartAccount = sa;
+  if (_debounceTimer) {
+    clearTimeout(_debounceTimer);
+  }
+  _debounceTimer = setTimeout(() => {
+    _executeSync();
+  }, debounceMs);
+  logger3.debug(
+    `[OnChainSync] CID planifi\xE9 dans ${(debounceMs / 1e3).toFixed(0)}s : ${cid.slice(0, 20)}...`
+  );
+}
+async function flushCidOnChainSync() {
+  logger3.debug(
+    "[OnChainSync] flush demand\xE9 \u2014 pending:",
+    _pendingCid?.slice(0, 20),
+    "SA:",
+    !!_pendingSmartAccount
+  );
+  if (!_pendingCid || !_pendingSmartAccount) {
+    logger3.debug("[OnChainSync] Rien \xE0 flush");
+    return true;
+  }
+  if (_debounceTimer) {
+    clearTimeout(_debounceTimer);
+    _debounceTimer = null;
+  }
+  logger3.debug("[OnChainSync] Flush imm\xE9diat...");
+  return _executeSync();
+}
+function getOnChainSyncStatus() {
+  return {
+    hasPending: _pendingCid !== null && _pendingCid !== _lastPublishedCid,
+    pendingCid: _pendingCid,
+    lastPublishedCid: _lastPublishedCid,
+    lastPublishTime: _lastPublishTime,
+    isPublishing: _isPublishing
+  };
+}
+function resetOnChainSync() {
+  if (_debounceTimer) {
+    clearTimeout(_debounceTimer);
+    _debounceTimer = null;
+  }
+  _pendingCid = null;
+  _pendingSmartAccount = null;
+  _lastPublishedCid = null;
+  _lastPublishTime = 0;
+  _isPublishing = false;
+}
+async function _executeSync() {
+  if (!_pendingCid || !_pendingSmartAccount || _isPublishing) return false;
+  if (_pendingCid === _lastPublishedCid) {
+    _pendingCid = null;
+    return true;
+  }
+  _isPublishing = true;
+  const cid = _pendingCid;
+  const sa = _pendingSmartAccount;
+  try {
+    logger3.debug(`[OnChainSync] Publication on-chain: ${cid.slice(0, 20)}...`);
+    const txHash = await publishCidOnChain(sa, cid);
+    if (txHash) {
+      _lastPublishedCid = cid;
+      _lastPublishTime = Date.now();
+      _pendingCid = null;
+      logger3.debug(
+        `[OnChainSync] \u2705 CID publi\xE9 on-chain : ${cid.slice(0, 20)}...`
+      );
+      return true;
+    }
+    logger3.warn("[OnChainSync] Publication \xE9chou\xE9e (null txHash)");
+    return false;
+  } catch (error) {
+    logger3.error("[OnChainSync] Erreur publication:", error instanceof Error ? error.message : error);
+    return false;
+  } finally {
+    _isPublishing = false;
+  }
+}
+
+// src/identity.ts
+import { logger as logger4, redactAddress as redactAddress2 } from "@vaultkeepr/logger";
+var _state = {
+  owner: null,
+  smartAccount: null,
+  mode: null,
+  initialized: false
+};
+var _listeners = /* @__PURE__ */ new Set();
+function _notify() {
+  for (const fn of _listeners) {
+    try {
+      fn(_state);
+    } catch {
+    }
+  }
+}
+async function initIdentityFromPassword(password, secretKey) {
+  const owner = await getOwnerFromPassword(password, secretKey);
+  let sa = null;
+  if (isSmartAccountConfigured()) {
+    try {
+      sa = await createVaultSmartAccount({
+        ownerAccount: owner,
+        mode: "password"
+      });
+    } catch (e) {
+      logger4.warn("[Identity] SA init failed (non-blocking):", e.message);
+    }
+  }
+  _state = {
+    owner,
+    smartAccount: sa,
+    mode: "password",
+    initialized: true
+  };
+  _notify();
+  logger4.debug(
+    `[Identity] Connect\xE9 (password) \u2014 adresse: ${redactAddress2(owner.address)}` + (sa ? ` | SA: ${redactAddress2(sa.address)}` : "") + (secretKey ? ` | SK: \u2713` : " | no secretKey")
+  );
+  return {
+    address: owner.address,
+    smartAccountAddress: sa?.address ?? null
+  };
+}
+async function initIdentityFromSigner(signer, mode = "passkey") {
+  let sa = null;
+  if (isSmartAccountConfigured()) {
+    try {
+      sa = await createVaultSmartAccount({ ownerAccount: signer, mode });
+    } catch (e) {
+      logger4.warn("[Identity] SA init failed (non-blocking):", e.message);
+    }
+  }
+  _state = {
+    owner: signer,
+    smartAccount: sa,
+    mode,
+    initialized: true
+  };
+  _notify();
+  logger4.info(
+    `[Identity] Connected (${mode}) \u2014 address: ${signer.address}` + (sa ? ` | SA: ${sa.address}` : "")
+  );
+  return {
+    address: signer.address,
+    smartAccountAddress: sa?.address ?? null
+  };
+}
+function clearIdentity() {
+  _state = {
+    owner: null,
+    smartAccount: null,
+    mode: null,
+    initialized: false
+  };
+  clearSmartAccountCache();
+  _notify();
+  logger4.info("[Identity] Disconnected");
+}
+function getIdentityAddress() {
+  return _state.owner?.address ?? null;
+}
+function isIdentityConnected() {
+  return _state.initialized && _state.owner !== null;
+}
+function getIdentityOwner() {
+  return _state.owner;
+}
+function getIdentitySmartAccount() {
+  return _state.smartAccount;
+}
+function getIdentityMode() {
+  return _state.mode;
+}
+async function signMessageWithIdentity(message) {
+  if (!_state.owner) {
+    throw new Error("[Identity] Pas connect\xE9 \u2014 impossible de signer");
+  }
+  return _state.owner.signMessage({ message });
+}
+function subscribeIdentity(listener) {
+  _listeners.add(listener);
+  return () => {
+    _listeners.delete(listener);
+  };
+}
+function getIdentitySnapshot() {
+  return _state;
+}
+
+// src/useIdentity.ts
+import { useSyncExternalStore, useCallback } from "react";
+var _emptyState = {
+  owner: null,
+  smartAccount: null,
+  mode: null,
+  initialized: false
+};
+function getServerSnapshot() {
+  return _emptyState;
+}
+function useIdentity() {
+  const state = useSyncExternalStore(
+    subscribeIdentity,
+    getIdentitySnapshot,
+    getServerSnapshot
+  );
+  const signMessage = useCallback(
+    async (message) => {
+      return signMessageWithIdentity(message);
+    },
+    []
+  );
+  const disconnect = useCallback(() => {
+    clearIdentity();
+  }, []);
+  const notifyOnChainSync = useCallback(
+    (cid) => {
+      const sa = getIdentitySmartAccount();
+      if (!sa) return;
+      scheduleCidOnChainSync(sa, cid);
+    },
+    []
+  );
+  const cleanupOnLock = useCallback(async () => {
+    await flushCidOnChainSync().catch(() => {
+    });
+    clearSmartAccountCache();
+    resetOnChainSync();
+    clearIdentity();
+  }, []);
+  const flushOnChainSync = useCallback(async () => {
+    await flushCidOnChainSync().catch(() => {
+    });
+  }, []);
+  return {
+    address: state.owner?.address ?? null,
+    isConnected: state.initialized && state.owner !== null,
+    mode: state.mode,
+    smartAccountAddress: state.smartAccount?.address ?? null,
+    signMessage,
+    disconnect,
+    notifyOnChainSync,
+    cleanupOnLock,
+    flushOnChainSync
+  };
+}
+
+// src/secretKey.ts
+import { bytesToHex } from "viem";
+function generateSecretKey() {
+  const bytes = new Uint8Array(32);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 32; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return bytesToHex(bytes).slice(2);
+}
+function isValidSecretKey(key) {
+  return typeof key === "string" && /^[0-9a-f]{64}$/i.test(key);
+}
+function formatSecretKeyForDisplay(key) {
+  const clean = key.replace(/[^0-9a-f]/gi, "").toLowerCase();
+  return clean.match(/.{1,8}/g)?.join("-") ?? clean;
+}
+function parseSecretKeyInput(input) {
+  return input.replace(/[-\s]/g, "").toLowerCase();
+}
+export {
+  CID_REGISTRY_ABI,
+  clearIdentity,
+  clearSmartAccountCache,
+  computeSmartAccountAddress,
+  createVaultSmartAccount,
+  flushCidOnChainSync,
+  formatSecretKeyForDisplay,
+  generateSecretKey,
+  getCachedSmartAccountAddress,
+  getCachedSmartAccountMode,
+  getIdentityAddress,
+  getIdentityMode,
+  getIdentityOwner,
+  getIdentitySmartAccount,
+  getIdentitySnapshot,
+  getOnChainSyncStatus,
+  getOwnerFromPassword,
+  getPimlicoApiKey,
+  getTargetChain,
+  initIdentityFromPassword,
+  initIdentityFromSigner,
+  isCidRegistryConfigured,
+  isIdentityConnected,
+  isSmartAccountConfigured,
+  isValidSecretKey,
+  parseSecretKeyInput,
+  publishCidOnChain,
+  readCidOnChain,
+  resetOnChainSync,
+  scheduleCidOnChainSync,
+  signMessageWithIdentity,
+  subscribeIdentity,
+  useIdentity
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@vaultkeepr/smart-account",
+  "version": "0.1.1",
+  "description": "ERC-4337 Smart Account (Kernel) with Pimlico Paymaster — universal module for Web, Extension, iOS, and Android",
+  "license": "MIT",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "require": "./src/index.ts"
+    }
+  },
+  "dependencies": {
+    "@vaultkeepr/logger": "0.1.1",
+    "@vaultkeepr/core": "0.1.1"
+  },
+  "peerDependencies": {
+    "permissionless": ">=0.3.0",
+    "viem": ">=2.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^4.1.11",
+    "react": "^19.2.0",
+    "@types/react": "^19.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "clean": "rm -rf dist",
+    "test": "vitest run --passWithNoTests",
+    "lint": "eslint src/"
+  }
+}