x402z-shared-web 0.0.9

package/dist/index.mjs

@@ -0,0 +1,531 @@
+// src/core/abi.ts
+var confidentialTokenAbi = [
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "bytes32", name: "encryptedAmountInput", type: "bytes32" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" }
+    ],
+    name: "confidentialTransfer",
+    outputs: [{ internalType: "euint64", name: "transferred", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "holder", type: "address" },
+          { internalType: "address", name: "payee", type: "address" },
+          { internalType: "uint256", name: "maxClearAmount", type: "uint256" },
+          { internalType: "bytes32", name: "resourceHash", type: "bytes32" },
+          { internalType: "uint48", name: "validAfter", type: "uint48" },
+          { internalType: "uint48", name: "validBefore", type: "uint48" },
+          { internalType: "bytes32", name: "nonce", type: "bytes32" },
+          { internalType: "bytes32", name: "encryptedAmountHash", type: "bytes32" }
+        ],
+        internalType: "struct FHEToken.ConfidentialPayment",
+        name: "p",
+        type: "tuple"
+      },
+      { internalType: "externalEuint64", name: "encryptedAmountInput", type: "bytes32" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" },
+      { internalType: "bytes", name: "sig", type: "bytes" }
+    ],
+    name: "confidentialTransferWithAuthorization",
+    outputs: [{ internalType: "euint64", name: "transferred", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" }
+    ],
+    name: "wrap",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "from", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "bytes32", name: "encryptedAmountInput", type: "bytes32" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" }
+    ],
+    name: "unwrap",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "holder", type: "address" },
+      { indexed: true, internalType: "address", name: "payee", type: "address" },
+      { indexed: false, internalType: "uint256", name: "maxClearAmount", type: "uint256" },
+      { indexed: true, internalType: "bytes32", name: "resourceHash", type: "bytes32" },
+      { indexed: false, internalType: "bytes32", name: "nonce", type: "bytes32" },
+      { indexed: false, internalType: "bytes32", name: "transferredAmount", type: "bytes32" }
+    ],
+    name: "ConfidentialPaymentExecuted",
+    type: "event"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "", type: "address" },
+      { internalType: "bytes32", name: "", type: "bytes32" }
+    ],
+    name: "usedNonces",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "account", type: "address" }],
+    name: "observer",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "account", type: "address" },
+      { internalType: "address", name: "newObserver", type: "address" }
+    ],
+    name: "setObserver",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/core/constants.ts
+var confidentialPaymentTypes = {
+  ConfidentialPayment: [
+    { name: "holder", type: "address" },
+    { name: "payee", type: "address" },
+    { name: "maxClearAmount", type: "uint256" },
+    { name: "resourceHash", type: "bytes32" },
+    { name: "validAfter", type: "uint48" },
+    { name: "validBefore", type: "uint48" },
+    { name: "nonce", type: "bytes32" },
+    { name: "encryptedAmountHash", type: "bytes32" }
+  ]
+};
+var confidentialErrorCodes = {
+  observerNotAuthorized: "observer_not_authorized"
+};
+
+// src/core/utils.ts
+import { encodeAbiParameters, keccak256, toHex } from "viem";
+function createNonce() {
+  const cryptoObj = typeof globalThis.crypto !== "undefined" ? globalThis.crypto : globalThis.crypto;
+  if (!cryptoObj) {
+    throw new Error("Crypto API not available");
+  }
+  return toHex(cryptoObj.getRandomValues(new Uint8Array(32)));
+}
+function hashEncryptedAmountInput(encryptedAmountInput) {
+  return keccak256(
+    encodeAbiParameters([{ type: "bytes32" }], [encryptedAmountInput])
+  );
+}
+function normalizeAmount(amount) {
+  if (typeof amount === "string") {
+    return amount;
+  }
+  if (typeof amount === "number") {
+    if (!Number.isFinite(amount)) {
+      throw new Error("Invalid amount");
+    }
+    return Math.trunc(amount).toString();
+  }
+  return amount.toString();
+}
+
+// src/relayer/index.ts
+import { getAddress, toHex as toHex2 } from "viem";
+var relayerSdk = null;
+var SepoliaConfig;
+async function getRelayerSdk() {
+  if (relayerSdk) {
+    return relayerSdk;
+  }
+  throw new Error(
+    "Relayer SDK not configured. Call configureRelayerSdk() with the CDN module before initSDK/createRelayer."
+  );
+}
+function configureRelayerSdk(sdk) {
+  relayerSdk = sdk;
+  SepoliaConfig = sdk.SepoliaConfig;
+}
+function getSepoliaConfig() {
+  if (!SepoliaConfig) {
+    throw new Error("SepoliaConfig is not available; call configureRelayerSdk or initSDK first");
+  }
+  return SepoliaConfig;
+}
+async function createRelayer(config) {
+  const sdk = await getRelayerSdk();
+  const instance = await sdk.createInstance(config);
+  if (typeof config.network === "string") {
+    instance.network = config.network;
+  }
+  return instance;
+}
+async function initSDK(params) {
+  const sdk = await getRelayerSdk();
+  return sdk.initSDK(params);
+}
+async function createEncryptedAmountInput(relayer, contractAddress, senderAddress, amount) {
+  const normalizedContract = getAddress(contractAddress);
+  const normalizedSender = getAddress(senderAddress);
+  const encrypted = await relayer.createEncryptedInput(normalizedContract, normalizedSender).add64(amount).encrypt();
+  const handle = typeof encrypted.handles[0] === "string" ? encrypted.handles[0] : toHex2(encrypted.handles[0]);
+  const inputProof = typeof encrypted.inputProof === "string" ? encrypted.inputProof : toHex2(encrypted.inputProof);
+  return {
+    handle,
+    inputProof
+  };
+}
+async function decryptEuint64(relayer, handle, contractAddress, signer, options) {
+  const keypair = relayer.generateKeypair();
+  const startTimestamp = options?.startTimestamp ?? Math.floor(Date.now() / 1e3).toString();
+  const durationDays = options?.durationDays ?? "10";
+  const contractAddresses = [contractAddress];
+  const eip712 = relayer.createEIP712(keypair.publicKey, contractAddresses, startTimestamp, durationDays);
+  const types = { UserDecryptRequestVerification: eip712.types.UserDecryptRequestVerification };
+  const sign = signer.signTypedData;
+  const signature = sign.length >= 3 ? await sign(eip712.domain, types, eip712.message) : await sign({
+    domain: eip712.domain,
+    types,
+    primaryType: "UserDecryptRequestVerification",
+    message: eip712.message
+  });
+  const result = await relayer.userDecrypt(
+    [{ handle, contractAddress }],
+    keypair.privateKey,
+    keypair.publicKey,
+    signature.replace("0x", ""),
+    contractAddresses,
+    signer.address,
+    startTimestamp,
+    durationDays
+  );
+  return result[handle];
+}
+async function publicDecrypt(relayer, handles) {
+  const result = await relayer.publicDecrypt(handles);
+  return {
+    clearValues: result.clearValues,
+    decryptionProof: result.decryptionProof
+  };
+}
+
+// src/token/transfer.ts
+import { createPublicClient, decodeEventLog, getAddress as getAddress2, http, isAddress, isHex, isAddressEqual } from "viem";
+async function getTransferAmounts(options) {
+  if (!isAddress(options.tokenAddress)) {
+    throw new Error(`Invalid token address: ${options.tokenAddress}`);
+  }
+  if (!isHex(options.txHash, { strict: true })) {
+    throw new Error(`Invalid transaction hash: ${options.txHash}`);
+  }
+  if (options.from && !isAddress(options.from)) {
+    throw new Error(`Invalid from address: ${options.from}`);
+  }
+  if (options.to && !isAddress(options.to)) {
+    throw new Error(`Invalid to address: ${options.to}`);
+  }
+  const publicClient = createPublicClient({ transport: http(options.rpcUrl) });
+  const receipt = await publicClient.getTransactionReceipt({
+    hash: options.txHash
+  });
+  const tokenAddress = getAddress2(options.tokenAddress);
+  const fromFilter = options.from ? getAddress2(options.from) : void 0;
+  const toFilter = options.to ? getAddress2(options.to) : void 0;
+  const logs = receipt.logs.filter((log) => getAddress2(log.address) === tokenAddress);
+  const transfers = [];
+  for (const log of logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: confidentialTokenAbi,
+        eventName: "ConfidentialPaymentExecuted",
+        data: log.data,
+        topics: log.topics
+      });
+      const args = decoded.args;
+      const entry = {
+        holder: getAddress2(args.holder),
+        payee: getAddress2(args.payee),
+        maxClearAmount: BigInt(args.maxClearAmount),
+        resourceHash: args.resourceHash,
+        nonce: args.nonce,
+        handle: args.transferredAmount
+      };
+      if (fromFilter && entry.holder !== fromFilter) {
+        continue;
+      }
+      if (toFilter && entry.payee !== toFilter) {
+        continue;
+      }
+      const shouldDecrypt = options.decrypt ?? true;
+      if (shouldDecrypt) {
+        if (!options.signer) {
+          throw new Error("Missing signer for decryption");
+        }
+        const signerAddress = getAddress2(options.signer.address);
+        const holderAddress = getAddress2(entry.holder);
+        const payeeAddress = getAddress2(entry.payee);
+        if (!isAddressEqual(signerAddress, holderAddress) && !isAddressEqual(signerAddress, payeeAddress)) {
+          const [holderObserver, payeeObserver] = await Promise.all([
+            publicClient.readContract({
+              address: tokenAddress,
+              abi: confidentialTokenAbi,
+              functionName: "observer",
+              args: [holderAddress]
+            }),
+            publicClient.readContract({
+              address: tokenAddress,
+              abi: confidentialTokenAbi,
+              functionName: "observer",
+              args: [payeeAddress]
+            })
+          ]);
+          const allowed = holderObserver && isAddressEqual(holderObserver, signerAddress) || payeeObserver && isAddressEqual(payeeObserver, signerAddress);
+          if (!allowed) {
+            throw new Error(confidentialErrorCodes.observerNotAuthorized);
+          }
+        }
+        entry.amount = await decryptEuint64(
+          options.relayer,
+          entry.handle,
+          tokenAddress,
+          options.signer
+        );
+      }
+      transfers.push(entry);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("ConfidentialPaymentExecuted")) {
+        throw error;
+      }
+    }
+  }
+  return transfers;
+}
+
+// src/token/token.ts
+import { getAddress as getAddress5, isAddress as isAddress4 } from "viem";
+
+// src/token/balance.ts
+import { createPublicClient as createPublicClient2, getAddress as getAddress3, http as http2, isAddress as isAddress2, isAddressEqual as isAddressEqual2 } from "viem";
+var ZERO_HANDLE = "0x" + "00".repeat(32);
+async function readBalance(options) {
+  if (!isAddress2(options.tokenAddress)) {
+    throw new Error(`Invalid token address: ${options.tokenAddress}`);
+  }
+  const account = options.account ?? options.signer?.address;
+  if (!account || !isAddress2(account)) {
+    throw new Error(`Invalid account address: ${account ?? "undefined"}`);
+  }
+  const publicClient = createPublicClient2({ transport: http2(options.rpcUrl) });
+  const confidentialBalanceAbi = [
+    {
+      inputs: [{ internalType: "address", name: "account", type: "address" }],
+      name: "confidentialBalanceOf",
+      outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+      stateMutability: "view",
+      type: "function"
+    }
+  ];
+  const handle = await publicClient.readContract({
+    address: options.tokenAddress,
+    abi: confidentialBalanceAbi,
+    functionName: "confidentialBalanceOf",
+    args: [account]
+  });
+  const shouldDecrypt = options.decrypt ?? true;
+  if (!shouldDecrypt) {
+    return { handle };
+  }
+  if (!options.signer) {
+    throw new Error("Missing signer for decryption");
+  }
+  const signerAddress = getAddress3(options.signer.address);
+  if (!isAddressEqual2(signerAddress, getAddress3(account))) {
+    const observer = await publicClient.readContract({
+      address: options.tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "observer",
+      args: [account]
+    });
+    if (!observer || !isAddressEqual2(observer, signerAddress)) {
+      throw new Error(confidentialErrorCodes.observerNotAuthorized);
+    }
+  }
+  if (handle === ZERO_HANDLE) {
+    return { handle, balance: 0n };
+  }
+  const balance = await decryptEuint64(options.relayer, handle, options.tokenAddress, options.signer);
+  return { handle, balance };
+}
+
+// src/token/observer.ts
+import { getAddress as getAddress4, isAddress as isAddress3 } from "viem";
+async function setObserver(options) {
+  if (!isAddress3(options.tokenAddress)) {
+    throw new Error(`Invalid token address: ${options.tokenAddress}`);
+  }
+  if (!isAddress3(options.account)) {
+    throw new Error(`Invalid account address: ${options.account}`);
+  }
+  if (!isAddress3(options.observer)) {
+    throw new Error(`Invalid observer address: ${options.observer}`);
+  }
+  return options.walletClient.writeContract({
+    address: getAddress4(options.tokenAddress),
+    abi: confidentialTokenAbi,
+    functionName: "setObserver",
+    args: [getAddress4(options.account), getAddress4(options.observer)],
+    chain: options.walletClient.chain ?? null,
+    account: options.signer ?? options.walletClient.account ?? null
+  });
+}
+
+// src/token/token.ts
+function assertAddress(value, label) {
+  if (!isAddress4(value)) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return getAddress5(value);
+}
+function resolveSignerAddress(signer, walletClient) {
+  if (signer?.address) {
+    return assertAddress(signer.address, "signer address");
+  }
+  const account = walletClient.account;
+  if (typeof account === "string") {
+    return assertAddress(account, "wallet address");
+  }
+  if (account && typeof account === "object" && "address" in account && account.address) {
+    return assertAddress(account.address, "wallet address");
+  }
+  throw new Error("Missing signer address");
+}
+function resolveWriteAccount(signer, walletClient) {
+  if (signer?.address) {
+    return assertAddress(signer.address, "signer address");
+  }
+  const account = walletClient.account;
+  if (typeof account === "string") {
+    return assertAddress(account, "wallet address");
+  }
+  return account ?? null;
+}
+var ConfidentialToken = class {
+  constructor(config) {
+    this.rpcUrl = config.rpcUrl;
+    this.tokenAddress = config.tokenAddress;
+    this.relayer = config.relayer;
+    this.walletClient = config.walletClient;
+    this.signer = config.signer;
+  }
+  async balanceOf(account) {
+    const result = await readBalance({
+      rpcUrl: this.rpcUrl,
+      tokenAddress: this.tokenAddress,
+      account,
+      relayer: this.relayer,
+      signer: this.signer,
+      decrypt: true
+    });
+    return result.balance ?? 0n;
+  }
+  async setObserver(account, observer) {
+    return setObserver({
+      tokenAddress: this.tokenAddress,
+      account,
+      observer,
+      signer: this.signer?.address ? assertAddress(this.signer.address, "signer address") : void 0,
+      walletClient: this.walletClient
+    });
+  }
+  async transfer(to, amount) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const toAddress = assertAddress(to, "recipient address");
+    const fromAddress = resolveSignerAddress(this.signer, this.walletClient);
+    if (!Number.isSafeInteger(amount)) {
+      throw new Error("Transfer amount must be a safe integer");
+    }
+    const { handle, inputProof } = await createEncryptedAmountInput(
+      this.relayer,
+      tokenAddress,
+      fromAddress,
+      amount
+    );
+    return this.walletClient.writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "confidentialTransfer",
+      args: [toAddress, handle, inputProof],
+      chain: this.walletClient.chain ?? null,
+      account: resolveWriteAccount(this.signer, this.walletClient)
+    });
+  }
+  async wrap(to, amount) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const toAddress = assertAddress(to, "recipient address");
+    const normalizedAmount = BigInt(normalizeAmount(amount));
+    return this.walletClient.writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "wrap",
+      args: [toAddress, normalizedAmount],
+      chain: this.walletClient.chain ?? null,
+      account: resolveWriteAccount(this.signer, this.walletClient)
+    });
+  }
+  async unwrap(from, to, amount) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const fromAddress = assertAddress(from, "from address");
+    const toAddress = assertAddress(to, "to address");
+    const signerAddress = resolveSignerAddress(this.signer, this.walletClient);
+    if (!Number.isSafeInteger(amount)) {
+      throw new Error("Unwrap amount must be a safe integer");
+    }
+    const { handle, inputProof } = await createEncryptedAmountInput(
+      this.relayer,
+      tokenAddress,
+      signerAddress,
+      amount
+    );
+    return this.walletClient.writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "unwrap",
+      args: [fromAddress, toAddress, handle, inputProof],
+      chain: this.walletClient.chain ?? null,
+      account: resolveWriteAccount(this.signer, this.walletClient)
+    });
+  }
+};
+export {
+  ConfidentialToken,
+  SepoliaConfig,
+  confidentialErrorCodes,
+  confidentialPaymentTypes,
+  confidentialTokenAbi,
+  configureRelayerSdk,
+  createEncryptedAmountInput,
+  createNonce,
+  createRelayer,
+  decryptEuint64,
+  getSepoliaConfig,
+  getTransferAmounts,
+  hashEncryptedAmountInput,
+  initSDK,
+  normalizeAmount,
+  publicDecrypt
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "x402z-shared-web",
+  "version": "0.0.9",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@x402/core": "^2.0.0",
+    "@zama-fhe/relayer-sdk": "0.3.0-8",
+    "viem": "^2.39.3"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "@types/jest": "^29.5.12"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "jest"
+  }
+}