x402z-shared 0.0.4 → 0.0.6

package/dist/web.js

@@ -20,27 +20,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/web.ts
 var web_exports = {};
 __export(web_exports, {
-  SepoliaConfig: () => import_bundle.SepoliaConfig,
+  ConfidentialTokenWeb: () => ConfidentialTokenWeb,
+  SepoliaConfig: () => import_web.SepoliaConfig,
   confidentialErrorCodes: () => confidentialErrorCodes,
   confidentialPaymentTypes: () => confidentialPaymentTypes,
+  confidentialToken: () => ConfidentialTokenWeb,
   confidentialTokenAbi: () => confidentialTokenAbi,
   createEncryptedAmountInput: () => createEncryptedAmountInput,
   createNonce: () => createNonce,
   createRelayerInstance: () => createRelayerInstance,
   hashEncryptedAmountInput: () => hashEncryptedAmountInput,
-  initSDK: () => import_bundle.initSDK,
+  initSDK: () => import_web.initSDK,
   normalizeAmount: () => normalizeAmount,
   publicDecrypt: () => publicDecrypt,
-  setObserver: () => setObserver,
-  setObserverWeb: () => setObserverWeb,
   userDecryptEuint64: () => userDecryptEuint64,
-  viewConfidentialBalance: () => viewConfidentialBalance,
   viewConfidentialTransferAmounts: () => viewConfidentialTransferAmounts
 });
 module.exports = __toCommonJS(web_exports);
 
 // src/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: [
       {
@@ -67,6 +77,28 @@ var confidentialTokenAbi = [
     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: [
@@ -154,10 +186,10 @@ function normalizeAmount(amount) {
 }
 
 // src/relayer-web.ts
-var import_bundle = require("@zama-fhe/relayer-sdk/bundle");
+var import_web = require("@zama-fhe/relayer-sdk/web");
 var import_viem2 = require("viem");
 async function createRelayerInstance(config) {
-  const instance = await (0, import_bundle.createInstance)(config);
+  const instance = await (0, import_web.createInstance)(config);
   if (typeof config.network === "string") {
     instance.network = config.network;
   }
@@ -208,86 +240,33 @@ async function publicDecrypt(relayer, handles) {
   };
 }
 
-// src/balance-web.ts
-var import_viem3 = require("viem");
-var ZERO_HANDLE = "0x" + "00".repeat(32);
-async function viewConfidentialBalance(options) {
-  if (!(0, import_viem3.isAddress)(options.tokenAddress)) {
-    throw new Error(`Invalid token address: ${options.tokenAddress}`);
-  }
-  const account = options.account ?? options.signer?.address;
-  if (!account || !(0, import_viem3.isAddress)(account)) {
-    throw new Error(`Invalid account address: ${account ?? "undefined"}`);
-  }
-  const publicClient = (0, import_viem3.createPublicClient)({ transport: (0, import_viem3.http)(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 = (0, import_viem3.getAddress)(options.signer.address);
-  if (!(0, import_viem3.isAddressEqual)(signerAddress, (0, import_viem3.getAddress)(account))) {
-    const observer = await publicClient.readContract({
-      address: options.tokenAddress,
-      abi: confidentialTokenAbi,
-      functionName: "observer",
-      args: [account]
-    });
-    if (!observer || !(0, import_viem3.isAddressEqual)(observer, signerAddress)) {
-      throw new Error(confidentialErrorCodes.observerNotAuthorized);
-    }
-  }
-  if (handle === ZERO_HANDLE) {
-    return { handle, balance: 0n };
-  }
-  const balance = await userDecryptEuint64(options.relayer, handle, options.tokenAddress, options.signer);
-  return { handle, balance };
-}
-
 // src/transfer-web.ts
-var import_viem4 = require("viem");
+var import_viem3 = require("viem");
 async function viewConfidentialTransferAmounts(options) {
-  if (!(0, import_viem4.isAddress)(options.tokenAddress)) {
+  if (!(0, import_viem3.isAddress)(options.tokenAddress)) {
     throw new Error(`Invalid token address: ${options.tokenAddress}`);
   }
-  if (!(0, import_viem4.isHex)(options.txHash, { strict: true })) {
+  if (!(0, import_viem3.isHex)(options.txHash, { strict: true })) {
     throw new Error(`Invalid transaction hash: ${options.txHash}`);
   }
-  if (options.from && !(0, import_viem4.isAddress)(options.from)) {
+  if (options.from && !(0, import_viem3.isAddress)(options.from)) {
     throw new Error(`Invalid from address: ${options.from}`);
   }
-  if (options.to && !(0, import_viem4.isAddress)(options.to)) {
+  if (options.to && !(0, import_viem3.isAddress)(options.to)) {
     throw new Error(`Invalid to address: ${options.to}`);
   }
-  const publicClient = (0, import_viem4.createPublicClient)({ transport: (0, import_viem4.http)(options.rpcUrl) });
+  const publicClient = (0, import_viem3.createPublicClient)({ transport: (0, import_viem3.http)(options.rpcUrl) });
   const receipt = await publicClient.getTransactionReceipt({
     hash: options.txHash
   });
-  const tokenAddress = (0, import_viem4.getAddress)(options.tokenAddress);
-  const fromFilter = options.from ? (0, import_viem4.getAddress)(options.from) : void 0;
-  const toFilter = options.to ? (0, import_viem4.getAddress)(options.to) : void 0;
-  const logs = receipt.logs.filter((log) => (0, import_viem4.getAddress)(log.address) === tokenAddress);
+  const tokenAddress = (0, import_viem3.getAddress)(options.tokenAddress);
+  const fromFilter = options.from ? (0, import_viem3.getAddress)(options.from) : void 0;
+  const toFilter = options.to ? (0, import_viem3.getAddress)(options.to) : void 0;
+  const logs = receipt.logs.filter((log) => (0, import_viem3.getAddress)(log.address) === tokenAddress);
   const transfers = [];
   for (const log of logs) {
     try {
-      const decoded = (0, import_viem4.decodeEventLog)({
+      const decoded = (0, import_viem3.decodeEventLog)({
         abi: confidentialTokenAbi,
         eventName: "ConfidentialPaymentExecuted",
         data: log.data,
@@ -295,8 +274,8 @@ async function viewConfidentialTransferAmounts(options) {
       });
       const args = decoded.args;
       const entry = {
-        holder: (0, import_viem4.getAddress)(args.holder),
-        payee: (0, import_viem4.getAddress)(args.payee),
+        holder: (0, import_viem3.getAddress)(args.holder),
+        payee: (0, import_viem3.getAddress)(args.payee),
         maxClearAmount: BigInt(args.maxClearAmount),
         resourceHash: args.resourceHash,
         nonce: args.nonce,
@@ -313,10 +292,10 @@ async function viewConfidentialTransferAmounts(options) {
         if (!options.signer) {
           throw new Error("Missing signer for decryption");
         }
-        const signerAddress = (0, import_viem4.getAddress)(options.signer.address);
-        const holderAddress = (0, import_viem4.getAddress)(entry.holder);
-        const payeeAddress = (0, import_viem4.getAddress)(entry.payee);
-        if (!(0, import_viem4.isAddressEqual)(signerAddress, holderAddress) && !(0, import_viem4.isAddressEqual)(signerAddress, payeeAddress)) {
+        const signerAddress = (0, import_viem3.getAddress)(options.signer.address);
+        const holderAddress = (0, import_viem3.getAddress)(entry.holder);
+        const payeeAddress = (0, import_viem3.getAddress)(entry.payee);
+        if (!(0, import_viem3.isAddressEqual)(signerAddress, holderAddress) && !(0, import_viem3.isAddressEqual)(signerAddress, payeeAddress)) {
           const [holderObserver, payeeObserver] = await Promise.all([
             publicClient.readContract({
               address: tokenAddress,
@@ -331,7 +310,7 @@ async function viewConfidentialTransferAmounts(options) {
               args: [payeeAddress]
             })
           ]);
-          const allowed = holderObserver && (0, import_viem4.isAddressEqual)(holderObserver, signerAddress) || payeeObserver && (0, import_viem4.isAddressEqual)(payeeObserver, signerAddress);
+          const allowed = holderObserver && (0, import_viem3.isAddressEqual)(holderObserver, signerAddress) || payeeObserver && (0, import_viem3.isAddressEqual)(payeeObserver, signerAddress);
           if (!allowed) {
             throw new Error(confidentialErrorCodes.observerNotAuthorized);
           }
@@ -353,65 +332,208 @@ async function viewConfidentialTransferAmounts(options) {
   return transfers;
 }
 
-// src/observer.ts
-var import_viem5 = require("viem");
-async function setObserver(options) {
-  if (!(0, import_viem5.isAddress)(options.tokenAddress)) {
+// src/token-web.ts
+var import_viem6 = require("viem");
+
+// src/balance-web.ts
+var import_viem4 = require("viem");
+var ZERO_HANDLE = "0x" + "00".repeat(32);
+async function viewConfidentialBalance(options) {
+  if (!(0, import_viem4.isAddress)(options.tokenAddress)) {
     throw new Error(`Invalid token address: ${options.tokenAddress}`);
   }
-  if (!(0, import_viem5.isAddress)(options.account)) {
-    throw new Error(`Invalid account address: ${options.account}`);
-  }
-  if (!(0, import_viem5.isAddress)(options.observer)) {
-    throw new Error(`Invalid observer address: ${options.observer}`);
+  const account = options.account ?? options.signer?.address;
+  if (!account || !(0, import_viem4.isAddress)(account)) {
+    throw new Error(`Invalid account address: ${account ?? "undefined"}`);
   }
-  const tokenAddress = (0, import_viem5.getAddress)(options.tokenAddress);
-  const account = (0, import_viem5.getAddress)(options.account);
-  const observer = (0, import_viem5.getAddress)(options.observer);
-  const publicClient = (0, import_viem5.createPublicClient)({ transport: (0, import_viem5.http)(options.rpcUrl) });
-  const existing = await publicClient.readContract({
-    address: tokenAddress,
-    abi: confidentialTokenAbi,
-    functionName: "observer",
+  const publicClient = (0, import_viem4.createPublicClient)({ transport: (0, import_viem4.http)(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]
   });
-  if (existing && (0, import_viem5.isAddress)(existing) && (0, import_viem5.getAddress)(existing) === observer) {
-    return "0x" + "00".repeat(32);
+  const shouldDecrypt = options.decrypt ?? true;
+  if (!shouldDecrypt) {
+    return { handle };
   }
-  return options.signer.writeContract({
-    address: tokenAddress,
-    abi: confidentialTokenAbi,
-    functionName: "setObserver",
-    args: [account, observer]
-  });
+  if (!options.signer) {
+    throw new Error("Missing signer for decryption");
+  }
+  const signerAddress = (0, import_viem4.getAddress)(options.signer.address);
+  if (!(0, import_viem4.isAddressEqual)(signerAddress, (0, import_viem4.getAddress)(account))) {
+    const observer = await publicClient.readContract({
+      address: options.tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "observer",
+      args: [account]
+    });
+    if (!observer || !(0, import_viem4.isAddressEqual)(observer, signerAddress)) {
+      throw new Error(confidentialErrorCodes.observerNotAuthorized);
+    }
+  }
+  if (handle === ZERO_HANDLE) {
+    return { handle, balance: 0n };
+  }
+  const balance = await userDecryptEuint64(options.relayer, handle, options.tokenAddress, options.signer);
+  return { handle, balance };
 }
 
 // src/observer-web.ts
-var import_viem6 = require("viem");
+var import_viem5 = require("viem");
 async function setObserverWeb(options) {
-  if (!(0, import_viem6.isAddress)(options.tokenAddress)) {
+  if (!(0, import_viem5.isAddress)(options.tokenAddress)) {
     throw new Error(`Invalid token address: ${options.tokenAddress}`);
   }
-  if (!(0, import_viem6.isAddress)(options.account)) {
+  if (!(0, import_viem5.isAddress)(options.account)) {
     throw new Error(`Invalid account address: ${options.account}`);
   }
-  if (!(0, import_viem6.isAddress)(options.observer)) {
+  if (!(0, import_viem5.isAddress)(options.observer)) {
     throw new Error(`Invalid observer address: ${options.observer}`);
   }
   return options.walletClient.writeContract({
-    address: (0, import_viem6.getAddress)(options.tokenAddress),
+    address: (0, import_viem5.getAddress)(options.tokenAddress),
     abi: confidentialTokenAbi,
     functionName: "setObserver",
-    args: [(0, import_viem6.getAddress)(options.account), (0, import_viem6.getAddress)(options.observer)],
+    args: [(0, import_viem5.getAddress)(options.account), (0, import_viem5.getAddress)(options.observer)],
     chain: options.walletClient.chain ?? null,
     account: options.signer ?? options.walletClient.account ?? null
   });
 }
+
+// src/token-web.ts
+function assertAddress(value, label) {
+  if (!(0, import_viem6.isAddress)(value)) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return (0, import_viem6.getAddress)(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 ConfidentialTokenWeb = 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 viewConfidentialBalance({
+      rpcUrl: this.rpcUrl,
+      tokenAddress: this.tokenAddress,
+      account,
+      relayer: this.relayer,
+      signer: this.signer,
+      decrypt: true
+    });
+    return result.balance ?? 0n;
+  }
+  async setObserver(account, observer) {
+    return setObserverWeb({
+      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)
+    });
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ConfidentialTokenWeb,
   SepoliaConfig,
   confidentialErrorCodes,
   confidentialPaymentTypes,
+  confidentialToken,
   confidentialTokenAbi,
   createEncryptedAmountInput,
   createNonce,
@@ -420,9 +542,6 @@ async function setObserverWeb(options) {
   initSDK,
   normalizeAmount,
   publicDecrypt,
-  setObserver,
-  setObserverWeb,
   userDecryptEuint64,
-  viewConfidentialBalance,
   viewConfidentialTransferAmounts
 });