x402z-shared-web 0.0.9

package/README.md

@@ -0,0 +1,93 @@
+# x402z-shared-web
+
+Browser relayer + token helpers for the erc7984-mind-v1 x402 scheme.
+
+## Install
+
+```bash
+pnpm add x402z-shared-web
+```
+
+## Folder map
+
+- `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)
+
+```ts
+import {
+  createRelayer,
+  createEncryptedAmountInput,
+  initSDK,
+  SepoliaConfig,
+} from "x402z-shared-web";
+
+await initSDK();
+const relayer = await createRelayer(SepoliaConfig);
+const encrypted = await createEncryptedAmountInput(
+  relayer,
+  "0xToken",
+  "0xBatcher",
+  1000,
+);
+```
+
+## Token helper (Browser)
+
+```ts
+import { ConfidentialToken } from "x402z-shared-web";
+
+const token = new ConfidentialToken({
+  rpcUrl: "https://sepolia.infura.io/v3/...",
+  tokenAddress: "0xToken",
+  relayer,
+  walletClient,
+});
+const balance = await token.balanceOf("0xWallet");
+console.log(balance.toString());
+```
+
+Notes:
+- Balance decryption is allowed for the account or its `observer` (ERC7984ObserverAccess).
+- Unauthorized observer errors throw `confidentialErrorCodes.observerNotAuthorized` (`ConfidentialErrorCode`).
+
+## Transfer amount helper (Browser)
+
+```ts
+import { getTransferAmounts } from "x402z-shared-web";
+
+const transfers = await getTransferAmounts({
+  rpcUrl: "https://sepolia.infura.io/v3/...",
+  tokenAddress: "0xToken",
+  txHash: "0xTransactionHash",
+  relayer,
+  signer: { address, signTypedData },
+});
+console.log(transfers[0]?.amount?.toString());
+```
+
+Notes:
+- Transfer amount decryption is allowed for `holder`, `payee`, or an `observer` set via `ERC7984ObserverAccess`.
+- Unauthorized observer errors throw `confidentialErrorCodes.observerNotAuthorized` (`ConfidentialErrorCode`).
+
+## Observer helper (Browser)
+
+```ts
+import { ConfidentialToken } from "x402z-shared-web";
+
+const token = new ConfidentialToken({
+  rpcUrl: "https://sepolia.infura.io/v3/...",
+  tokenAddress: "0xToken",
+  relayer,
+  walletClient,
+});
+const txHash = await token.setObserver("0xHolder", "0xObserver");
+console.log(txHash);
+```
+
+## Notes
+
+- Scheme name: `erc7984-mind-v1`

package/dist/index.d.mts

@@ -0,0 +1,391 @@
+import { WalletClient } from 'viem';
+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;
+
+interface RelayerInstance {
+    createEncryptedInput: (contractAddress: string, senderAddress: string) => {
+        add64: (amount: number) => {
+            encrypt: () => Promise<{
+                handles: Array<string | Uint8Array>;
+                inputProof: string | Uint8Array;
+            }>;
+        };
+    };
+    generateKeypair: () => {
+        publicKey: string;
+        privateKey: string;
+    };
+    createEIP712: (publicKey: string, contractAddresses: string[], startTimestamp: string, durationDays: string) => {
+        domain: Record<string, unknown>;
+        types: {
+            UserDecryptRequestVerification: Array<{
+                name: string;
+                type: string;
+            }>;
+        };
+        message: Record<string, unknown>;
+    };
+    userDecrypt: (handles: Array<{
+        handle: string;
+        contractAddress: string;
+    }>, privateKey: string, publicKey: string, signature: string, contractAddresses: string[], address: string, startTimestamp: string, durationDays: string) => Promise<Record<string, bigint> | {
+        clearValues?: Record<string, bigint>;
+    }>;
+    publicDecrypt: (handles: string[]) => Promise<{
+        clearValues: Record<string, bigint>;
+        decryptionProof: string;
+    }>;
+}
+type RelayerSdkModule = {
+    createInstance: (config: unknown) => Promise<RelayerInstance>;
+    initSDK: (params?: unknown) => Promise<boolean>;
+    SepoliaConfig: unknown;
+};
+declare let SepoliaConfig: RelayerSdkModule["SepoliaConfig"] | undefined;
+declare function configureRelayerSdk(sdk: RelayerSdkModule): void;
+declare function getSepoliaConfig(): RelayerSdkModule["SepoliaConfig"];
+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 createRelayer(config: unknown): Promise<RelayerInstance>;
+declare function initSDK(params?: unknown): Promise<boolean>;
+declare function createEncryptedAmountInput(relayer: RelayerInstance, contractAddress: string, senderAddress: string, amount: number): Promise<{
+    handle: `0x${string}`;
+    inputProof: `0x${string}`;
+}>;
+declare function decryptEuint64(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 TransferAmount = {
+    holder: `0x${string}`;
+    payee: `0x${string}`;
+    maxClearAmount: bigint;
+    resourceHash: `0x${string}`;
+    nonce: `0x${string}`;
+    handle: `0x${string}`;
+    amount?: bigint;
+};
+type TransferQueryOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    txHash: `0x${string}`;
+    from?: `0x${string}`;
+    to?: `0x${string}`;
+    relayer: RelayerInstance;
+    signer?: RelayerSigner;
+    decrypt?: boolean;
+};
+declare function getTransferAmounts(options: TransferQueryOptions): Promise<TransferAmount[]>;
+
+type ConfidentialTokenOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    relayer: RelayerInstance;
+    walletClient: WalletClient;
+    signer?: RelayerSigner;
+};
+declare class ConfidentialToken {
+    private readonly rpcUrl;
+    private readonly tokenAddress;
+    private readonly relayer;
+    private readonly walletClient;
+    private readonly signer?;
+    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}`>;
+    wrap(to: `0x${string}`, amount: string | number | bigint): Promise<`0x${string}`>;
+    unwrap(from: `0x${string}`, to: `0x${string}`, amount: number): Promise<`0x${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, type ConfidentialPaymentAuthorization, type ConfidentialPaymentInput, type ConfidentialPaymentPayload, type ConfidentialRequirementsExtra, ConfidentialToken, type ConfidentialTokenOptions, type RelayerInstance, type RelayerSdkModule, type RelayerSigner, SepoliaConfig, type TransferAmount, type TransferQueryOptions, confidentialErrorCodes, confidentialPaymentTypes, confidentialTokenAbi, configureRelayerSdk, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getSepoliaConfig, getTransferAmounts, hashEncryptedAmountInput, initSDK, normalizeAmount, publicDecrypt };