@vaultkeepr/smart-account 0.1.1

package/dist/index.js

@@ -0,0 +1,684 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CID_REGISTRY_ABI: () => CID_REGISTRY_ABI,
+  clearIdentity: () => clearIdentity,
+  clearSmartAccountCache: () => clearSmartAccountCache,
+  computeSmartAccountAddress: () => computeSmartAccountAddress,
+  createVaultSmartAccount: () => createVaultSmartAccount,
+  flushCidOnChainSync: () => flushCidOnChainSync,
+  formatSecretKeyForDisplay: () => formatSecretKeyForDisplay,
+  generateSecretKey: () => generateSecretKey,
+  getCachedSmartAccountAddress: () => getCachedSmartAccountAddress,
+  getCachedSmartAccountMode: () => getCachedSmartAccountMode,
+  getIdentityAddress: () => getIdentityAddress,
+  getIdentityMode: () => getIdentityMode,
+  getIdentityOwner: () => getIdentityOwner,
+  getIdentitySmartAccount: () => getIdentitySmartAccount,
+  getIdentitySnapshot: () => getIdentitySnapshot,
+  getOnChainSyncStatus: () => getOnChainSyncStatus,
+  getOwnerFromPassword: () => getOwnerFromPassword,
+  getPimlicoApiKey: () => getPimlicoApiKey,
+  getTargetChain: () => getTargetChain,
+  initIdentityFromPassword: () => initIdentityFromPassword,
+  initIdentityFromSigner: () => initIdentityFromSigner,
+  isCidRegistryConfigured: () => isCidRegistryConfigured,
+  isIdentityConnected: () => isIdentityConnected,
+  isSmartAccountConfigured: () => isSmartAccountConfigured,
+  isValidSecretKey: () => isValidSecretKey,
+  parseSecretKeyInput: () => parseSecretKeyInput,
+  publishCidOnChain: () => publishCidOnChain,
+  readCidOnChain: () => readCidOnChain,
+  resetOnChainSync: () => resetOnChainSync,
+  scheduleCidOnChainSync: () => scheduleCidOnChainSync,
+  signMessageWithIdentity: () => signMessageWithIdentity,
+  subscribeIdentity: () => subscribeIdentity,
+  useIdentity: () => useIdentity
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/kernel.ts
+var import_viem = require("viem");
+var import_accounts = require("permissionless/accounts");
+var import_pimlico = require("permissionless/clients/pimlico");
+var import_account_abstraction = require("viem/account-abstraction");
+
+// src/config.ts
+var import_chains = require("viem/chains");
+var TARGET_CHAIN = import_chains.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
+var import_logger = require("@vaultkeepr/logger");
+async function computeSmartAccountAddress(ownerAccount) {
+  const publicClient = (0, import_viem.createPublicClient)({
+    chain: TARGET_CHAIN,
+    transport: (0, import_viem.http)()
+  });
+  const kernelAccount = await (0, import_accounts.toKernelSmartAccount)({
+    client: publicClient,
+    owners: [ownerAccount],
+    entryPoint: {
+      address: import_account_abstraction.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 = (0, import_viem.createPublicClient)({
+    chain: TARGET_CHAIN,
+    transport: (0, import_viem.http)()
+  });
+  const kernelAccount = await (0, import_accounts.toKernelSmartAccount)({
+    client: publicClient,
+    owners: [ownerAccount],
+    entryPoint: {
+      address: import_account_abstraction.entryPoint07Address,
+      version: "0.7"
+    }
+  });
+  const pimlicoUrl = getPimlicoUrl();
+  const pimlicoClient = (0, import_pimlico.createPimlicoClient)({
+    transport: (0, import_viem.http)(pimlicoUrl),
+    entryPoint: {
+      address: import_account_abstraction.entryPoint07Address,
+      version: "0.7"
+    }
+  });
+  const bundlerClient = (0, import_account_abstraction.createBundlerClient)({
+    account: kernelAccount,
+    chain: TARGET_CHAIN,
+    transport: (0, import_viem.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;
+  import_logger.logger.debug(
+    `[SmartAccount] Kernel cr\xE9\xE9 (${mode}) \u2014 SA: ${(0, import_logger.redactAddress)(kernelAccount.address)} | Owner: ${(0, import_logger.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
+var import_core = require("@vaultkeepr/core");
+async function getOwnerFromPassword(password, secretKey) {
+  return (0, import_core.getHiddenWalletFromPassword)(password, secretKey);
+}
+
+// src/cidRegistry.ts
+var import_viem2 = require("viem");
+var import_logger2 = require("@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()) {
+    import_logger2.logger.warn(
+      "[CidRegistry] Non configur\xE9, skip on-chain publish"
+    );
+    return null;
+  }
+  try {
+    const calldata = (0, import_viem2.encodeFunctionData)({
+      abi: CID_REGISTRY_ABI,
+      functionName: "setCid",
+      args: [cid]
+    });
+    const userOpHash = await smartAccount.client.sendUserOperation({
+      calls: [
+        {
+          to: getCidRegistryAddress(),
+          data: calldata,
+          value: BigInt(0)
+        }
+      ]
+    });
+    import_logger2.logger.debug(
+      `[CidRegistry] UserOp soumise: ${userOpHash}`
+    );
+    const receipt = await smartAccount.client.waitForUserOperationReceipt({
+      hash: userOpHash
+    });
+    import_logger2.logger.debug(
+      `[CidRegistry] CID publi\xE9 on-chain \u2014 tx: ${receipt.receipt.transactionHash} | CID: ${cid.slice(0, 20)}...`
+    );
+    return receipt.receipt.transactionHash;
+  } catch (error) {
+    import_logger2.logger.error("[CidRegistry] Erreur:", error instanceof Error ? error.message : error);
+    return null;
+  }
+}
+async function readCidOnChain(smartAccountAddress) {
+  if (!isCidRegistryConfigured()) return null;
+  try {
+    const publicClient = (0, import_viem2.createPublicClient)({
+      chain: TARGET_CHAIN,
+      transport: (0, import_viem2.http)()
+    });
+    const cid = await publicClient.readContract({
+      address: getCidRegistryAddress(),
+      abi: CID_REGISTRY_ABI,
+      functionName: "getCid",
+      args: [smartAccountAddress]
+    });
+    return cid && cid.length > 0 ? cid : null;
+  } catch (error) {
+    import_logger2.logger.error("[CidRegistry] Erreur lecture:", error instanceof Error ? error.message : error);
+    return null;
+  }
+}
+
+// src/onChainSync.ts
+var import_logger3 = require("@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) {
+    import_logger3.logger.debug("[OnChainSync] CID identique, skip");
+    return;
+  }
+  const sa = smartAccount ?? _pendingSmartAccount;
+  if (!sa) {
+    import_logger3.logger.warn("[OnChainSync] Pas de Smart Account disponible, skip");
+    return;
+  }
+  _pendingCid = cid;
+  _pendingSmartAccount = sa;
+  if (_debounceTimer) {
+    clearTimeout(_debounceTimer);
+  }
+  _debounceTimer = setTimeout(() => {
+    _executeSync();
+  }, debounceMs);
+  import_logger3.logger.debug(
+    `[OnChainSync] CID planifi\xE9 dans ${(debounceMs / 1e3).toFixed(0)}s : ${cid.slice(0, 20)}...`
+  );
+}
+async function flushCidOnChainSync() {
+  import_logger3.logger.debug(
+    "[OnChainSync] flush demand\xE9 \u2014 pending:",
+    _pendingCid?.slice(0, 20),
+    "SA:",
+    !!_pendingSmartAccount
+  );
+  if (!_pendingCid || !_pendingSmartAccount) {
+    import_logger3.logger.debug("[OnChainSync] Rien \xE0 flush");
+    return true;
+  }
+  if (_debounceTimer) {
+    clearTimeout(_debounceTimer);
+    _debounceTimer = null;
+  }
+  import_logger3.logger.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 {
+    import_logger3.logger.debug(`[OnChainSync] Publication on-chain: ${cid.slice(0, 20)}...`);
+    const txHash = await publishCidOnChain(sa, cid);
+    if (txHash) {
+      _lastPublishedCid = cid;
+      _lastPublishTime = Date.now();
+      _pendingCid = null;
+      import_logger3.logger.debug(
+        `[OnChainSync] \u2705 CID publi\xE9 on-chain : ${cid.slice(0, 20)}...`
+      );
+      return true;
+    }
+    import_logger3.logger.warn("[OnChainSync] Publication \xE9chou\xE9e (null txHash)");
+    return false;
+  } catch (error) {
+    import_logger3.logger.error("[OnChainSync] Erreur publication:", error instanceof Error ? error.message : error);
+    return false;
+  } finally {
+    _isPublishing = false;
+  }
+}
+
+// src/identity.ts
+var import_logger4 = require("@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) {
+      import_logger4.logger.warn("[Identity] SA init failed (non-blocking):", e.message);
+    }
+  }
+  _state = {
+    owner,
+    smartAccount: sa,
+    mode: "password",
+    initialized: true
+  };
+  _notify();
+  import_logger4.logger.debug(
+    `[Identity] Connect\xE9 (password) \u2014 adresse: ${(0, import_logger4.redactAddress)(owner.address)}` + (sa ? ` | SA: ${(0, import_logger4.redactAddress)(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) {
+      import_logger4.logger.warn("[Identity] SA init failed (non-blocking):", e.message);
+    }
+  }
+  _state = {
+    owner: signer,
+    smartAccount: sa,
+    mode,
+    initialized: true
+  };
+  _notify();
+  import_logger4.logger.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();
+  import_logger4.logger.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
+var import_react = require("react");
+var _emptyState = {
+  owner: null,
+  smartAccount: null,
+  mode: null,
+  initialized: false
+};
+function getServerSnapshot() {
+  return _emptyState;
+}
+function useIdentity() {
+  const state = (0, import_react.useSyncExternalStore)(
+    subscribeIdentity,
+    getIdentitySnapshot,
+    getServerSnapshot
+  );
+  const signMessage = (0, import_react.useCallback)(
+    async (message) => {
+      return signMessageWithIdentity(message);
+    },
+    []
+  );
+  const disconnect = (0, import_react.useCallback)(() => {
+    clearIdentity();
+  }, []);
+  const notifyOnChainSync = (0, import_react.useCallback)(
+    (cid) => {
+      const sa = getIdentitySmartAccount();
+      if (!sa) return;
+      scheduleCidOnChainSync(sa, cid);
+    },
+    []
+  );
+  const cleanupOnLock = (0, import_react.useCallback)(async () => {
+    await flushCidOnChainSync().catch(() => {
+    });
+    clearSmartAccountCache();
+    resetOnChainSync();
+    clearIdentity();
+  }, []);
+  const flushOnChainSync = (0, import_react.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
+var import_viem3 = require("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 (0, import_viem3.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();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});