x402z-shared 0.0.5 → 0.0.6

package/dist/index.mjs

@@ -4,9 +4,8 @@ import {
   confidentialTokenAbi,
   createNonce,
   hashEncryptedAmountInput,
-  normalizeAmount,
-  setObserver
-} from "./chunk-LTE4V3LT.mjs";
+  normalizeAmount
+} from "./chunk-7OLOM2AQ.mjs";
 
 // src/relayer.ts
 import { createInstance, SepoliaConfig } from "@zama-fhe/relayer-sdk/node";
@@ -63,87 +62,29 @@ async function publicDecrypt(relayer, handles) {
   };
 }
 
-// src/balance.ts
-import { createPublicClient, getAddress as getAddress2, http, isAddress, isAddressEqual } from "viem";
-var ZERO_HANDLE = "0x" + "00".repeat(32);
-async function viewConfidentialBalance(options) {
-  if (!isAddress(options.tokenAddress)) {
-    throw new Error(`Invalid token address: ${options.tokenAddress}`);
-  }
-  const account = options.account ?? options.signer?.address;
-  if (!account || !isAddress(account)) {
-    throw new Error(`Invalid account address: ${account ?? "undefined"}`);
-  }
-  const publicClient = createPublicClient({ transport: 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 = getAddress2(options.signer.address);
-  if (!isAddressEqual(signerAddress, getAddress2(account))) {
-    const observer = await publicClient.readContract({
-      address: options.tokenAddress,
-      abi: confidentialTokenAbi,
-      functionName: "observer",
-      args: [account]
-    });
-    if (!observer || !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.ts
-import { createPublicClient as createPublicClient2, decodeEventLog, getAddress as getAddress3, http as http2, isAddress as isAddress2, isHex, isAddressEqual as isAddressEqual2 } from "viem";
+import { createPublicClient, decodeEventLog, getAddress as getAddress2, http, isAddress, isHex, isAddressEqual } from "viem";
 async function viewConfidentialTransferAmounts(options) {
-  if (!isAddress2(options.tokenAddress)) {
+  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 && !isAddress2(options.from)) {
+  if (options.from && !isAddress(options.from)) {
     throw new Error(`Invalid from address: ${options.from}`);
   }
-  if (options.to && !isAddress2(options.to)) {
+  if (options.to && !isAddress(options.to)) {
     throw new Error(`Invalid to address: ${options.to}`);
   }
-  const publicClient = createPublicClient2({ transport: http2(options.rpcUrl) });
+  const publicClient = createPublicClient({ transport: http(options.rpcUrl) });
   const receipt = await publicClient.getTransactionReceipt({
     hash: options.txHash
   });
-  const tokenAddress = getAddress3(options.tokenAddress);
-  const fromFilter = options.from ? getAddress3(options.from) : void 0;
-  const toFilter = options.to ? getAddress3(options.to) : void 0;
-  const logs = receipt.logs.filter((log) => getAddress3(log.address) === tokenAddress);
+  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 {
@@ -155,8 +96,8 @@ async function viewConfidentialTransferAmounts(options) {
       });
       const args = decoded.args;
       const entry = {
-        holder: getAddress3(args.holder),
-        payee: getAddress3(args.payee),
+        holder: getAddress2(args.holder),
+        payee: getAddress2(args.payee),
         maxClearAmount: BigInt(args.maxClearAmount),
         resourceHash: args.resourceHash,
         nonce: args.nonce,
@@ -173,10 +114,10 @@ async function viewConfidentialTransferAmounts(options) {
         if (!options.signer) {
           throw new Error("Missing signer for decryption");
         }
-        const signerAddress = getAddress3(options.signer.address);
-        const holderAddress = getAddress3(entry.holder);
-        const payeeAddress = getAddress3(entry.payee);
-        if (!isAddressEqual2(signerAddress, holderAddress) && !isAddressEqual2(signerAddress, payeeAddress)) {
+        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,
@@ -191,7 +132,7 @@ async function viewConfidentialTransferAmounts(options) {
               args: [payeeAddress]
             })
           ]);
-          const allowed = holderObserver && isAddressEqual2(holderObserver, signerAddress) || payeeObserver && isAddressEqual2(payeeObserver, signerAddress);
+          const allowed = holderObserver && isAddressEqual(holderObserver, signerAddress) || payeeObserver && isAddressEqual(payeeObserver, signerAddress);
           if (!allowed) {
             throw new Error(confidentialErrorCodes.observerNotAuthorized);
           }
@@ -212,10 +153,204 @@ async function viewConfidentialTransferAmounts(options) {
   }
   return transfers;
 }
+
+// src/token.ts
+import { getAddress as getAddress5, isAddress as isAddress4 } from "viem";
+
+// src/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 viewConfidentialBalance(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 userDecryptEuint64(
+    options.relayer,
+    handle,
+    options.tokenAddress,
+    options.signer
+  );
+  return { handle, balance };
+}
+
+// src/observer.ts
+import { createPublicClient as createPublicClient3, getAddress as getAddress4, http as http3, 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}`);
+  }
+  const tokenAddress = getAddress4(options.tokenAddress);
+  const account = getAddress4(options.account);
+  const observer = getAddress4(options.observer);
+  const publicClient = createPublicClient3({ transport: http3(options.rpcUrl) });
+  const existing = await publicClient.readContract({
+    address: tokenAddress,
+    abi: confidentialTokenAbi,
+    functionName: "observer",
+    args: [account]
+  });
+  if (existing && isAddress3(existing) && getAddress4(existing) === observer) {
+    return "0x" + "00".repeat(32);
+  }
+  return options.signer.writeContract({
+    address: tokenAddress,
+    abi: confidentialTokenAbi,
+    functionName: "setObserver",
+    args: [account, observer]
+  });
+}
+
+// src/token.ts
+function assertAddress(value, label) {
+  if (!isAddress4(value)) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return getAddress5(value);
+}
+function requireWriteContract(signer) {
+  if (!signer.writeContract) {
+    throw new Error("Missing signer.writeContract for on-chain calls");
+  }
+  return signer.writeContract;
+}
+var ConfidentialToken = class {
+  constructor(config) {
+    this.rpcUrl = config.rpcUrl;
+    this.tokenAddress = config.tokenAddress;
+    this.relayer = config.relayer;
+    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) {
+    const writeContract = requireWriteContract(this.signer);
+    return setObserver({
+      rpcUrl: this.rpcUrl,
+      tokenAddress: this.tokenAddress,
+      account,
+      observer,
+      signer: { ...this.signer, writeContract }
+    });
+  }
+  async transfer(to, amount) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const toAddress = assertAddress(to, "recipient address");
+    const fromAddress = assertAddress(this.signer.address, "signer address");
+    if (!Number.isSafeInteger(amount)) {
+      throw new Error("Transfer amount must be a safe integer");
+    }
+    const { handle, inputProof } = await createEncryptedAmountInput(
+      this.relayer,
+      tokenAddress,
+      fromAddress,
+      amount
+    );
+    const writeContract = requireWriteContract(this.signer);
+    return writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "confidentialTransfer",
+      args: [toAddress, handle, inputProof]
+    });
+  }
+  async wrap(to, amount) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const toAddress = assertAddress(to, "recipient address");
+    const normalizedAmount = BigInt(normalizeAmount(amount));
+    const writeContract = requireWriteContract(this.signer);
+    return writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "wrap",
+      args: [toAddress, normalizedAmount]
+    });
+  }
+  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 = assertAddress(this.signer.address, "signer address");
+    if (!Number.isSafeInteger(amount)) {
+      throw new Error("Unwrap amount must be a safe integer");
+    }
+    const { handle, inputProof } = await createEncryptedAmountInput(
+      this.relayer,
+      tokenAddress,
+      signerAddress,
+      amount
+    );
+    const writeContract = requireWriteContract(this.signer);
+    return writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "unwrap",
+      args: [fromAddress, toAddress, handle, inputProof]
+    });
+  }
+};
 export {
+  ConfidentialToken,
   SepoliaConfig,
   confidentialErrorCodes,
   confidentialPaymentTypes,
+  ConfidentialToken as confidentialToken,
   confidentialTokenAbi,
   createEncryptedAmountInput,
   createNonce,
@@ -223,8 +358,6 @@ export {
   hashEncryptedAmountInput,
   normalizeAmount,
   publicDecrypt,
-  setObserver,
   userDecryptEuint64,
-  viewConfidentialBalance,
   viewConfidentialTransferAmounts
 };

package/dist/types-I3K7qzdc.d.mts

@@ -0,0 +1,274 @@
+declare const confidentialTokenAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "encryptedAmountInput";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }];
+    readonly name: "confidentialTransfer";
+    readonly outputs: readonly [{
+        readonly internalType: "euint64";
+        readonly name: "transferred";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "holder";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "payee";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "maxClearAmount";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "resourceHash";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "uint48";
+            readonly name: "validAfter";
+            readonly type: "uint48";
+        }, {
+            readonly internalType: "uint48";
+            readonly name: "validBefore";
+            readonly type: "uint48";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "nonce";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "encryptedAmountHash";
+            readonly type: "bytes32";
+        }];
+        readonly internalType: "struct FHEToken.ConfidentialPayment";
+        readonly name: "p";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "externalEuint64";
+        readonly name: "encryptedAmountInput";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "sig";
+        readonly type: "bytes";
+    }];
+    readonly name: "confidentialTransferWithAuthorization";
+    readonly outputs: readonly [{
+        readonly internalType: "euint64";
+        readonly name: "transferred";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "wrap";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "encryptedAmountInput";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }];
+    readonly name: "unwrap";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "holder";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "payee";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "maxClearAmount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "resourceHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "nonce";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "transferredAmount";
+        readonly type: "bytes32";
+    }];
+    readonly name: "ConfidentialPaymentExecuted";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly name: "usedNonces";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "observer";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "newObserver";
+        readonly type: "address";
+    }];
+    readonly name: "setObserver";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+
+declare const confidentialPaymentTypes: {
+    readonly ConfidentialPayment: readonly [{
+        readonly name: "holder";
+        readonly type: "address";
+    }, {
+        readonly name: "payee";
+        readonly type: "address";
+    }, {
+        readonly name: "maxClearAmount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "resourceHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "validAfter";
+        readonly type: "uint48";
+    }, {
+        readonly name: "validBefore";
+        readonly type: "uint48";
+    }, {
+        readonly name: "nonce";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "encryptedAmountHash";
+        readonly type: "bytes32";
+    }];
+};
+declare const confidentialErrorCodes: {
+    readonly observerNotAuthorized: "observer_not_authorized";
+};
+type ConfidentialErrorCode = (typeof confidentialErrorCodes)[keyof typeof confidentialErrorCodes];
+
+declare function createNonce(): `0x${string}`;
+declare function hashEncryptedAmountInput(encryptedAmountInput: `0x${string}`): `0x${string}`;
+declare function normalizeAmount(amount: string | number | bigint): string;
+
+type ConfidentialPaymentAuthorization = {
+    holder: `0x${string}`;
+    payee: `0x${string}`;
+    maxClearAmount: string;
+    resourceHash: `0x${string}`;
+    validAfter: string;
+    validBefore: string;
+    nonce: `0x${string}`;
+    encryptedAmountHash: `0x${string}`;
+};
+type ConfidentialPaymentPayload = {
+    authorization: ConfidentialPaymentAuthorization;
+    signature: `0x${string}`;
+    encryptedAmountInput: `0x${string}`;
+    inputProof: `0x${string}`;
+};
+type ConfidentialRequirementsExtra = {
+    eip712: {
+        name: string;
+        version: string;
+    };
+    confidential?: {
+        maxClearAmount?: string;
+        resourceHash?: `0x${string}`;
+        batcherAddress?: `0x${string}`;
+    };
+};
+type ConfidentialPaymentInput = {
+    encryptedAmountInput: `0x${string}`;
+    inputProof: `0x${string}`;
+    maxClearAmount?: string;
+    resourceHash?: `0x${string}`;
+    validAfter?: number;
+    validBefore?: number;
+    nonce?: `0x${string}`;
+};
+
+export { type ConfidentialErrorCode as C, confidentialPaymentTypes as a, confidentialErrorCodes as b, confidentialTokenAbi as c, createNonce as d, type ConfidentialPaymentAuthorization as e, type ConfidentialPaymentPayload as f, type ConfidentialRequirementsExtra as g, hashEncryptedAmountInput as h, type ConfidentialPaymentInput as i, normalizeAmount as n };