x402z-shared 0.0.4 → 0.0.6

package/README.md

@@ -39,18 +39,19 @@ const encrypted = await createEncryptedAmountInput(
 );
 ```
 
-## Balance helper (Node)
+## Token helper (Node)
 
 ```ts
-import { viewConfidentialBalance } from "x402z-shared";
+import { ConfidentialToken } from "x402z-shared";
 
-const result = await viewConfidentialBalance({
+const token = new ConfidentialToken({
   rpcUrl: "https://sepolia.infura.io/v3/...",
   tokenAddress: "0xToken",
   relayer,
-  signer: { address, signTypedData },
+  signer: { address, signTypedData, writeContract },
 });
-console.log(result.balance?.toString());
+const balance = await token.balanceOf("0xWallet");
+console.log(balance.toString());
 ```
 
 Notes:
@@ -81,45 +82,38 @@ Notes:
 ## Observer helper (Node)
 
 ```ts
-import { setObserver } from "x402z-shared";
+import { ConfidentialToken } from "x402z-shared";
 
-const txHash = await setObserver({
+const token = new ConfidentialToken({
   rpcUrl: "https://sepolia.infura.io/v3/...",
   tokenAddress: "0xToken",
-  account: "0xHolder",
-  observer: "0xObserver",
-  signer,
+  relayer,
+  signer: { address, signTypedData, writeContract },
 });
+const txHash = await token.setObserver("0xHolder", "0xObserver");
 console.log(txHash);
 ```
 
-## Observer helper (Browser)
+## Token helper (Browser)
 
 ```ts
-import { setObserverWeb } from "x402z-shared/web";
+import { ConfidentialTokenWeb } from "x402z-shared/web";
 
-const txHash = await setObserverWeb({
+const token = new ConfidentialTokenWeb({
+  rpcUrl: "https://sepolia.infura.io/v3/...",
   tokenAddress: "0xToken",
-  account: "0xHolder",
-  observer: "0xObserver",
+  relayer,
   walletClient,
 });
+const txHash = await token.setObserver("0xHolder", "0xObserver");
 console.log(txHash);
 ```
 
-## Balance helper (Browser)
-
-```ts
-import { viewConfidentialBalance } from "x402z-shared/web";
-```
-
 ## Transfer amount helper (Browser)
 
 ```ts
 import { viewConfidentialTransferAmounts } from "x402z-shared/web";
 ```
-
 ## Notes
 
 - Scheme name: `erc7984-mind-v1`
-- `viewConfidentialBalance` can return handle-only if `decrypt: false`.

package/dist/chunk-7OLOM2AQ.mjs

@@ -0,0 +1,155 @@
+// 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: [
+      {
+        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/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/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();
+}
+
+export {
+  confidentialTokenAbi,
+  confidentialPaymentTypes,
+  confidentialErrorCodes,
+  createNonce,
+  hashEncryptedAmountInput,
+  normalizeAmount
+};

package/dist/index.d.mts

@@ -1,19 +1,39 @@
-import { R as RelayerInstance, a as RelayerSigner } from './types-Cy4f8wJ6.mjs';
-export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, g as createEncryptedAmountInput, e as createNonce, f as createRelayerInstance, h as hashEncryptedAmountInput, n as normalizeAmount, p as publicDecrypt, s as setObserver, u as userDecryptEuint64 } from './types-Cy4f8wJ6.mjs';
-export * from '@x402/core/types';
+import { c as confidentialTokenAbi } from './types-I3K7qzdc.mjs';
+export { C as ConfidentialErrorCode, e as ConfidentialPaymentAuthorization, i as ConfidentialPaymentInput, f as ConfidentialPaymentPayload, g as ConfidentialRequirementsExtra, b as confidentialErrorCodes, a as confidentialPaymentTypes, d as createNonce, h as hashEncryptedAmountInput, n as normalizeAmount } from './types-I3K7qzdc.mjs';
+import { FhevmInstanceConfig, createInstance } from '@zama-fhe/relayer-sdk/node';
 export { FhevmInstanceConfig, SepoliaConfig } from '@zama-fhe/relayer-sdk/node';
+export * from '@x402/core/types';
 
-type ViewConfidentialBalanceOptions = {
-    rpcUrl: string;
-    tokenAddress: `0x${string}`;
-    account?: `0x${string}`;
-    relayer: RelayerInstance;
-    signer?: RelayerSigner;
-    decrypt?: boolean;
+type RelayerInstance = Awaited<ReturnType<typeof createInstance>>;
+type RelayerSigner = {
+    address: string;
+    signTypedData: ((domain: Record<string, unknown>, types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, message: Record<string, unknown>) => Promise<string>) | ((args: {
+        domain: Record<string, unknown>;
+        types: Record<string, Array<{
+            name: string;
+            type: string;
+        }>>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }) => Promise<string>);
 };
-declare function viewConfidentialBalance(options: ViewConfidentialBalanceOptions): Promise<{
+
+declare function createRelayerInstance(config: FhevmInstanceConfig): Promise<RelayerInstance>;
+
+declare function createEncryptedAmountInput(relayer: RelayerInstance, contractAddress: string, senderAddress: string, amount: number): Promise<{
     handle: `0x${string}`;
-    balance?: bigint;
+    inputProof: `0x${string}`;
+}>;
+declare function userDecryptEuint64(relayer: RelayerInstance, handle: string, contractAddress: string, signer: RelayerSigner, options?: {
+    durationDays?: string;
+    startTimestamp?: string;
+}): Promise<bigint>;
+declare function publicDecrypt(relayer: RelayerInstance, handles: string[]): Promise<{
+    clearValues: Record<string, bigint>;
+    decryptionProof: string;
 }>;
 
 type ConfidentialTransferAmount = {
@@ -37,4 +57,31 @@ type ViewConfidentialTransferOptions = {
 };
 declare function viewConfidentialTransferAmounts(options: ViewConfidentialTransferOptions): Promise<ConfidentialTransferAmount[]>;
 
-export { type ConfidentialTransferAmount, RelayerInstance, RelayerSigner, type ViewConfidentialBalanceOptions, type ViewConfidentialTransferOptions, viewConfidentialBalance, viewConfidentialTransferAmounts };
+type TokenWriteSigner = RelayerSigner & {
+    writeContract?: (args: {
+        address: `0x${string}`;
+        abi: typeof confidentialTokenAbi;
+        functionName: "confidentialTransfer" | "wrap" | "unwrap" | "setObserver";
+        args: readonly unknown[];
+    }) => Promise<`0x${string}`>;
+};
+type ConfidentialTokenConfig = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    relayer: RelayerInstance;
+    signer: TokenWriteSigner;
+};
+declare class ConfidentialToken {
+    private readonly rpcUrl;
+    private readonly tokenAddress;
+    private readonly relayer;
+    private readonly signer;
+    constructor(config: ConfidentialTokenConfig);
+    balanceOf(account?: `0x${string}`): Promise<bigint>;
+    setObserver(account: `0x${string}`, observer: `0x${string}`): Promise<`0x${string}`>;
+    transfer(to: `0x${string}`, amount: number): Promise<`0x${string}`>;
+    wrap(to: `0x${string}`, amount: string | number | bigint): Promise<`0x${string}`>;
+    unwrap(from: `0x${string}`, to: `0x${string}`, amount: number): Promise<`0x${string}`>;
+}
+
+export { ConfidentialToken, type ConfidentialTokenConfig, type ConfidentialTransferAmount, type RelayerInstance, type RelayerSigner, type ViewConfidentialTransferOptions, ConfidentialToken as confidentialToken, confidentialTokenAbi, createEncryptedAmountInput, createRelayerInstance, publicDecrypt, userDecryptEuint64, viewConfidentialTransferAmounts };

package/dist/index.d.ts

@@ -1,19 +1,39 @@
-import { R as RelayerInstance, a as RelayerSigner } from './types-Cy4f8wJ6.js';
-export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, g as createEncryptedAmountInput, e as createNonce, f as createRelayerInstance, h as hashEncryptedAmountInput, n as normalizeAmount, p as publicDecrypt, s as setObserver, u as userDecryptEuint64 } from './types-Cy4f8wJ6.js';
-export * from '@x402/core/types';
+import { c as confidentialTokenAbi } from './types-I3K7qzdc.js';
+export { C as ConfidentialErrorCode, e as ConfidentialPaymentAuthorization, i as ConfidentialPaymentInput, f as ConfidentialPaymentPayload, g as ConfidentialRequirementsExtra, b as confidentialErrorCodes, a as confidentialPaymentTypes, d as createNonce, h as hashEncryptedAmountInput, n as normalizeAmount } from './types-I3K7qzdc.js';
+import { FhevmInstanceConfig, createInstance } from '@zama-fhe/relayer-sdk/node';
 export { FhevmInstanceConfig, SepoliaConfig } from '@zama-fhe/relayer-sdk/node';
+export * from '@x402/core/types';
 
-type ViewConfidentialBalanceOptions = {
-    rpcUrl: string;
-    tokenAddress: `0x${string}`;
-    account?: `0x${string}`;
-    relayer: RelayerInstance;
-    signer?: RelayerSigner;
-    decrypt?: boolean;
+type RelayerInstance = Awaited<ReturnType<typeof createInstance>>;
+type RelayerSigner = {
+    address: string;
+    signTypedData: ((domain: Record<string, unknown>, types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, message: Record<string, unknown>) => Promise<string>) | ((args: {
+        domain: Record<string, unknown>;
+        types: Record<string, Array<{
+            name: string;
+            type: string;
+        }>>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }) => Promise<string>);
 };
-declare function viewConfidentialBalance(options: ViewConfidentialBalanceOptions): Promise<{
+
+declare function createRelayerInstance(config: FhevmInstanceConfig): Promise<RelayerInstance>;
+
+declare function createEncryptedAmountInput(relayer: RelayerInstance, contractAddress: string, senderAddress: string, amount: number): Promise<{
     handle: `0x${string}`;
-    balance?: bigint;
+    inputProof: `0x${string}`;
+}>;
+declare function userDecryptEuint64(relayer: RelayerInstance, handle: string, contractAddress: string, signer: RelayerSigner, options?: {
+    durationDays?: string;
+    startTimestamp?: string;
+}): Promise<bigint>;
+declare function publicDecrypt(relayer: RelayerInstance, handles: string[]): Promise<{
+    clearValues: Record<string, bigint>;
+    decryptionProof: string;
 }>;
 
 type ConfidentialTransferAmount = {
@@ -37,4 +57,31 @@ type ViewConfidentialTransferOptions = {
 };
 declare function viewConfidentialTransferAmounts(options: ViewConfidentialTransferOptions): Promise<ConfidentialTransferAmount[]>;
 
-export { type ConfidentialTransferAmount, RelayerInstance, RelayerSigner, type ViewConfidentialBalanceOptions, type ViewConfidentialTransferOptions, viewConfidentialBalance, viewConfidentialTransferAmounts };
+type TokenWriteSigner = RelayerSigner & {
+    writeContract?: (args: {
+        address: `0x${string}`;
+        abi: typeof confidentialTokenAbi;
+        functionName: "confidentialTransfer" | "wrap" | "unwrap" | "setObserver";
+        args: readonly unknown[];
+    }) => Promise<`0x${string}`>;
+};
+type ConfidentialTokenConfig = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    relayer: RelayerInstance;
+    signer: TokenWriteSigner;
+};
+declare class ConfidentialToken {
+    private readonly rpcUrl;
+    private readonly tokenAddress;
+    private readonly relayer;
+    private readonly signer;
+    constructor(config: ConfidentialTokenConfig);
+    balanceOf(account?: `0x${string}`): Promise<bigint>;
+    setObserver(account: `0x${string}`, observer: `0x${string}`): Promise<`0x${string}`>;
+    transfer(to: `0x${string}`, amount: number): Promise<`0x${string}`>;
+    wrap(to: `0x${string}`, amount: string | number | bigint): Promise<`0x${string}`>;
+    unwrap(from: `0x${string}`, to: `0x${string}`, amount: number): Promise<`0x${string}`>;
+}
+
+export { ConfidentialToken, type ConfidentialTokenConfig, type ConfidentialTransferAmount, type RelayerInstance, type RelayerSigner, type ViewConfidentialTransferOptions, ConfidentialToken as confidentialToken, confidentialTokenAbi, createEncryptedAmountInput, createRelayerInstance, publicDecrypt, userDecryptEuint64, viewConfidentialTransferAmounts };