tenjin-cli 0.1.0-alpha.0

package/dist/chunk-QHIEYBLV.js

@@ -0,0 +1,320 @@
+import { createRequire as __tenjinCreateRequire } from 'node:module'; const require = __tenjinCreateRequire(import.meta.url);
+import {
+  hashAuthorization,
+  hashMessage,
+  hashTypedData,
+  publicKeyToAddress,
+  serializeSignature,
+  serializeTransaction
+} from "./chunk-SXQQ2ZSR.js";
+import {
+  secp256k1
+} from "./chunk-TX5T3LKJ.js";
+import {
+  InvalidAddressError,
+  hexToBytes,
+  isAddress,
+  isHex,
+  keccak256,
+  numberToHex,
+  toHex
+} from "./chunk-F5DZJLU3.js";
+import {
+  PRIVATE_KEY_RE,
+  readWalletRecord,
+  walletFileMode,
+  writeWalletRecord
+} from "./chunk-376LHMK2.js";
+import {
+  CliError,
+  walletPath
+} from "./chunk-FIYZLITH.js";
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/accounts/generatePrivateKey.js
+function generatePrivateKey() {
+  return toHex(secp256k1.utils.randomPrivateKey());
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/accounts/toAccount.js
+function toAccount(source) {
+  if (typeof source === "string") {
+    if (!isAddress(source, { strict: false }))
+      throw new InvalidAddressError({ address: source });
+    return {
+      address: source,
+      type: "json-rpc"
+    };
+  }
+  if (!isAddress(source.address, { strict: false }))
+    throw new InvalidAddressError({ address: source.address });
+  return {
+    address: source.address,
+    nonceManager: source.nonceManager,
+    sign: source.sign,
+    signAuthorization: source.signAuthorization,
+    signMessage: source.signMessage,
+    signTransaction: source.signTransaction,
+    signTypedData: source.signTypedData,
+    source: "custom",
+    type: "local"
+  };
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/accounts/utils/sign.js
+var extraEntropy = false;
+async function sign({ hash, privateKey, to = "object" }) {
+  const { r, s, recovery } = secp256k1.sign(hash.slice(2), privateKey.slice(2), {
+    lowS: true,
+    extraEntropy: isHex(extraEntropy, { strict: false }) ? hexToBytes(extraEntropy) : extraEntropy
+  });
+  const signature = {
+    r: numberToHex(r, { size: 32 }),
+    s: numberToHex(s, { size: 32 }),
+    v: recovery ? 28n : 27n,
+    yParity: recovery
+  };
+  return (() => {
+    if (to === "bytes" || to === "hex")
+      return serializeSignature({ ...signature, to });
+    return signature;
+  })();
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/accounts/utils/signAuthorization.js
+async function signAuthorization(parameters) {
+  const { chainId, nonce, privateKey, to = "object" } = parameters;
+  const address = parameters.contractAddress ?? parameters.address;
+  const signature = await sign({
+    hash: hashAuthorization({ address, chainId, nonce }),
+    privateKey,
+    to
+  });
+  if (to === "object")
+    return {
+      address,
+      chainId,
+      nonce,
+      ...signature
+    };
+  return signature;
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/accounts/utils/signMessage.js
+async function signMessage({ message, privateKey }) {
+  return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/accounts/utils/signTransaction.js
+async function signTransaction(parameters) {
+  const { privateKey, transaction, serializer = serializeTransaction } = parameters;
+  const signableTransaction = (() => {
+    if (transaction.type === "eip4844")
+      return {
+        ...transaction,
+        sidecars: false
+      };
+    return transaction;
+  })();
+  const signature = await sign({
+    hash: keccak256(await serializer(signableTransaction)),
+    privateKey
+  });
+  return await serializer(transaction, signature);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/accounts/utils/signTypedData.js
+async function signTypedData(parameters) {
+  const { privateKey, ...typedData } = parameters;
+  return await sign({
+    hash: hashTypedData(typedData),
+    privateKey,
+    to: "hex"
+  });
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/accounts/privateKeyToAccount.js
+function privateKeyToAccount(privateKey, options = {}) {
+  const { nonceManager } = options;
+  const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
+  const address = publicKeyToAddress(publicKey);
+  const account = toAccount({
+    address,
+    nonceManager,
+    async sign({ hash }) {
+      return sign({ hash, privateKey, to: "hex" });
+    },
+    async signAuthorization(authorization) {
+      return signAuthorization({ ...authorization, privateKey });
+    },
+    async signMessage({ message }) {
+      return signMessage({ message, privateKey });
+    },
+    async signTransaction(transaction, { serializer } = {}) {
+      return signTransaction({ privateKey, transaction, serializer });
+    },
+    async signTypedData(typedData) {
+      return signTypedData({ ...typedData, privateKey });
+    }
+  });
+  return {
+    ...account,
+    publicKey,
+    source: "privateKey"
+  };
+}
+
+// src/lib/wallet/local.ts
+var isWindows = process.platform === "win32";
+function createLocalProvider(deps) {
+  return {
+    id: "local",
+    async describe() {
+      const cred = resolveCredentialOrThrow(await loadCredential(deps));
+      return {
+        // A stored address is only a claim; accountForCredential derives from the
+        // key and rejects a record whose address does not match, so show/balance
+        // can never display an address the key would not sign as.
+        address: accountForCredential(cred).address,
+        provider: "local",
+        credentialSource: cred.source,
+        policyEnforcement: "client-only"
+      };
+    },
+    async getSigner() {
+      const cred = resolveCredentialOrThrow(await loadCredential(deps));
+      const account = accountForCredential(cred);
+      return {
+        address: account.address,
+        signMessage: (args) => account.signMessage({ message: args.message }),
+        signTypedData: (args) => account.signTypedData(args)
+      };
+    },
+    diagnostics() {
+      return localWalletDiagnostics(deps);
+    }
+  };
+}
+async function localWalletDiagnostics(deps) {
+  const mode = await walletFileMode(deps.dir);
+  const fileExists = mode !== null;
+  const envKey = deps.env.TENJIN_WALLET_KEY;
+  const envSet = envKey !== void 0 && envKey.length > 0;
+  const path = walletPath(deps.dir);
+  const warnings = [];
+  if (envSet && fileExists) {
+    warnings.push("TENJIN_WALLET_KEY is set and shadows the wallet file at runtime.");
+  }
+  if (mode !== null) {
+    if (isWindows) {
+      warnings.push("File permission checks are not available on Windows.");
+    } else if (mode !== 384) {
+      warnings.push(
+        `Wallet file permissions are ${mode.toString(8)}, expected 600. Run \`chmod 600 ${path}\`.`
+      );
+    }
+  }
+  return { ...fileExists ? { walletPath: path } : {}, warnings };
+}
+async function createLocalWallet(dir) {
+  const key = generatePrivateKey();
+  const address = privateKeyToAccount(key).address;
+  await writeWalletRecord(dir, walletRecord(address, key));
+  return { address, walletPath: walletPath(dir) };
+}
+async function importLocalWallet(dir, key) {
+  if (!PRIVATE_KEY_RE.test(key)) {
+    throw new CliError("WALLET_INVALID_KEY", "The provided key is not a valid private key.", {
+      fix: "Provide a 0x-prefixed 32-byte hex private key."
+    });
+  }
+  let address;
+  try {
+    address = privateKeyToAccount(key).address;
+  } catch (err) {
+    throw new CliError("WALLET_INVALID_KEY", "The provided key is not a valid secp256k1 key.", {
+      fix: "Provide a 0x-prefixed 32-byte hex key within the curve order.",
+      cause: err
+    });
+  }
+  await writeWalletRecord(dir, walletRecord(address, key));
+  return { address, walletPath: walletPath(dir) };
+}
+async function loadCredential(deps) {
+  const envKey = deps.env.TENJIN_WALLET_KEY;
+  if (envKey !== void 0 && envKey.trim().length > 0) {
+    const key = envKey.trim();
+    if (!PRIVATE_KEY_RE.test(key)) {
+      throw new CliError("WALLET_INVALID_KEY", "TENJIN_WALLET_KEY is not a valid private key.", {
+        fix: "Set TENJIN_WALLET_KEY to a 0x-prefixed 32-byte hex key, or unset it to use the wallet file."
+      });
+    }
+    return { source: "env", key };
+  }
+  const record = await readWalletRecord(deps.dir);
+  if (record !== null) {
+    return { source: "file", key: record.privateKey, address: record.address };
+  }
+  return null;
+}
+function accountForCredential(cred) {
+  let account;
+  try {
+    account = privateKeyToAccount(cred.key);
+  } catch (err) {
+    throw new CliError("WALLET_INVALID_KEY", "The private key is not a valid secp256k1 key.", {
+      fix: cred.source === "file" ? "Move the wallet file aside, then re-import the intended key." : "Set TENJIN_WALLET_KEY to a valid 0x-prefixed 32-byte hex key.",
+      cause: err
+    });
+  }
+  if (cred.source === "file" && account.address.toLowerCase() !== cred.address.toLowerCase()) {
+    throw new CliError(
+      "WALLET_INVALID_KEY",
+      `The wallet file's stored address ${cred.address} does not match its private key (derives ${account.address}).`,
+      { fix: "Move the wallet file aside, then re-import the intended key." }
+    );
+  }
+  return account;
+}
+function resolveCredentialOrThrow(cred) {
+  if (cred === null) {
+    throw new CliError("WALLET_MISSING", "No wallet found.", {
+      fix: "Run `tenjin wallet create` to create one."
+    });
+  }
+  return cred;
+}
+function walletRecord(address, privateKey) {
+  return {
+    schemaVersion: 1,
+    provider: "local",
+    address,
+    privateKey,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/lib/wallet/index.ts
+function resolveWalletProvider(ctx, opts = {}) {
+  if (opts.provider !== void 0) return opts.provider;
+  return createLocalProvider({ dir: ctx.dataDir, env: process.env });
+}
+async function describeWallet(provider) {
+  try {
+    return await provider.describe();
+  } catch (err) {
+    if (err instanceof CliError) throw err;
+    const message = err instanceof Error ? err.message : "unknown error";
+    throw new CliError("PROVIDER_ERROR", `Wallet provider "${provider.id}" failed: ${message}`, {
+      fix: "Check the wallet provider and try again.",
+      cause: err
+    });
+  }
+}
+
+export {
+  createLocalWallet,
+  importLocalWallet,
+  resolveWalletProvider,
+  describeWallet
+};
+//# sourceMappingURL=chunk-QHIEYBLV.js.map

package/dist/chunk-QHIEYBLV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/accounts/generatePrivateKey.ts","../node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/accounts/toAccount.ts","../node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/accounts/utils/sign.ts","../node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/accounts/utils/signAuthorization.ts","../node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/accounts/utils/signMessage.ts","../node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/accounts/utils/signTransaction.ts","../node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/accounts/utils/signTypedData.ts","../node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/accounts/privateKeyToAccount.ts","../src/lib/wallet/local.ts","../src/lib/wallet/index.ts"],"sourcesContent":["import { secp256k1 } from '@noble/curves/secp256k1'\n\nimport type { ErrorType } from '../errors/utils.js'\nimport type { Hex } from '../types/misc.js'\nimport { type ToHexErrorType, toHex } from '../utils/encoding/toHex.js'\n\nexport type GeneratePrivateKeyErrorType = ToHexErrorType | ErrorType\n\n/**\n * @description Generates a random private key.\n *\n * @returns A randomly generated private key.\n */\nexport function generatePrivateKey(): Hex {\n  return toHex(secp256k1.utils.randomPrivateKey())\n}\n","// TODO(v3): Rename to `toLocalAccount` + add `source` property to define source (privateKey, mnemonic, hdKey, etc).\n\nimport type { Address } from 'abitype'\n\nimport {\n  InvalidAddressError,\n  type InvalidAddressErrorType,\n} from '../errors/address.js'\nimport type { ErrorType } from '../errors/utils.js'\nimport {\n  type IsAddressErrorType,\n  isAddress,\n} from '../utils/address/isAddress.js'\nimport type {\n  AccountSource,\n  CustomSource,\n  JsonRpcAccount,\n  LocalAccount,\n} from './types.js'\n\ntype GetAccountReturnType<accountSource extends AccountSource> =\n  | (accountSource extends Address ? JsonRpcAccount : never)\n  | (accountSource extends CustomSource ? LocalAccount : never)\n\nexport type ToAccountErrorType =\n  | InvalidAddressErrorType\n  | IsAddressErrorType\n  | ErrorType\n\n/**\n * @description Creates an Account from a custom signing implementation.\n *\n * @returns A Local Account.\n */\nexport function toAccount<accountSource extends AccountSource>(\n  source: accountSource,\n): GetAccountReturnType<accountSource> {\n  if (typeof source === 'string') {\n    if (!isAddress(source, { strict: false }))\n      throw new InvalidAddressError({ address: source })\n    return {\n      address: source,\n      type: 'json-rpc',\n    } as GetAccountReturnType<accountSource>\n  }\n\n  if (!isAddress(source.address, { strict: false }))\n    throw new InvalidAddressError({ address: source.address })\n  return {\n    address: source.address,\n    nonceManager: source.nonceManager,\n    sign: source.sign,\n    signAuthorization: source.signAuthorization,\n    signMessage: source.signMessage,\n    signTransaction: source.signTransaction,\n    signTypedData: source.signTypedData,\n    source: 'custom',\n    type: 'local',\n  } as GetAccountReturnType<accountSource>\n}\n","// TODO(v3): Convert to sync.\n\nimport { secp256k1 } from '@noble/curves/secp256k1'\n\nimport type { ErrorType } from '../../errors/utils.js'\nimport type { ByteArray, Hex, Signature } from '../../types/misc.js'\nimport { type IsHexErrorType, isHex } from '../../utils/data/isHex.js'\nimport {\n  type HexToBytesErrorType,\n  hexToBytes,\n} from '../../utils/encoding/toBytes.js'\nimport {\n  type NumberToHexErrorType,\n  numberToHex,\n} from '../../utils/encoding/toHex.js'\nimport { serializeSignature } from '../../utils/signature/serializeSignature.js'\n\ntype To = 'object' | 'bytes' | 'hex'\n\nexport type SignParameters<to extends To = 'object'> = {\n  hash: Hex\n  privateKey: Hex\n  to?: to | To | undefined\n}\n\nexport type SignReturnType<to extends To = 'object'> =\n  | (to extends 'object' ? Signature : never)\n  | (to extends 'bytes' ? ByteArray : never)\n  | (to extends 'hex' ? Hex : never)\n\nexport type SignErrorType =\n  | HexToBytesErrorType\n  | IsHexErrorType\n  | NumberToHexErrorType\n  | ErrorType\n\nlet extraEntropy: Hex | boolean = false\n\n/**\n * Sets extra entropy for signing functions.\n */\nexport function setSignEntropy(entropy: true | Hex) {\n  if (!entropy) throw new Error('must be a `true` or a hex value.')\n  extraEntropy = entropy\n}\n\n/**\n * @description Signs a hash with a given private key.\n *\n * @param hash The hash to sign.\n * @param privateKey The private key to sign with.\n *\n * @returns The signature.\n */\nexport async function sign<to extends To = 'object'>({\n  hash,\n  privateKey,\n  to = 'object',\n}: SignParameters<to>): Promise<SignReturnType<to>> {\n  const { r, s, recovery } = secp256k1.sign(\n    hash.slice(2),\n    privateKey.slice(2),\n    {\n      lowS: true,\n      extraEntropy: isHex(extraEntropy, { strict: false })\n        ? hexToBytes(extraEntropy)\n        : extraEntropy,\n    },\n  )\n  const signature = {\n    r: numberToHex(r, { size: 32 }),\n    s: numberToHex(s, { size: 32 }),\n    v: recovery ? 28n : 27n,\n    yParity: recovery,\n  }\n  return (() => {\n    if (to === 'bytes' || to === 'hex')\n      return serializeSignature({ ...signature, to })\n    return signature\n  })() as SignReturnType<to>\n}\n","import type { ErrorType } from '../../errors/utils.js'\nimport type {\n  AuthorizationRequest,\n  SignedAuthorization,\n} from '../../types/authorization.js'\nimport type { Hex, Signature } from '../../types/misc.js'\nimport type { Prettify } from '../../types/utils.js'\nimport {\n  type HashAuthorizationErrorType,\n  hashAuthorization,\n} from '../../utils/authorization/hashAuthorization.js'\nimport {\n  type SignErrorType,\n  type SignParameters,\n  type SignReturnType,\n  sign,\n} from './sign.js'\n\ntype To = 'object' | 'bytes' | 'hex'\n\nexport type SignAuthorizationParameters<to extends To = 'object'> =\n  AuthorizationRequest & {\n    /** The private key to sign with. */\n    privateKey: Hex\n    to?: SignParameters<to>['to'] | undefined\n  }\n\nexport type SignAuthorizationReturnType<to extends To = 'object'> = Prettify<\n  to extends 'object' ? SignedAuthorization : SignReturnType<to>\n>\n\nexport type SignAuthorizationErrorType =\n  | SignErrorType\n  | HashAuthorizationErrorType\n  | ErrorType\n\n/**\n * Signs an Authorization hash in [EIP-7702 format](https://eips.ethereum.org/EIPS/eip-7702): `keccak256('0x05' || rlp([chain_id, address, nonce]))`.\n */\nexport async function signAuthorization<to extends To = 'object'>(\n  parameters: SignAuthorizationParameters<to>,\n): Promise<SignAuthorizationReturnType<to>> {\n  const { chainId, nonce, privateKey, to = 'object' } = parameters\n  const address = parameters.contractAddress ?? parameters.address\n  const signature = await sign({\n    hash: hashAuthorization({ address, chainId, nonce }),\n    privateKey,\n    to,\n  })\n  if (to === 'object')\n    return {\n      address,\n      chainId,\n      nonce,\n      ...(signature as Signature),\n    } as any\n  return signature as any\n}\n","import type { ErrorType } from '../../errors/utils.js'\nimport type { Hex, SignableMessage } from '../../types/misc.js'\nimport {\n  type HashMessageErrorType,\n  hashMessage,\n} from '../../utils/signature/hashMessage.js'\n\nimport { type SignErrorType, sign } from './sign.js'\n\nexport type SignMessageParameters = {\n  /** The message to sign. */\n  message: SignableMessage\n  /** The private key to sign with. */\n  privateKey: Hex\n}\n\nexport type SignMessageReturnType = Hex\n\nexport type SignMessageErrorType =\n  | SignErrorType\n  | HashMessageErrorType\n  | ErrorType\n\n/**\n * @description Calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191):\n * `keccak256(\"\\x19Ethereum Signed Message:\\n\" + len(message) + message))`.\n *\n * @returns The signature.\n */\nexport async function signMessage({\n  message,\n  privateKey,\n}: SignMessageParameters): Promise<SignMessageReturnType> {\n  return await sign({ hash: hashMessage(message), privateKey, to: 'hex' })\n}\n","import type { ErrorType } from '../../errors/utils.js'\nimport type { Hex } from '../../types/misc.js'\nimport type {\n  TransactionSerializable,\n  TransactionSerialized,\n} from '../../types/transaction.js'\nimport {\n  type Keccak256ErrorType,\n  keccak256,\n} from '../../utils/hash/keccak256.js'\nimport type { GetTransactionType } from '../../utils/transaction/getTransactionType.js'\nimport {\n  type SerializeTransactionFn,\n  serializeTransaction,\n} from '../../utils/transaction/serializeTransaction.js'\n\nimport { type SignErrorType, sign } from './sign.js'\n\nexport type SignTransactionParameters<\n  serializer extends\n    SerializeTransactionFn<TransactionSerializable> = SerializeTransactionFn<TransactionSerializable>,\n  transaction extends Parameters<serializer>[0] = Parameters<serializer>[0],\n> = {\n  privateKey: Hex\n  transaction: transaction\n  serializer?: serializer | undefined\n}\n\nexport type SignTransactionReturnType<\n  serializer extends\n    SerializeTransactionFn<TransactionSerializable> = SerializeTransactionFn<TransactionSerializable>,\n  transaction extends Parameters<serializer>[0] = Parameters<serializer>[0],\n> = TransactionSerialized<GetTransactionType<transaction>>\n\nexport type SignTransactionErrorType =\n  | Keccak256ErrorType\n  | SignErrorType\n  | ErrorType\n\nexport async function signTransaction<\n  serializer extends\n    SerializeTransactionFn<TransactionSerializable> = SerializeTransactionFn<TransactionSerializable>,\n  transaction extends Parameters<serializer>[0] = Parameters<serializer>[0],\n>(\n  parameters: SignTransactionParameters<serializer, transaction>,\n): Promise<SignTransactionReturnType<serializer, transaction>> {\n  const {\n    privateKey,\n    transaction,\n    serializer = serializeTransaction,\n  } = parameters\n\n  const signableTransaction = (() => {\n    // For EIP-4844 Transactions, we want to sign the transaction payload body (tx_payload_body) without the sidecars (ie. without the network wrapper).\n    // See: https://github.com/ethereum/EIPs/blob/e00f4daa66bd56e2dbd5f1d36d09fd613811a48b/EIPS/eip-4844.md#networking\n    if (transaction.type === 'eip4844')\n      return {\n        ...transaction,\n        sidecars: false,\n      }\n    return transaction\n  })()\n\n  const signature = await sign({\n    hash: keccak256(await serializer(signableTransaction)),\n    privateKey,\n  })\n  return (await serializer(\n    transaction,\n    signature,\n  )) as SignTransactionReturnType<serializer, transaction>\n}\n","import type { TypedData } from 'abitype'\nimport type { ErrorType } from '../../errors/utils.js'\nimport type { Hex } from '../../types/misc.js'\nimport type { TypedDataDefinition } from '../../types/typedData.js'\nimport {\n  type HashTypedDataErrorType,\n  hashTypedData,\n} from '../../utils/signature/hashTypedData.js'\nimport { type SignErrorType, sign } from './sign.js'\n\nexport type SignTypedDataParameters<\n  typedData extends TypedData | Record<string, unknown> = TypedData,\n  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,\n> = TypedDataDefinition<typedData, primaryType> & {\n  /** The private key to sign with. */\n  privateKey: Hex\n}\n\nexport type SignTypedDataReturnType = Hex\n\nexport type SignTypedDataErrorType =\n  | HashTypedDataErrorType\n  | SignErrorType\n  | ErrorType\n\n/**\n * @description Signs typed data and calculates an Ethereum-specific signature in [https://eips.ethereum.org/EIPS/eip-712](https://eips.ethereum.org/EIPS/eip-712):\n * `sign(keccak256(\"\\x19\\x01\" ‖ domainSeparator ‖ hashStruct(message)))`.\n *\n * @returns The signature.\n */\nexport async function signTypedData<\n  const typedData extends TypedData | Record<string, unknown>,\n  primaryType extends keyof typedData | 'EIP712Domain',\n>(\n  parameters: SignTypedDataParameters<typedData, primaryType>,\n): Promise<SignTypedDataReturnType> {\n  const { privateKey, ...typedData } =\n    parameters as unknown as SignTypedDataParameters\n  return await sign({\n    hash: hashTypedData(typedData),\n    privateKey,\n    to: 'hex',\n  })\n}\n","import { secp256k1 } from '@noble/curves/secp256k1'\nimport type { ErrorType } from '../errors/utils.js'\nimport type { Hex } from '../types/misc.js'\nimport { type ToHexErrorType, toHex } from '../utils/encoding/toHex.js'\nimport type { NonceManager } from '../utils/nonceManager.js'\nimport { type ToAccountErrorType, toAccount } from './toAccount.js'\nimport type { PrivateKeyAccount } from './types.js'\nimport {\n  type PublicKeyToAddressErrorType,\n  publicKeyToAddress,\n} from './utils/publicKeyToAddress.js'\nimport { type SignErrorType, sign } from './utils/sign.js'\nimport { signAuthorization } from './utils/signAuthorization.js'\nimport { type SignMessageErrorType, signMessage } from './utils/signMessage.js'\nimport {\n  type SignTransactionErrorType,\n  signTransaction,\n} from './utils/signTransaction.js'\nimport {\n  type SignTypedDataErrorType,\n  signTypedData,\n} from './utils/signTypedData.js'\n\nexport type PrivateKeyToAccountOptions = {\n  nonceManager?: NonceManager | undefined\n}\n\nexport type PrivateKeyToAccountErrorType =\n  | ToAccountErrorType\n  | ToHexErrorType\n  | PublicKeyToAddressErrorType\n  | SignErrorType\n  | SignMessageErrorType\n  | SignTransactionErrorType\n  | SignTypedDataErrorType\n  | ErrorType\n\n/**\n * @description Creates an Account from a private key.\n *\n * @returns A Private Key Account.\n */\nexport function privateKeyToAccount(\n  privateKey: Hex,\n  options: PrivateKeyToAccountOptions = {},\n): PrivateKeyAccount {\n  const { nonceManager } = options\n  const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false))\n  const address = publicKeyToAddress(publicKey)\n\n  const account = toAccount({\n    address,\n    nonceManager,\n    async sign({ hash }) {\n      return sign({ hash, privateKey, to: 'hex' })\n    },\n    async signAuthorization(authorization) {\n      return signAuthorization({ ...authorization, privateKey })\n    },\n    async signMessage({ message }) {\n      return signMessage({ message, privateKey })\n    },\n    async signTransaction(transaction, { serializer } = {}) {\n      return signTransaction({ privateKey, transaction, serializer })\n    },\n    async signTypedData(typedData) {\n      return signTypedData({ ...typedData, privateKey } as any)\n    },\n  })\n\n  return {\n    ...account,\n    publicKey,\n    source: 'privateKey',\n  } as PrivateKeyAccount\n}\n","import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';\nimport type { PrivateKeyAccount } from 'viem/accounts';\nimport type { Address, Hex } from 'viem';\nimport { CliError } from '../errors';\nimport { walletPath } from '../paths';\nimport {\n  PRIVATE_KEY_RE,\n  readWalletRecord,\n  walletFileMode,\n  writeWalletRecord,\n  type WalletRecord,\n} from './store';\nimport type {\n  TenjinSigner,\n  WalletDescription,\n  WalletDiagnostics,\n  WalletProvider,\n} from './provider';\n\nexport interface LocalProviderDeps {\n  dir: string;\n  env: NodeJS.ProcessEnv;\n}\n\nconst isWindows = process.platform === 'win32';\n\n/**\n * The only real B1 provider: a local viem account whose key comes from the env\n * override or the wallet file. Together with the lifecycle helpers below, this is\n * the ONLY module that knows raw keys exist — `describe()` returns just the\n * address and posture, so `show`/`balance` stay keyless; `getSigner()` is the\n * single door to the key material.\n */\nexport function createLocalProvider(deps: LocalProviderDeps): WalletProvider {\n  return {\n    id: 'local',\n    async describe(): Promise<WalletDescription> {\n      const cred = resolveCredentialOrThrow(await loadCredential(deps));\n      return {\n        // A stored address is only a claim; accountForCredential derives from the\n        // key and rejects a record whose address does not match, so show/balance\n        // can never display an address the key would not sign as.\n        address: accountForCredential(cred).address,\n        provider: 'local',\n        credentialSource: cred.source,\n        policyEnforcement: 'client-only',\n      };\n    },\n    async getSigner(): Promise<TenjinSigner> {\n      const cred = resolveCredentialOrThrow(await loadCredential(deps));\n      const account = accountForCredential(cred);\n      return {\n        address: account.address,\n        signMessage: (args) => account.signMessage({ message: args.message }),\n        signTypedData: (args) => account.signTypedData(args),\n      };\n    },\n    diagnostics(): Promise<WalletDiagnostics> {\n      return localWalletDiagnostics(deps);\n    },\n  };\n}\n\n/**\n * File-custody warnings for the local provider: an env key shadowing the file,\n * non-0600 perms, and the Windows \"perms not checkable\" note. Keyless. walletPath\n * is reported only when the file actually exists, so a pure-env caller advertises\n * no on-disk path. This is the ONLY place these local-only signals live — `show`\n * and `doctor` render what the active provider returns, never their own fs probe.\n */\nexport async function localWalletDiagnostics(deps: LocalProviderDeps): Promise<WalletDiagnostics> {\n  const mode = await walletFileMode(deps.dir);\n  const fileExists = mode !== null;\n  const envKey = deps.env.TENJIN_WALLET_KEY;\n  const envSet = envKey !== undefined && envKey.length > 0;\n  const path = walletPath(deps.dir);\n\n  const warnings: string[] = [];\n  if (envSet && fileExists) {\n    warnings.push('TENJIN_WALLET_KEY is set and shadows the wallet file at runtime.');\n  }\n  if (mode !== null) {\n    if (isWindows) {\n      warnings.push('File permission checks are not available on Windows.');\n    } else if (mode !== 0o600) {\n      warnings.push(\n        `Wallet file permissions are ${mode.toString(8)}, expected 600. Run \\`chmod 600 ${path}\\`.`,\n      );\n    }\n  }\n  return { ...(fileExists ? { walletPath: path } : {}), warnings };\n}\n\nexport interface LocalWalletInfo {\n  address: Address;\n  walletPath: string;\n}\n\n/**\n * Generate a fresh key and persist it NO-CLOBBER, returning the address and path.\n * The write, not a caller's pre-check, is the authority: a lost create/import\n * race throws WALLET_EXISTS rather than overwriting a funded key.\n */\nexport async function createLocalWallet(dir: string): Promise<LocalWalletInfo> {\n  const key = generatePrivateKey();\n  const address = privateKeyToAccount(key).address;\n  await writeWalletRecord(dir, walletRecord(address, key));\n  return { address, walletPath: walletPath(dir) };\n}\n\n/**\n * Validate an imported key and persist it NO-CLOBBER. WALLET_INVALID_KEY for a\n * bad format or an out-of-range scalar; WALLET_EXISTS if a wallet already exists.\n */\nexport async function importLocalWallet(dir: string, key: string): Promise<LocalWalletInfo> {\n  if (!PRIVATE_KEY_RE.test(key)) {\n    throw new CliError('WALLET_INVALID_KEY', 'The provided key is not a valid private key.', {\n      fix: 'Provide a 0x-prefixed 32-byte hex private key.',\n    });\n  }\n  let address: Address;\n  try {\n    address = privateKeyToAccount(key as Hex).address;\n  } catch (err) {\n    throw new CliError('WALLET_INVALID_KEY', 'The provided key is not a valid secp256k1 key.', {\n      fix: 'Provide a 0x-prefixed 32-byte hex key within the curve order.',\n      cause: err,\n    });\n  }\n  await writeWalletRecord(dir, walletRecord(address, key as Hex));\n  return { address, walletPath: walletPath(dir) };\n}\n\ntype Credential = { source: 'env'; key: Hex } | { source: 'file'; key: Hex; address: Address };\n\n/** Env override beats the wallet file (CI + ephemeral agents); null when neither exists. */\nasync function loadCredential(deps: LocalProviderDeps): Promise<Credential | null> {\n  const envKey = deps.env.TENJIN_WALLET_KEY;\n  if (envKey !== undefined && envKey.trim().length > 0) {\n    const key = envKey.trim();\n    if (!PRIVATE_KEY_RE.test(key)) {\n      throw new CliError('WALLET_INVALID_KEY', 'TENJIN_WALLET_KEY is not a valid private key.', {\n        fix: 'Set TENJIN_WALLET_KEY to a 0x-prefixed 32-byte hex key, or unset it to use the wallet file.',\n      });\n    }\n    return { source: 'env', key: key as Hex };\n  }\n  const record = await readWalletRecord(deps.dir);\n  if (record !== null) {\n    return { source: 'file', key: record.privateKey as Hex, address: record.address as Address };\n  }\n  return null;\n}\n\n/**\n * Build the viem account from a credential, mapping viem's throw on an invalid\n * key to WALLET_INVALID_KEY. For a FILE credential, also require the stored\n * address to match what the key derives (EIP-55 normalized): a stale or tampered\n * record that would show address A but sign as B is rejected, not trusted.\n */\nfunction accountForCredential(cred: Credential): PrivateKeyAccount {\n  let account: PrivateKeyAccount;\n  try {\n    account = privateKeyToAccount(cred.key);\n  } catch (err) {\n    throw new CliError('WALLET_INVALID_KEY', 'The private key is not a valid secp256k1 key.', {\n      fix:\n        cred.source === 'file'\n          ? 'Move the wallet file aside, then re-import the intended key.'\n          : 'Set TENJIN_WALLET_KEY to a valid 0x-prefixed 32-byte hex key.',\n      cause: err,\n    });\n  }\n  if (cred.source === 'file' && account.address.toLowerCase() !== cred.address.toLowerCase()) {\n    throw new CliError(\n      'WALLET_INVALID_KEY',\n      `The wallet file's stored address ${cred.address} does not match its private key (derives ${account.address}).`,\n      { fix: 'Move the wallet file aside, then re-import the intended key.' },\n    );\n  }\n  return account;\n}\n\nfunction resolveCredentialOrThrow(cred: Credential | null): Credential {\n  if (cred === null) {\n    throw new CliError('WALLET_MISSING', 'No wallet found.', {\n      fix: 'Run `tenjin wallet create` to create one.',\n    });\n  }\n  return cred;\n}\n\nfunction walletRecord(address: Address, privateKey: Hex): WalletRecord {\n  return {\n    schemaVersion: 1,\n    provider: 'local',\n    address,\n    privateKey,\n    createdAt: new Date().toISOString(),\n  };\n}\n","import { CliError } from '../errors';\nimport { createLocalProvider } from './local';\nimport type { CommandContext } from '../../context';\nimport type { WalletDescription, WalletProvider } from './provider';\n\nexport * from './provider';\nexport { createLocalWallet, importLocalWallet, type LocalWalletInfo } from './local';\n\nexport interface ResolveWalletProviderOptions {\n  /** Test-injection seam: bypass the local provider with a fake (e.g. a remote stub). */\n  provider?: WalletProvider;\n}\n\n/**\n * The commands' one entry to a wallet. Production always gets the `local`\n * provider bound to the context's data dir and process env; tests pass\n * `opts.provider` to prove `show`/`balance` work against any provider without a\n * real key on disk.\n */\nexport function resolveWalletProvider(\n  ctx: CommandContext,\n  opts: ResolveWalletProviderOptions = {},\n): WalletProvider {\n  if (opts.provider !== undefined) return opts.provider;\n  return createLocalProvider({ dir: ctx.dataDir, env: process.env });\n}\n\n/**\n * Call `describe()` through the error contract: a CliError (e.g. WALLET_MISSING\n * from the local provider) passes through, but any other rejection — a remote\n * provider's network/refusal error — normalizes to PROVIDER_ERROR so callers\n * always see a coded failure, never a bare stack trace.\n */\nexport async function describeWallet(provider: WalletProvider): Promise<WalletDescription> {\n  try {\n    return await provider.describe();\n  } catch (err) {\n    if (err instanceof CliError) throw err;\n    const message = err instanceof Error ? err.message : 'unknown error';\n    throw new CliError('PROVIDER_ERROR', `Wallet provider \"${provider.id}\" failed: ${message}`, {\n      fix: 'Check the wallet provider and try again.',\n      cause: err,\n    });\n  }\n}\n"],"mappings":"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","names":[]}