x402z-shared-web 0.0.10 → 0.0.12

package/README.md

@@ -20,15 +20,16 @@ pnpm add x402z-shared-web
 ```ts
 import {
   createRelayer,
+  getBrowserEthereumProvider,
   createEncryptedAmountInput,
   getSepoliaConfig,
 } from "x402z-shared-web";
 import type { FhevmInstanceConfig } from "x402z-shared-web";
 
+const provider = getBrowserEthereumProvider();
 const relayerConfig: FhevmInstanceConfig = {
   ...(getSepoliaConfig() as object),
-  network: window.ethereum,
-  relayerUrl: "https://relayer.testnet.zama.org",
+  network: provider,
 };
 const relayer = await createRelayer(relayerConfig);
 const encrypted = await createEncryptedAmountInput(
@@ -45,12 +46,18 @@ const encrypted = await createEncryptedAmountInput(
 
 ```ts
 import { ConfidentialToken } from "x402z-shared-web";
+import { createWalletClient, custom } from "viem";
+import { createBrowserSigner, getBrowserEthereumProvider } from "x402z-shared-web";
 
+const provider = getBrowserEthereumProvider();
+const signer = await createBrowserSigner(provider);
+const walletClient = createWalletClient({ transport: custom(provider as any) });
 const token = new ConfidentialToken({
   rpcUrl: "https://sepolia.infura.io/v3/...",
   tokenAddress: "0xToken",
   relayer,
   walletClient,
+  signer,
 });
 const balance = await token.balanceOf("0xWallet");
 console.log(balance.toString());
@@ -64,13 +71,16 @@ Notes:
 
 ```ts
 import { getTransferAmounts } from "x402z-shared-web";
+import { createBrowserSigner, getBrowserEthereumProvider } from "x402z-shared-web";
 
+const provider = getBrowserEthereumProvider();
+const signer = await createBrowserSigner(provider);
 const transfers = await getTransferAmounts({
   rpcUrl: "https://sepolia.infura.io/v3/...",
   tokenAddress: "0xToken",
   txHash: "0xTransactionHash",
   relayer,
-  signer: { address, signTypedData },
+  signer,
 });
 console.log(transfers[0]?.amount?.toString());
 ```
@@ -83,12 +93,18 @@ Notes:
 
 ```ts
 import { ConfidentialToken } from "x402z-shared-web";
+import { createWalletClient, custom } from "viem";
+import { createBrowserSigner, getBrowserEthereumProvider } from "x402z-shared-web";
 
+const provider = getBrowserEthereumProvider();
+const signer = await createBrowserSigner(provider);
+const walletClient = createWalletClient({ transport: custom(provider as any) });
 const token = new ConfidentialToken({
   rpcUrl: "https://sepolia.infura.io/v3/...",
   tokenAddress: "0xToken",
   relayer,
   walletClient,
+  signer,
 });
 const txHash = await token.setObserver("0xHolder", "0xObserver");
 console.log(txHash);
@@ -96,4 +112,6 @@ console.log(txHash);
 
 ## Notes
 
+- Web builds use `@zama-fhe/relayer-sdk/web` (no CDN script tag or bundle).
+- Requires an injected wallet for signing (e.g. MetaMask).
 - Scheme name: `erc7984-mind-v1`

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import * as relayerBundle from '@zama-fhe/relayer-sdk/bundle';
+import * as relayerWeb from '@zama-fhe/relayer-sdk/web';
 import { WalletClient } from 'viem';
 export * from '@x402/core/types';
 
@@ -119,6 +119,71 @@ declare const confidentialTokenAbi: readonly [{
     readonly outputs: readonly [];
     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: "to";
+            readonly type: "address";
+        }, {
+            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.UnwrapAuthorization";
+        readonly name: "p";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "encryptedAmountInput";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "sig";
+        readonly type: "bytes";
+    }];
+    readonly name: "unwrapWithAuthorization";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "burntAmount";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "burntAmountCleartext";
+        readonly type: "uint64";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "decryptionProof";
+        readonly type: "bytes";
+    }];
+    readonly name: "finalizeUnwrap";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly anonymous: false;
     readonly inputs: readonly [{
@@ -238,6 +303,27 @@ declare function createNonce(): `0x${string}`;
 declare function hashEncryptedAmountInput(encryptedAmountInput: `0x${string}`): `0x${string}`;
 declare function normalizeAmount(amount: string | number | bigint): string;
 
+type BrowserEthereumProvider = {
+    request: (args: {
+        method: string;
+        params?: unknown[];
+    }) => Promise<unknown>;
+};
+type BrowserSigner = {
+    address: `0x${string}`;
+    signTypedData: (args: {
+        domain: Record<string, unknown>;
+        types: Record<string, Array<{
+            name: string;
+            type: string;
+        }>>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }) => Promise<`0x${string}`>;
+};
+declare function getBrowserEthereumProvider(): BrowserEthereumProvider;
+declare function createBrowserSigner(provider?: BrowserEthereumProvider): Promise<BrowserSigner>;
+
 interface RelayerInstance {
     createEncryptedInput: (contractAddress: string, senderAddress: string) => {
         add64: (amount: number) => {
@@ -270,15 +356,15 @@ interface RelayerInstance {
         decryptionProof: string;
     }>;
 }
-type RelayerBundleModule = typeof relayerBundle;
+type RelayerWebModule = typeof relayerWeb;
 type RelayerSdkModule = {
-    createInstance: RelayerBundleModule["createInstance"];
-    initSDK: RelayerBundleModule["initSDK"];
-    SepoliaConfig: RelayerBundleModule["SepoliaConfig"];
+    createInstance: RelayerWebModule["createInstance"];
+    initSDK: RelayerWebModule["initSDK"];
+    SepoliaConfig: RelayerWebModule["SepoliaConfig"];
 };
-type FhevmInstanceConfig = Parameters<RelayerBundleModule["createInstance"]>[0];
-declare const SepoliaConfig: relayerBundle.FhevmInstanceConfig;
-declare function getSepoliaConfig(): RelayerBundleModule["SepoliaConfig"];
+type FhevmInstanceConfig = Parameters<RelayerWebModule["createInstance"]>[0];
+declare const SepoliaConfig: relayerWeb.FhevmInstanceConfig;
+declare function getSepoliaConfig(): RelayerWebModule["SepoliaConfig"];
 type RelayerSigner = {
     address: string;
     signTypedData: ((domain: Record<string, unknown>, types: Record<string, Array<{
@@ -330,27 +416,6 @@ type TransferQueryOptions = {
 };
 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}`;
@@ -361,6 +426,14 @@ type ConfidentialPaymentAuthorization = {
     nonce: `0x${string}`;
     encryptedAmountHash: `0x${string}`;
 };
+type UnwrapAuthorization = {
+    holder: `0x${string}`;
+    to: `0x${string}`;
+    validAfter: number;
+    validBefore: number;
+    nonce: `0x${string}`;
+    encryptedAmountHash: `0x${string}`;
+};
 type ConfidentialPaymentPayload = {
     authorization: ConfidentialPaymentAuthorization;
     signature: `0x${string}`;
@@ -388,4 +461,27 @@ type ConfidentialPaymentInput = {
     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, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getSepoliaConfig, getTransferAmounts, hashEncryptedAmountInput, initSDK, normalizeAmount, publicDecrypt };
+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}`>;
+    unwrapWithAuthorization(authorization: UnwrapAuthorization, encryptedAmountInput: `0x${string}`, inputProof: `0x${string}`, signature: `0x${string}`): Promise<`0x${string}`>;
+    finalizeUnwrap(burntAmount: `0x${string}`, burntAmountCleartext: string | number | bigint, decryptionProof: `0x${string}`): Promise<`0x${string}`>;
+}
+
+export { type BrowserEthereumProvider, type BrowserSigner, type ConfidentialErrorCode, type ConfidentialPaymentAuthorization, type ConfidentialPaymentInput, type ConfidentialPaymentPayload, type ConfidentialRequirementsExtra, ConfidentialToken, type ConfidentialTokenOptions, type RelayerInstance, type RelayerSdkModule, type RelayerSigner, SepoliaConfig, type TransferAmount, type TransferQueryOptions, type UnwrapAuthorization, confidentialErrorCodes, confidentialPaymentTypes, confidentialTokenAbi, createBrowserSigner, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getBrowserEthereumProvider, getSepoliaConfig, getTransferAmounts, hashEncryptedAmountInput, initSDK, normalizeAmount, publicDecrypt };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import * as relayerBundle from '@zama-fhe/relayer-sdk/bundle';
+import * as relayerWeb from '@zama-fhe/relayer-sdk/web';
 import { WalletClient } from 'viem';
 export * from '@x402/core/types';
 
@@ -119,6 +119,71 @@ declare const confidentialTokenAbi: readonly [{
     readonly outputs: readonly [];
     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: "to";
+            readonly type: "address";
+        }, {
+            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.UnwrapAuthorization";
+        readonly name: "p";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "encryptedAmountInput";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "sig";
+        readonly type: "bytes";
+    }];
+    readonly name: "unwrapWithAuthorization";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "burntAmount";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "burntAmountCleartext";
+        readonly type: "uint64";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "decryptionProof";
+        readonly type: "bytes";
+    }];
+    readonly name: "finalizeUnwrap";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly anonymous: false;
     readonly inputs: readonly [{
@@ -238,6 +303,27 @@ declare function createNonce(): `0x${string}`;
 declare function hashEncryptedAmountInput(encryptedAmountInput: `0x${string}`): `0x${string}`;
 declare function normalizeAmount(amount: string | number | bigint): string;
 
+type BrowserEthereumProvider = {
+    request: (args: {
+        method: string;
+        params?: unknown[];
+    }) => Promise<unknown>;
+};
+type BrowserSigner = {
+    address: `0x${string}`;
+    signTypedData: (args: {
+        domain: Record<string, unknown>;
+        types: Record<string, Array<{
+            name: string;
+            type: string;
+        }>>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }) => Promise<`0x${string}`>;
+};
+declare function getBrowserEthereumProvider(): BrowserEthereumProvider;
+declare function createBrowserSigner(provider?: BrowserEthereumProvider): Promise<BrowserSigner>;
+
 interface RelayerInstance {
     createEncryptedInput: (contractAddress: string, senderAddress: string) => {
         add64: (amount: number) => {
@@ -270,15 +356,15 @@ interface RelayerInstance {
         decryptionProof: string;
     }>;
 }
-type RelayerBundleModule = typeof relayerBundle;
+type RelayerWebModule = typeof relayerWeb;
 type RelayerSdkModule = {
-    createInstance: RelayerBundleModule["createInstance"];
-    initSDK: RelayerBundleModule["initSDK"];
-    SepoliaConfig: RelayerBundleModule["SepoliaConfig"];
+    createInstance: RelayerWebModule["createInstance"];
+    initSDK: RelayerWebModule["initSDK"];
+    SepoliaConfig: RelayerWebModule["SepoliaConfig"];
 };
-type FhevmInstanceConfig = Parameters<RelayerBundleModule["createInstance"]>[0];
-declare const SepoliaConfig: relayerBundle.FhevmInstanceConfig;
-declare function getSepoliaConfig(): RelayerBundleModule["SepoliaConfig"];
+type FhevmInstanceConfig = Parameters<RelayerWebModule["createInstance"]>[0];
+declare const SepoliaConfig: relayerWeb.FhevmInstanceConfig;
+declare function getSepoliaConfig(): RelayerWebModule["SepoliaConfig"];
 type RelayerSigner = {
     address: string;
     signTypedData: ((domain: Record<string, unknown>, types: Record<string, Array<{
@@ -330,27 +416,6 @@ type TransferQueryOptions = {
 };
 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}`;
@@ -361,6 +426,14 @@ type ConfidentialPaymentAuthorization = {
     nonce: `0x${string}`;
     encryptedAmountHash: `0x${string}`;
 };
+type UnwrapAuthorization = {
+    holder: `0x${string}`;
+    to: `0x${string}`;
+    validAfter: number;
+    validBefore: number;
+    nonce: `0x${string}`;
+    encryptedAmountHash: `0x${string}`;
+};
 type ConfidentialPaymentPayload = {
     authorization: ConfidentialPaymentAuthorization;
     signature: `0x${string}`;
@@ -388,4 +461,27 @@ type ConfidentialPaymentInput = {
     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, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getSepoliaConfig, getTransferAmounts, hashEncryptedAmountInput, initSDK, normalizeAmount, publicDecrypt };
+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}`>;
+    unwrapWithAuthorization(authorization: UnwrapAuthorization, encryptedAmountInput: `0x${string}`, inputProof: `0x${string}`, signature: `0x${string}`): Promise<`0x${string}`>;
+    finalizeUnwrap(burntAmount: `0x${string}`, burntAmountCleartext: string | number | bigint, decryptionProof: `0x${string}`): Promise<`0x${string}`>;
+}
+
+export { type BrowserEthereumProvider, type BrowserSigner, type ConfidentialErrorCode, type ConfidentialPaymentAuthorization, type ConfidentialPaymentInput, type ConfidentialPaymentPayload, type ConfidentialRequirementsExtra, ConfidentialToken, type ConfidentialTokenOptions, type RelayerInstance, type RelayerSdkModule, type RelayerSigner, SepoliaConfig, type TransferAmount, type TransferQueryOptions, type UnwrapAuthorization, confidentialErrorCodes, confidentialPaymentTypes, confidentialTokenAbi, createBrowserSigner, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getBrowserEthereumProvider, getSepoliaConfig, getTransferAmounts, hashEncryptedAmountInput, initSDK, normalizeAmount, publicDecrypt };

package/dist/index.js

@@ -35,10 +35,12 @@ __export(index_exports, {
   confidentialErrorCodes: () => confidentialErrorCodes,
   confidentialPaymentTypes: () => confidentialPaymentTypes,
   confidentialTokenAbi: () => confidentialTokenAbi,
+  createBrowserSigner: () => createBrowserSigner,
   createEncryptedAmountInput: () => createEncryptedAmountInput,
   createNonce: () => createNonce,
   createRelayer: () => createRelayer,
   decryptEuint64: () => decryptEuint64,
+  getBrowserEthereumProvider: () => getBrowserEthereumProvider,
   getSepoliaConfig: () => getSepoliaConfig,
   getTransferAmounts: () => getTransferAmounts,
   hashEncryptedAmountInput: () => hashEncryptedAmountInput,
@@ -109,6 +111,41 @@ var confidentialTokenAbi = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "holder", type: "address" },
+          { internalType: "address", name: "to", type: "address" },
+          { 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.UnwrapAuthorization",
+        name: "p",
+        type: "tuple"
+      },
+      { internalType: "bytes", name: "encryptedAmountInput", type: "bytes" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" },
+      { internalType: "bytes", name: "sig", type: "bytes" }
+    ],
+    name: "unwrapWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "burntAmount", type: "bytes32" },
+      { internalType: "uint64", name: "burntAmountCleartext", type: "uint64" },
+      { internalType: "bytes", name: "decryptionProof", type: "bytes" }
+    ],
+    name: "finalizeUnwrap",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     anonymous: false,
     inputs: [
@@ -195,16 +232,64 @@ function normalizeAmount(amount) {
   return amount.toString();
 }
 
+// src/core/signer.ts
+function stringifyPayload(payload) {
+  return JSON.stringify(
+    payload,
+    (_, value) => typeof value === "bigint" ? value.toString() : value
+  );
+}
+function getBrowserEthereumProvider() {
+  const provider = globalThis.ethereum;
+  if (!provider) {
+    throw new Error("Missing window.ethereum; install a wallet like MetaMask");
+  }
+  return provider;
+}
+async function createBrowserSigner(provider = getBrowserEthereumProvider()) {
+  const accounts = await provider.request({ method: "eth_requestAccounts" });
+  const account = accounts?.[0];
+  if (!account) {
+    throw new Error("No wallet account available");
+  }
+  return {
+    address: account,
+    signTypedData: async (args) => {
+      const signature = await provider.request({
+        method: "eth_signTypedData_v4",
+        params: [
+          account,
+          stringifyPayload({
+            domain: args.domain,
+            types: {
+              EIP712Domain: [
+                { name: "name", type: "string" },
+                { name: "version", type: "string" },
+                { name: "chainId", type: "uint256" },
+                { name: "verifyingContract", type: "address" }
+              ],
+              ...args.types
+            },
+            primaryType: args.primaryType,
+            message: args.message
+          })
+        ]
+      });
+      return signature;
+    }
+  };
+}
+
 // src/relayer/index.ts
 var import_viem2 = require("viem");
-var relayerBundle = __toESM(require("@zama-fhe/relayer-sdk/bundle"));
-var SepoliaConfig2 = relayerBundle.SepoliaConfig;
+var relayerWeb = __toESM(require("@zama-fhe/relayer-sdk/web"));
+var SepoliaConfig2 = relayerWeb.SepoliaConfig;
 function getSepoliaConfig() {
-  return relayerBundle.SepoliaConfig;
+  return relayerWeb.SepoliaConfig;
 }
 async function createRelayer(config) {
   await initSDK2();
-  const instance = await relayerBundle.createInstance(config);
+  const instance = await relayerWeb.createInstance(config);
   if (typeof config.network === "string") {
     instance.network = config.network;
   }
@@ -215,7 +300,7 @@ async function initSDK2(params) {
   if (sdkInitialized) {
     return true;
   }
-  const result = await relayerBundle.initSDK(params);
+  const result = await relayerWeb.initSDK(params);
   sdkInitialized = true;
   return result;
 }
@@ -550,6 +635,43 @@ var ConfidentialToken = class {
       account: resolveWriteAccount(this.signer, this.walletClient)
     });
   }
+  async unwrapWithAuthorization(authorization, encryptedAmountInput, inputProof, signature) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const holder = assertAddress(authorization.holder, "holder address");
+    const to = assertAddress(authorization.to, "to address");
+    return this.walletClient.writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "unwrapWithAuthorization",
+      args: [
+        {
+          holder,
+          to,
+          validAfter: authorization.validAfter,
+          validBefore: authorization.validBefore,
+          nonce: authorization.nonce,
+          encryptedAmountHash: authorization.encryptedAmountHash
+        },
+        encryptedAmountInput,
+        inputProof,
+        signature
+      ],
+      chain: this.walletClient.chain ?? null,
+      account: resolveWriteAccount(this.signer, this.walletClient)
+    });
+  }
+  async finalizeUnwrap(burntAmount, burntAmountCleartext, decryptionProof) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const normalizedAmount = BigInt(normalizeAmount(burntAmountCleartext));
+    return this.walletClient.writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "finalizeUnwrap",
+      args: [burntAmount, normalizedAmount, decryptionProof],
+      chain: this.walletClient.chain ?? null,
+      account: resolveWriteAccount(this.signer, this.walletClient)
+    });
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -558,10 +680,12 @@ var ConfidentialToken = class {
   confidentialErrorCodes,
   confidentialPaymentTypes,
   confidentialTokenAbi,
+  createBrowserSigner,
   createEncryptedAmountInput,
   createNonce,
   createRelayer,
   decryptEuint64,
+  getBrowserEthereumProvider,
   getSepoliaConfig,
   getTransferAmounts,
   hashEncryptedAmountInput,

package/dist/index.mjs

@@ -59,6 +59,41 @@ var confidentialTokenAbi = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "holder", type: "address" },
+          { internalType: "address", name: "to", type: "address" },
+          { 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.UnwrapAuthorization",
+        name: "p",
+        type: "tuple"
+      },
+      { internalType: "bytes", name: "encryptedAmountInput", type: "bytes" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" },
+      { internalType: "bytes", name: "sig", type: "bytes" }
+    ],
+    name: "unwrapWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "burntAmount", type: "bytes32" },
+      { internalType: "uint64", name: "burntAmountCleartext", type: "uint64" },
+      { internalType: "bytes", name: "decryptionProof", type: "bytes" }
+    ],
+    name: "finalizeUnwrap",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     anonymous: false,
     inputs: [
@@ -145,16 +180,64 @@ function normalizeAmount(amount) {
   return amount.toString();
 }
 
+// src/core/signer.ts
+function stringifyPayload(payload) {
+  return JSON.stringify(
+    payload,
+    (_, value) => typeof value === "bigint" ? value.toString() : value
+  );
+}
+function getBrowserEthereumProvider() {
+  const provider = globalThis.ethereum;
+  if (!provider) {
+    throw new Error("Missing window.ethereum; install a wallet like MetaMask");
+  }
+  return provider;
+}
+async function createBrowserSigner(provider = getBrowserEthereumProvider()) {
+  const accounts = await provider.request({ method: "eth_requestAccounts" });
+  const account = accounts?.[0];
+  if (!account) {
+    throw new Error("No wallet account available");
+  }
+  return {
+    address: account,
+    signTypedData: async (args) => {
+      const signature = await provider.request({
+        method: "eth_signTypedData_v4",
+        params: [
+          account,
+          stringifyPayload({
+            domain: args.domain,
+            types: {
+              EIP712Domain: [
+                { name: "name", type: "string" },
+                { name: "version", type: "string" },
+                { name: "chainId", type: "uint256" },
+                { name: "verifyingContract", type: "address" }
+              ],
+              ...args.types
+            },
+            primaryType: args.primaryType,
+            message: args.message
+          })
+        ]
+      });
+      return signature;
+    }
+  };
+}
+
 // src/relayer/index.ts
 import { getAddress, toHex as toHex2 } from "viem";
-import * as relayerBundle from "@zama-fhe/relayer-sdk/bundle";
-var SepoliaConfig2 = relayerBundle.SepoliaConfig;
+import * as relayerWeb from "@zama-fhe/relayer-sdk/web";
+var SepoliaConfig2 = relayerWeb.SepoliaConfig;
 function getSepoliaConfig() {
-  return relayerBundle.SepoliaConfig;
+  return relayerWeb.SepoliaConfig;
 }
 async function createRelayer(config) {
   await initSDK2();
-  const instance = await relayerBundle.createInstance(config);
+  const instance = await relayerWeb.createInstance(config);
   if (typeof config.network === "string") {
     instance.network = config.network;
   }
@@ -165,7 +248,7 @@ async function initSDK2(params) {
   if (sdkInitialized) {
     return true;
   }
-  const result = await relayerBundle.initSDK(params);
+  const result = await relayerWeb.initSDK(params);
   sdkInitialized = true;
   return result;
 }
@@ -500,6 +583,43 @@ var ConfidentialToken = class {
       account: resolveWriteAccount(this.signer, this.walletClient)
     });
   }
+  async unwrapWithAuthorization(authorization, encryptedAmountInput, inputProof, signature) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const holder = assertAddress(authorization.holder, "holder address");
+    const to = assertAddress(authorization.to, "to address");
+    return this.walletClient.writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "unwrapWithAuthorization",
+      args: [
+        {
+          holder,
+          to,
+          validAfter: authorization.validAfter,
+          validBefore: authorization.validBefore,
+          nonce: authorization.nonce,
+          encryptedAmountHash: authorization.encryptedAmountHash
+        },
+        encryptedAmountInput,
+        inputProof,
+        signature
+      ],
+      chain: this.walletClient.chain ?? null,
+      account: resolveWriteAccount(this.signer, this.walletClient)
+    });
+  }
+  async finalizeUnwrap(burntAmount, burntAmountCleartext, decryptionProof) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const normalizedAmount = BigInt(normalizeAmount(burntAmountCleartext));
+    return this.walletClient.writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "finalizeUnwrap",
+      args: [burntAmount, normalizedAmount, decryptionProof],
+      chain: this.walletClient.chain ?? null,
+      account: resolveWriteAccount(this.signer, this.walletClient)
+    });
+  }
 };
 export {
   ConfidentialToken,
@@ -507,10 +627,12 @@ export {
   confidentialErrorCodes,
   confidentialPaymentTypes,
   confidentialTokenAbi,
+  createBrowserSigner,
   createEncryptedAmountInput,
   createNonce,
   createRelayer,
   decryptEuint64,
+  getBrowserEthereumProvider,
   getSepoliaConfig,
   getTransferAmounts,
   hashEncryptedAmountInput,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x402z-shared-web",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",