x402z-shared 0.0.7 → 0.0.9

package/README.md

@@ -8,35 +8,22 @@ Shared utilities for the erc7984-mind-v1 x402 scheme.
 pnpm add x402z-shared
 ```
 
-## Relayer helpers (Node)
+## Folder map
 
-```ts
-import {
-  createRelayerInstance,
-  createEncryptedAmountInput,
-  SepoliaConfig,
-} from "x402z-shared";
+- `src/core/`: ABI, constants, types, utils
+- `src/relayer/`: relayer helpers
+- `src/token/`: token, balance, observer, transfer helpers
+- `src/index.ts`: public exports
 
-```
-
-## Relayer helpers (Browser)
+## Relayer helpers (Node)
 
 ```ts
 import {
-  createRelayerInstance,
+  createRelayer,
   createEncryptedAmountInput,
-  initSDK,
   SepoliaConfig,
-} from "x402z-shared/web";
+} from "x402z-shared";
 
-await initSDK();
-const relayer = await createRelayerInstance(SepoliaConfig);
-const encrypted = await createEncryptedAmountInput(
-  relayer,
-  "0xToken",
-  "0xFacilitator",
-  1000,
-);
 ```
 
 ## Token helper (Node)
@@ -61,9 +48,9 @@ Notes:
 ## Transfer amount helper (Node)
 
 ```ts
-import { viewConfidentialTransferAmounts } from "x402z-shared";
+import { getTransferAmounts } from "x402z-shared";
 
-const transfers = await viewConfidentialTransferAmounts({
+const transfers = await getTransferAmounts({
   rpcUrl: "https://sepolia.infura.io/v3/...",
   tokenAddress: "0xToken",
   txHash: "0xTransactionHash",
@@ -94,26 +81,7 @@ const txHash = await token.setObserver("0xHolder", "0xObserver");
 console.log(txHash);
 ```
 
-## Token helper (Browser)
-
-```ts
-import { ConfidentialTokenWeb } from "x402z-shared/web";
-
-const token = new ConfidentialTokenWeb({
-  rpcUrl: "https://sepolia.infura.io/v3/...",
-  tokenAddress: "0xToken",
-  relayer,
-  walletClient,
-});
-const txHash = await token.setObserver("0xHolder", "0xObserver");
-console.log(txHash);
-```
-
-## Transfer amount helper (Browser)
-
-```ts
-import { viewConfidentialTransferAmounts } from "x402z-shared/web";
-```
 ## Notes
 
 - Scheme name: `erc7984-mind-v1`
+- For browser usage, use `x402z-shared-web`.

package/dist/index.d.mts

@@ -1,9 +1,243 @@
-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';
 
+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 RelayerInstance = Awaited<ReturnType<typeof createInstance>>;
 type RelayerSigner = {
     address: string;
@@ -21,13 +255,13 @@ type RelayerSigner = {
     }) => Promise<string>);
 };
 
-declare function createRelayerInstance(config: FhevmInstanceConfig): Promise<RelayerInstance>;
+declare function createRelayer(config: FhevmInstanceConfig): Promise<RelayerInstance>;
 
 declare function createEncryptedAmountInput(relayer: RelayerInstance, contractAddress: string, senderAddress: string, amount: number): Promise<{
     handle: `0x${string}`;
     inputProof: `0x${string}`;
 }>;
-declare function userDecryptEuint64(relayer: RelayerInstance, handle: string, contractAddress: string, signer: RelayerSigner, options?: {
+declare function decryptEuint64(relayer: RelayerInstance, handle: string, contractAddress: string, signer: RelayerSigner, options?: {
     durationDays?: string;
     startTimestamp?: string;
 }): Promise<bigint>;
@@ -36,7 +270,7 @@ declare function publicDecrypt(relayer: RelayerInstance, handles: string[]): Pro
     decryptionProof: string;
 }>;
 
-type ConfidentialTransferAmount = {
+type TransferAmount = {
     holder: `0x${string}`;
     payee: `0x${string}`;
     maxClearAmount: bigint;
@@ -45,7 +279,7 @@ type ConfidentialTransferAmount = {
     handle: `0x${string}`;
     amount?: bigint;
 };
-type ViewConfidentialTransferOptions = {
+type TransferQueryOptions = {
     rpcUrl: string;
     tokenAddress: `0x${string}`;
     txHash: `0x${string}`;
@@ -55,7 +289,7 @@ type ViewConfidentialTransferOptions = {
     signer?: RelayerSigner;
     decrypt?: boolean;
 };
-declare function viewConfidentialTransferAmounts(options: ViewConfidentialTransferOptions): Promise<ConfidentialTransferAmount[]>;
+declare function getTransferAmounts(options: TransferQueryOptions): Promise<TransferAmount[]>;
 
 type TokenWriteSigner = RelayerSigner & {
     writeContract?: (args: {
@@ -65,7 +299,7 @@ type TokenWriteSigner = RelayerSigner & {
         args: readonly unknown[];
     }) => Promise<`0x${string}`>;
 };
-type ConfidentialTokenConfig = {
+type ConfidentialTokenOptions = {
     rpcUrl: string;
     tokenAddress: `0x${string}`;
     relayer: RelayerInstance;
@@ -76,7 +310,7 @@ declare class ConfidentialToken {
     private readonly tokenAddress;
     private readonly relayer;
     private readonly signer;
-    constructor(config: ConfidentialTokenConfig);
+    constructor(config: ConfidentialTokenOptions);
     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}`>;
@@ -84,4 +318,41 @@ declare class ConfidentialToken {
     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 };
+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, type ConfidentialPaymentAuthorization, type ConfidentialPaymentInput, type ConfidentialPaymentPayload, type ConfidentialRequirementsExtra, ConfidentialToken, type ConfidentialTokenOptions, type RelayerInstance, type RelayerSigner, type TransferAmount, type TransferQueryOptions, confidentialErrorCodes, confidentialPaymentTypes, confidentialTokenAbi, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getTransferAmounts, hashEncryptedAmountInput, normalizeAmount, publicDecrypt };

package/dist/index.d.ts

@@ -1,9 +1,243 @@
-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';
 
+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 RelayerInstance = Awaited<ReturnType<typeof createInstance>>;
 type RelayerSigner = {
     address: string;
@@ -21,13 +255,13 @@ type RelayerSigner = {
     }) => Promise<string>);
 };
 
-declare function createRelayerInstance(config: FhevmInstanceConfig): Promise<RelayerInstance>;
+declare function createRelayer(config: FhevmInstanceConfig): Promise<RelayerInstance>;
 
 declare function createEncryptedAmountInput(relayer: RelayerInstance, contractAddress: string, senderAddress: string, amount: number): Promise<{
     handle: `0x${string}`;
     inputProof: `0x${string}`;
 }>;
-declare function userDecryptEuint64(relayer: RelayerInstance, handle: string, contractAddress: string, signer: RelayerSigner, options?: {
+declare function decryptEuint64(relayer: RelayerInstance, handle: string, contractAddress: string, signer: RelayerSigner, options?: {
     durationDays?: string;
     startTimestamp?: string;
 }): Promise<bigint>;
@@ -36,7 +270,7 @@ declare function publicDecrypt(relayer: RelayerInstance, handles: string[]): Pro
     decryptionProof: string;
 }>;
 
-type ConfidentialTransferAmount = {
+type TransferAmount = {
     holder: `0x${string}`;
     payee: `0x${string}`;
     maxClearAmount: bigint;
@@ -45,7 +279,7 @@ type ConfidentialTransferAmount = {
     handle: `0x${string}`;
     amount?: bigint;
 };
-type ViewConfidentialTransferOptions = {
+type TransferQueryOptions = {
     rpcUrl: string;
     tokenAddress: `0x${string}`;
     txHash: `0x${string}`;
@@ -55,7 +289,7 @@ type ViewConfidentialTransferOptions = {
     signer?: RelayerSigner;
     decrypt?: boolean;
 };
-declare function viewConfidentialTransferAmounts(options: ViewConfidentialTransferOptions): Promise<ConfidentialTransferAmount[]>;
+declare function getTransferAmounts(options: TransferQueryOptions): Promise<TransferAmount[]>;
 
 type TokenWriteSigner = RelayerSigner & {
     writeContract?: (args: {
@@ -65,7 +299,7 @@ type TokenWriteSigner = RelayerSigner & {
         args: readonly unknown[];
     }) => Promise<`0x${string}`>;
 };
-type ConfidentialTokenConfig = {
+type ConfidentialTokenOptions = {
     rpcUrl: string;
     tokenAddress: `0x${string}`;
     relayer: RelayerInstance;
@@ -76,7 +310,7 @@ declare class ConfidentialToken {
     private readonly tokenAddress;
     private readonly relayer;
     private readonly signer;
-    constructor(config: ConfidentialTokenConfig);
+    constructor(config: ConfidentialTokenOptions);
     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}`>;
@@ -84,4 +318,41 @@ declare class ConfidentialToken {
     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 };
+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, type ConfidentialPaymentAuthorization, type ConfidentialPaymentInput, type ConfidentialPaymentPayload, type ConfidentialRequirementsExtra, ConfidentialToken, type ConfidentialTokenOptions, type RelayerInstance, type RelayerSigner, type TransferAmount, type TransferQueryOptions, confidentialErrorCodes, confidentialPaymentTypes, confidentialTokenAbi, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getTransferAmounts, hashEncryptedAmountInput, normalizeAmount, publicDecrypt };

package/dist/index.js

@@ -24,20 +24,19 @@ __export(index_exports, {
   SepoliaConfig: () => import_node.SepoliaConfig,
   confidentialErrorCodes: () => confidentialErrorCodes,
   confidentialPaymentTypes: () => confidentialPaymentTypes,
-  confidentialToken: () => ConfidentialToken,
   confidentialTokenAbi: () => confidentialTokenAbi,
   createEncryptedAmountInput: () => createEncryptedAmountInput,
   createNonce: () => createNonce,
-  createRelayerInstance: () => createRelayerInstance,
+  createRelayer: () => createRelayer,
+  decryptEuint64: () => decryptEuint64,
+  getTransferAmounts: () => getTransferAmounts,
   hashEncryptedAmountInput: () => hashEncryptedAmountInput,
   normalizeAmount: () => normalizeAmount,
-  publicDecrypt: () => publicDecrypt,
-  userDecryptEuint64: () => userDecryptEuint64,
-  viewConfidentialTransferAmounts: () => viewConfidentialTransferAmounts
+  publicDecrypt: () => publicDecrypt
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/abi.ts
+// src/core/abi.ts
 var confidentialTokenAbi = [
   {
     inputs: [
@@ -140,7 +139,7 @@ var confidentialTokenAbi = [
   }
 ];
 
-// src/constants.ts
+// src/core/constants.ts
 var confidentialPaymentTypes = {
   ConfidentialPayment: [
     { name: "holder", type: "address" },
@@ -157,7 +156,7 @@ var confidentialErrorCodes = {
   observerNotAuthorized: "observer_not_authorized"
 };
 
-// src/utils.ts
+// src/core/utils.ts
 var import_viem = require("viem");
 function createNonce() {
   const cryptoObj = typeof globalThis.crypto !== "undefined" ? globalThis.crypto : globalThis.crypto;
@@ -184,10 +183,10 @@ function normalizeAmount(amount) {
   return amount.toString();
 }
 
-// src/relayer.ts
+// src/relayer/index.ts
 var import_node = require("@zama-fhe/relayer-sdk/node");
 var import_viem2 = require("viem");
-async function createRelayerInstance(config) {
+async function createRelayer(config) {
   const instance = await (0, import_node.createInstance)(config);
   if (typeof config.network === "string") {
     instance.network = config.network;
@@ -205,7 +204,7 @@ async function createEncryptedAmountInput(relayer, contractAddress, senderAddres
     inputProof
   };
 }
-async function userDecryptEuint64(relayer, handle, contractAddress, signer, options) {
+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";
@@ -239,9 +238,9 @@ async function publicDecrypt(relayer, handles) {
   };
 }
 
-// src/transfer.ts
+// src/token/transfer.ts
 var import_viem3 = require("viem");
-async function viewConfidentialTransferAmounts(options) {
+async function getTransferAmounts(options) {
   if (!(0, import_viem3.isAddress)(options.tokenAddress)) {
     throw new Error(`Invalid token address: ${options.tokenAddress}`);
   }
@@ -314,7 +313,7 @@ async function viewConfidentialTransferAmounts(options) {
             throw new Error(confidentialErrorCodes.observerNotAuthorized);
           }
         }
-        entry.amount = await userDecryptEuint64(
+        entry.amount = await decryptEuint64(
           options.relayer,
           entry.handle,
           tokenAddress,
@@ -331,13 +330,13 @@ async function viewConfidentialTransferAmounts(options) {
   return transfers;
 }
 
-// src/token.ts
+// src/token/token.ts
 var import_viem6 = require("viem");
 
-// src/balance.ts
+// src/token/balance.ts
 var import_viem4 = require("viem");
 var ZERO_HANDLE = "0x" + "00".repeat(32);
-async function viewConfidentialBalance(options) {
+async function readBalance(options) {
   if (!(0, import_viem4.isAddress)(options.tokenAddress)) {
     throw new Error(`Invalid token address: ${options.tokenAddress}`);
   }
@@ -383,7 +382,7 @@ async function viewConfidentialBalance(options) {
   if (handle === ZERO_HANDLE) {
     return { handle, balance: 0n };
   }
-  const balance = await userDecryptEuint64(
+  const balance = await decryptEuint64(
     options.relayer,
     handle,
     options.tokenAddress,
@@ -392,7 +391,7 @@ async function viewConfidentialBalance(options) {
   return { handle, balance };
 }
 
-// src/observer.ts
+// src/token/observer.ts
 var import_viem5 = require("viem");
 async function setObserver(options) {
   if (!(0, import_viem5.isAddress)(options.tokenAddress)) {
@@ -425,7 +424,7 @@ async function setObserver(options) {
   });
 }
 
-// src/token.ts
+// src/token/token.ts
 function assertAddress(value, label) {
   if (!(0, import_viem6.isAddress)(value)) {
     throw new Error(`Invalid ${label}: ${value}`);
@@ -446,7 +445,7 @@ var ConfidentialToken = class {
     this.signer = config.signer;
   }
   async balanceOf(account) {
-    const result = await viewConfidentialBalance({
+    const result = await readBalance({
       rpcUrl: this.rpcUrl,
       tokenAddress: this.tokenAddress,
       account,
@@ -528,14 +527,13 @@ var ConfidentialToken = class {
   SepoliaConfig,
   confidentialErrorCodes,
   confidentialPaymentTypes,
-  confidentialToken,
   confidentialTokenAbi,
   createEncryptedAmountInput,
   createNonce,
-  createRelayerInstance,
+  createRelayer,
+  decryptEuint64,
+  getTransferAmounts,
   hashEncryptedAmountInput,
   normalizeAmount,
-  publicDecrypt,
-  userDecryptEuint64,
-  viewConfidentialTransferAmounts
+  publicDecrypt
 });

package/dist/index.mjs

@@ -1,16 +1,154 @@
-import {
-  confidentialErrorCodes,
-  confidentialPaymentTypes,
-  confidentialTokenAbi,
-  createNonce,
-  hashEncryptedAmountInput,
-  normalizeAmount
-} from "./chunk-7OLOM2AQ.mjs";
+// 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.ts
+// src/relayer/index.ts
 import { createInstance, SepoliaConfig } from "@zama-fhe/relayer-sdk/node";
-import { getAddress, toHex } from "viem";
-async function createRelayerInstance(config) {
+import { getAddress, toHex as toHex2 } from "viem";
+async function createRelayer(config) {
   const instance = await createInstance(config);
   if (typeof config.network === "string") {
     instance.network = config.network;
@@ -21,14 +159,14 @@ async function createEncryptedAmountInput(relayer, contractAddress, senderAddres
   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] : toHex(encrypted.handles[0]);
-  const inputProof = typeof encrypted.inputProof === "string" ? encrypted.inputProof : toHex(encrypted.inputProof);
+  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 userDecryptEuint64(relayer, handle, contractAddress, signer, options) {
+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";
@@ -62,9 +200,9 @@ async function publicDecrypt(relayer, handles) {
   };
 }
 
-// src/transfer.ts
+// src/token/transfer.ts
 import { createPublicClient, decodeEventLog, getAddress as getAddress2, http, isAddress, isHex, isAddressEqual } from "viem";
-async function viewConfidentialTransferAmounts(options) {
+async function getTransferAmounts(options) {
   if (!isAddress(options.tokenAddress)) {
     throw new Error(`Invalid token address: ${options.tokenAddress}`);
   }
@@ -137,7 +275,7 @@ async function viewConfidentialTransferAmounts(options) {
             throw new Error(confidentialErrorCodes.observerNotAuthorized);
           }
         }
-        entry.amount = await userDecryptEuint64(
+        entry.amount = await decryptEuint64(
           options.relayer,
           entry.handle,
           tokenAddress,
@@ -154,13 +292,13 @@ async function viewConfidentialTransferAmounts(options) {
   return transfers;
 }
 
-// src/token.ts
+// src/token/token.ts
 import { getAddress as getAddress5, isAddress as isAddress4 } from "viem";
 
-// src/balance.ts
+// 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 viewConfidentialBalance(options) {
+async function readBalance(options) {
   if (!isAddress2(options.tokenAddress)) {
     throw new Error(`Invalid token address: ${options.tokenAddress}`);
   }
@@ -206,7 +344,7 @@ async function viewConfidentialBalance(options) {
   if (handle === ZERO_HANDLE) {
     return { handle, balance: 0n };
   }
-  const balance = await userDecryptEuint64(
+  const balance = await decryptEuint64(
     options.relayer,
     handle,
     options.tokenAddress,
@@ -215,7 +353,7 @@ async function viewConfidentialBalance(options) {
   return { handle, balance };
 }
 
-// src/observer.ts
+// src/token/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)) {
@@ -248,7 +386,7 @@ async function setObserver(options) {
   });
 }
 
-// src/token.ts
+// src/token/token.ts
 function assertAddress(value, label) {
   if (!isAddress4(value)) {
     throw new Error(`Invalid ${label}: ${value}`);
@@ -269,7 +407,7 @@ var ConfidentialToken = class {
     this.signer = config.signer;
   }
   async balanceOf(account) {
-    const result = await viewConfidentialBalance({
+    const result = await readBalance({
       rpcUrl: this.rpcUrl,
       tokenAddress: this.tokenAddress,
       account,
@@ -350,14 +488,13 @@ export {
   SepoliaConfig,
   confidentialErrorCodes,
   confidentialPaymentTypes,
-  ConfidentialToken as confidentialToken,
   confidentialTokenAbi,
   createEncryptedAmountInput,
   createNonce,
-  createRelayerInstance,
+  createRelayer,
+  decryptEuint64,
+  getTransferAmounts,
   hashEncryptedAmountInput,
   normalizeAmount,
-  publicDecrypt,
-  userDecryptEuint64,
-  viewConfidentialTransferAmounts
+  publicDecrypt
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x402z-shared",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -12,17 +12,12 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
-    },
-    "./web": {
-      "types": "./dist/web.d.ts",
-      "import": "./dist/web.mjs",
-      "require": "./dist/web.js"
     }
   },
   "dependencies": {
     "@x402/core": "^2.0.0",
     "viem": "^2.39.3",
-    "@zama-fhe/relayer-sdk": "^0.3.0-5"
+    "@zama-fhe/relayer-sdk": "0.3.0-8"
   },
   "devDependencies": {
     "jest": "^29.7.0",
@@ -30,7 +25,7 @@
     "@types/jest": "^29.5.12"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/web.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts --format cjs,esm --dts",
     "test": "jest"
   }
 }