x402z-shared 0.0.3 → 0.0.5

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { R as RelayerInstance, a as RelayerSigner } from './types-gx3OAvqG.mjs';
-export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, g as createEncryptedAmountInput, e as createNonce, f as createRelayerInstance, h as hashEncryptedAmountInput, n as normalizeAmount, p as publicDecrypt, s as setObserver, u as userDecryptEuint64 } from './types-gx3OAvqG.mjs';
+import { R as RelayerInstance, a as RelayerSigner } from './types-Cy4f8wJ6.mjs';
+export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, g as createEncryptedAmountInput, e as createNonce, f as createRelayerInstance, h as hashEncryptedAmountInput, n as normalizeAmount, p as publicDecrypt, s as setObserver, u as userDecryptEuint64 } from './types-Cy4f8wJ6.mjs';
 export * from '@x402/core/types';
 export { FhevmInstanceConfig, SepoliaConfig } from '@zama-fhe/relayer-sdk/node';
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { R as RelayerInstance, a as RelayerSigner } from './types-gx3OAvqG.js';
-export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, g as createEncryptedAmountInput, e as createNonce, f as createRelayerInstance, h as hashEncryptedAmountInput, n as normalizeAmount, p as publicDecrypt, s as setObserver, u as userDecryptEuint64 } from './types-gx3OAvqG.js';
+import { R as RelayerInstance, a as RelayerSigner } from './types-Cy4f8wJ6.js';
+export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, g as createEncryptedAmountInput, e as createNonce, f as createRelayerInstance, h as hashEncryptedAmountInput, n as normalizeAmount, p as publicDecrypt, s as setObserver, u as userDecryptEuint64 } from './types-Cy4f8wJ6.js';
 export * from '@x402/core/types';
 export { FhevmInstanceConfig, SepoliaConfig } from '@zama-fhe/relayer-sdk/node';
 

package/dist/types-Cy4f8wJ6.d.mts

@@ -0,0 +1,266 @@
+import { FhevmInstanceConfig, createInstance } from '@zama-fhe/relayer-sdk/node';
+
+declare const confidentialTokenAbi: readonly [{
+    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 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;
+    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 createRelayerInstance(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?: {
+    durationDays?: string;
+    startTimestamp?: string;
+}): Promise<bigint>;
+declare function publicDecrypt(relayer: RelayerInstance, handles: string[]): Promise<{
+    clearValues: Record<string, bigint>;
+    decryptionProof: string;
+}>;
+
+type SetObserverOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    account: `0x${string}`;
+    observer: `0x${string}`;
+    signer: RelayerSigner & {
+        writeContract: (args: {
+            address: `0x${string}`;
+            abi: typeof confidentialTokenAbi;
+            functionName: "setObserver";
+            args: [`0x${string}`, `0x${string}`];
+        }) => Promise<`0x${string}`>;
+    };
+};
+declare function setObserver(options: SetObserverOptions): 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 as C, type RelayerInstance as R, type SetObserverOptions as S, type RelayerSigner as a, confidentialPaymentTypes as b, confidentialTokenAbi as c, confidentialErrorCodes as d, createNonce as e, createRelayerInstance as f, createEncryptedAmountInput as g, hashEncryptedAmountInput as h, type ConfidentialPaymentAuthorization as i, type ConfidentialPaymentPayload as j, type ConfidentialRequirementsExtra as k, type ConfidentialPaymentInput as l, normalizeAmount as n, publicDecrypt as p, setObserver as s, userDecryptEuint64 as u };

package/dist/types-Cy4f8wJ6.d.ts

@@ -0,0 +1,266 @@
+import { FhevmInstanceConfig, createInstance } from '@zama-fhe/relayer-sdk/node';
+
+declare const confidentialTokenAbi: readonly [{
+    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 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;
+    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 createRelayerInstance(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?: {
+    durationDays?: string;
+    startTimestamp?: string;
+}): Promise<bigint>;
+declare function publicDecrypt(relayer: RelayerInstance, handles: string[]): Promise<{
+    clearValues: Record<string, bigint>;
+    decryptionProof: string;
+}>;
+
+type SetObserverOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    account: `0x${string}`;
+    observer: `0x${string}`;
+    signer: RelayerSigner & {
+        writeContract: (args: {
+            address: `0x${string}`;
+            abi: typeof confidentialTokenAbi;
+            functionName: "setObserver";
+            args: [`0x${string}`, `0x${string}`];
+        }) => Promise<`0x${string}`>;
+    };
+};
+declare function setObserver(options: SetObserverOptions): 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 as C, type RelayerInstance as R, type SetObserverOptions as S, type RelayerSigner as a, confidentialPaymentTypes as b, confidentialTokenAbi as c, confidentialErrorCodes as d, createNonce as e, createRelayerInstance as f, createEncryptedAmountInput as g, hashEncryptedAmountInput as h, type ConfidentialPaymentAuthorization as i, type ConfidentialPaymentPayload as j, type ConfidentialRequirementsExtra as k, type ConfidentialPaymentInput as l, normalizeAmount as n, publicDecrypt as p, setObserver as s, userDecryptEuint64 as u };

package/dist/web.d.mts

@@ -1,6 +1,6 @@
-export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, e as createNonce, h as hashEncryptedAmountInput, n as normalizeAmount, s as setObserver } from './types-gx3OAvqG.mjs';
-import { createInstance } from '@zama-fhe/relayer-sdk/bundle';
-export { SepoliaConfig, initSDK } from '@zama-fhe/relayer-sdk/bundle';
+export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, e as createNonce, h as hashEncryptedAmountInput, n as normalizeAmount, s as setObserver } from './types-Cy4f8wJ6.mjs';
+import { createInstance } from '@zama-fhe/relayer-sdk/web';
+export { SepoliaConfig, initSDK } from '@zama-fhe/relayer-sdk/web';
 import { WalletClient } from 'viem';
 export * from '@x402/core/types';
 import '@zama-fhe/relayer-sdk/node';

package/dist/web.d.ts

@@ -1,6 +1,6 @@
-export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, e as createNonce, h as hashEncryptedAmountInput, n as normalizeAmount, s as setObserver } from './types-gx3OAvqG.js';
-import { createInstance } from '@zama-fhe/relayer-sdk/bundle';
-export { SepoliaConfig, initSDK } from '@zama-fhe/relayer-sdk/bundle';
+export { C as ConfidentialErrorCode, i as ConfidentialPaymentAuthorization, l as ConfidentialPaymentInput, j as ConfidentialPaymentPayload, k as ConfidentialRequirementsExtra, S as SetObserverOptions, d as confidentialErrorCodes, b as confidentialPaymentTypes, c as confidentialTokenAbi, e as createNonce, h as hashEncryptedAmountInput, n as normalizeAmount, s as setObserver } from './types-Cy4f8wJ6.js';
+import { createInstance } from '@zama-fhe/relayer-sdk/web';
+export { SepoliaConfig, initSDK } from '@zama-fhe/relayer-sdk/web';
 import { WalletClient } from 'viem';
 export * from '@x402/core/types';
 import '@zama-fhe/relayer-sdk/node';

package/dist/web.js

@@ -20,7 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/web.ts
 var web_exports = {};
 __export(web_exports, {
-  SepoliaConfig: () => import_bundle.SepoliaConfig,
+  SepoliaConfig: () => import_web.SepoliaConfig,
   confidentialErrorCodes: () => confidentialErrorCodes,
   confidentialPaymentTypes: () => confidentialPaymentTypes,
   confidentialTokenAbi: () => confidentialTokenAbi,
@@ -28,7 +28,7 @@ __export(web_exports, {
   createNonce: () => createNonce,
   createRelayerInstance: () => createRelayerInstance,
   hashEncryptedAmountInput: () => hashEncryptedAmountInput,
-  initSDK: () => import_bundle.initSDK,
+  initSDK: () => import_web.initSDK,
   normalizeAmount: () => normalizeAmount,
   publicDecrypt: () => publicDecrypt,
   setObserver: () => setObserver,
@@ -154,10 +154,10 @@ function normalizeAmount(amount) {
 }
 
 // src/relayer-web.ts
-var import_bundle = require("@zama-fhe/relayer-sdk/bundle");
+var import_web = require("@zama-fhe/relayer-sdk/web");
 var import_viem2 = require("viem");
 async function createRelayerInstance(config) {
-  const instance = await (0, import_bundle.createInstance)(config);
+  const instance = await (0, import_web.createInstance)(config);
   if (typeof config.network === "string") {
     instance.network = config.network;
   }

package/dist/web.mjs

@@ -9,7 +9,7 @@ import {
 } from "./chunk-LTE4V3LT.mjs";
 
 // src/relayer-web.ts
-import { createInstance, initSDK, SepoliaConfig } from "@zama-fhe/relayer-sdk/bundle";
+import { createInstance, initSDK, SepoliaConfig } from "@zama-fhe/relayer-sdk/web";
 import { getAddress, toHex } from "viem";
 async function createRelayerInstance(config) {
   const instance = await createInstance(config);

package/package.json

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