x402z-shared 0.0.1

package/dist/index.mjs

@@ -0,0 +1,191 @@
+import {
+  confidentialPaymentTypes,
+  confidentialTokenAbi,
+  createNonce,
+  hashEncryptedAmountInput,
+  normalizeAmount
+} from "./chunk-V7Z3OAXS.mjs";
+
+// src/relayer.ts
+import { createInstance, SepoliaConfig } from "@zama-fhe/relayer-sdk/node";
+import { getAddress, toHex } from "viem";
+async function createRelayerInstance(config) {
+  return createInstance(config);
+}
+async function createEncryptedAmountInput(relayer, contractAddress, senderAddress, amount) {
+  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);
+  return {
+    handle,
+    inputProof
+  };
+}
+async function userDecryptEuint64(relayer, handle, contractAddress, signer, options) {
+  const keypair = relayer.generateKeypair();
+  const startTimestamp = options?.startTimestamp ?? Math.floor(Date.now() / 1e3).toString();
+  const durationDays = options?.durationDays ?? "10";
+  const contractAddresses = [contractAddress];
+  const eip712 = relayer.createEIP712(keypair.publicKey, contractAddresses, startTimestamp, durationDays);
+  const types = { UserDecryptRequestVerification: eip712.types.UserDecryptRequestVerification };
+  const sign = signer.signTypedData;
+  const signature = sign.length >= 3 ? await sign(eip712.domain, types, eip712.message) : await sign({
+    domain: eip712.domain,
+    types,
+    primaryType: "UserDecryptRequestVerification",
+    message: eip712.message
+  });
+  const result = await relayer.userDecrypt(
+    [{ handle, contractAddress }],
+    keypair.privateKey,
+    keypair.publicKey,
+    signature.replace("0x", ""),
+    contractAddresses,
+    signer.address,
+    startTimestamp,
+    durationDays
+  );
+  return result[handle];
+}
+async function publicDecrypt(relayer, handles) {
+  const result = await relayer.publicDecrypt(handles);
+  return {
+    clearValues: result.clearValues,
+    decryptionProof: result.decryptionProof
+  };
+}
+
+// src/balance.ts
+import { createPublicClient, http, isAddress } from "viem";
+var ZERO_HANDLE = "0x" + "00".repeat(32);
+async function viewConfidentialBalance(options) {
+  if (!isAddress(options.tokenAddress)) {
+    throw new Error(`Invalid token address: ${options.tokenAddress}`);
+  }
+  const account = options.account ?? options.signer?.address;
+  if (!account || !isAddress(account)) {
+    throw new Error(`Invalid account address: ${account ?? "undefined"}`);
+  }
+  const publicClient = createPublicClient({ transport: http(options.rpcUrl) });
+  const confidentialBalanceAbi = [
+    {
+      inputs: [{ internalType: "address", name: "account", type: "address" }],
+      name: "confidentialBalanceOf",
+      outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+      stateMutability: "view",
+      type: "function"
+    }
+  ];
+  const handle = await publicClient.readContract({
+    address: options.tokenAddress,
+    abi: confidentialBalanceAbi,
+    functionName: "confidentialBalanceOf",
+    args: [account]
+  });
+  const shouldDecrypt = options.decrypt ?? true;
+  if (!shouldDecrypt) {
+    return { handle };
+  }
+  if (!options.signer) {
+    throw new Error("Missing signer for decryption");
+  }
+  if (handle === ZERO_HANDLE) {
+    return { handle, balance: 0n };
+  }
+  const balance = await userDecryptEuint64(
+    options.relayer,
+    handle,
+    options.tokenAddress,
+    options.signer
+  );
+  return { handle, balance };
+}
+
+// src/transfer.ts
+import { createPublicClient as createPublicClient2, decodeEventLog, getAddress as getAddress2, http as http2, isAddress as isAddress2, isHex } from "viem";
+async function viewConfidentialTransferAmounts(options) {
+  if (!isAddress2(options.tokenAddress)) {
+    throw new Error(`Invalid token address: ${options.tokenAddress}`);
+  }
+  if (!isHex(options.txHash, { strict: true })) {
+    throw new Error(`Invalid transaction hash: ${options.txHash}`);
+  }
+  if (options.from && !isAddress2(options.from)) {
+    throw new Error(`Invalid from address: ${options.from}`);
+  }
+  if (options.to && !isAddress2(options.to)) {
+    throw new Error(`Invalid to address: ${options.to}`);
+  }
+  const publicClient = createPublicClient2({ transport: http2(options.rpcUrl) });
+  const receipt = await publicClient.getTransactionReceipt({
+    hash: options.txHash
+  });
+  const tokenAddress = getAddress2(options.tokenAddress);
+  const fromFilter = options.from ? getAddress2(options.from) : void 0;
+  const toFilter = options.to ? getAddress2(options.to) : void 0;
+  const logs = receipt.logs.filter((log) => getAddress2(log.address) === tokenAddress);
+  const transfers = [];
+  for (const log of logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: confidentialTokenAbi,
+        eventName: "ConfidentialPaymentExecuted",
+        data: log.data,
+        topics: log.topics
+      });
+      const args = decoded.args;
+      const entry = {
+        holder: getAddress2(args.holder),
+        payee: getAddress2(args.payee),
+        maxClearAmount: BigInt(args.maxClearAmount),
+        resourceHash: args.resourceHash,
+        nonce: args.nonce,
+        handle: args.transferredAmount
+      };
+      if (fromFilter && entry.holder !== fromFilter) {
+        continue;
+      }
+      if (toFilter && entry.payee !== toFilter) {
+        continue;
+      }
+      const shouldDecrypt = options.decrypt ?? true;
+      if (shouldDecrypt) {
+        if (!options.signer) {
+          throw new Error("Missing signer for decryption");
+        }
+        const signerAddress = getAddress2(options.signer.address);
+        if (signerAddress !== getAddress2(entry.holder) && signerAddress !== getAddress2(entry.payee)) {
+          throw new Error("Signer must be the holder or payee to decrypt transfer amount");
+        }
+        entry.amount = await userDecryptEuint64(
+          options.relayer,
+          entry.handle,
+          tokenAddress,
+          options.signer
+        );
+      }
+      transfers.push(entry);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("ConfidentialPaymentExecuted")) {
+        throw error;
+      }
+    }
+  }
+  return transfers;
+}
+export {
+  SepoliaConfig,
+  confidentialPaymentTypes,
+  confidentialTokenAbi,
+  createEncryptedAmountInput,
+  createNonce,
+  createRelayerInstance,
+  hashEncryptedAmountInput,
+  normalizeAmount,
+  publicDecrypt,
+  userDecryptEuint64,
+  viewConfidentialBalance,
+  viewConfidentialTransferAmounts
+};

package/dist/types-RdcpJuhT.d.mts

@@ -0,0 +1,184 @@
+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";
+}];
+
+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 function createNonce(): `0x${string}`;
+declare function hashEncryptedAmountInput(encryptedAmountInput: `0x${string}`): `0x${string}`;
+declare function normalizeAmount(amount: string | number | bigint): 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}`;
+        facilitatorAddress?: `0x${string}`;
+    };
+};
+type ConfidentialPaymentInput = {
+    encryptedAmountInput: `0x${string}`;
+    inputProof: `0x${string}`;
+    maxClearAmount?: string;
+    resourceHash?: `0x${string}`;
+    validAfter?: number;
+    validBefore?: number;
+    nonce?: `0x${string}`;
+};
+
+export { type ConfidentialPaymentAuthorization as C, confidentialPaymentTypes as a, createNonce as b, confidentialTokenAbi as c, type ConfidentialPaymentPayload as d, type ConfidentialRequirementsExtra as e, type ConfidentialPaymentInput as f, hashEncryptedAmountInput as h, normalizeAmount as n };

package/dist/types-RdcpJuhT.d.ts

@@ -0,0 +1,184 @@
+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";
+}];
+
+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 function createNonce(): `0x${string}`;
+declare function hashEncryptedAmountInput(encryptedAmountInput: `0x${string}`): `0x${string}`;
+declare function normalizeAmount(amount: string | number | bigint): 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}`;
+        facilitatorAddress?: `0x${string}`;
+    };
+};
+type ConfidentialPaymentInput = {
+    encryptedAmountInput: `0x${string}`;
+    inputProof: `0x${string}`;
+    maxClearAmount?: string;
+    resourceHash?: `0x${string}`;
+    validAfter?: number;
+    validBefore?: number;
+    nonce?: `0x${string}`;
+};
+
+export { type ConfidentialPaymentAuthorization as C, confidentialPaymentTypes as a, createNonce as b, confidentialTokenAbi as c, type ConfidentialPaymentPayload as d, type ConfidentialRequirementsExtra as e, type ConfidentialPaymentInput as f, hashEncryptedAmountInput as h, normalizeAmount as n };

package/dist/web.d.mts

@@ -0,0 +1,71 @@
+export { C as ConfidentialPaymentAuthorization, f as ConfidentialPaymentInput, d as ConfidentialPaymentPayload, e as ConfidentialRequirementsExtra, a as confidentialPaymentTypes, c as confidentialTokenAbi, b as createNonce, h as hashEncryptedAmountInput, n as normalizeAmount } from './types-RdcpJuhT.mjs';
+import { createInstance } from '@zama-fhe/relayer-sdk/bundle';
+export { SepoliaConfig, initSDK } from '@zama-fhe/relayer-sdk/bundle';
+export * from '@x402/core/types';
+
+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: unknown): 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 ViewConfidentialBalanceOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    account?: `0x${string}`;
+    relayer: RelayerInstance;
+    signer?: RelayerSigner;
+    decrypt?: boolean;
+};
+declare function viewConfidentialBalance(options: ViewConfidentialBalanceOptions): Promise<{
+    handle: `0x${string}`;
+    balance?: bigint;
+}>;
+
+type ConfidentialTransferAmount = {
+    holder: `0x${string}`;
+    payee: `0x${string}`;
+    maxClearAmount: bigint;
+    resourceHash: `0x${string}`;
+    nonce: `0x${string}`;
+    handle: `0x${string}`;
+    amount?: bigint;
+};
+type ViewConfidentialTransferOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    txHash: `0x${string}`;
+    from?: `0x${string}`;
+    to?: `0x${string}`;
+    relayer: RelayerInstance;
+    signer?: RelayerSigner;
+    decrypt?: boolean;
+};
+declare function viewConfidentialTransferAmounts(options: ViewConfidentialTransferOptions): Promise<ConfidentialTransferAmount[]>;
+
+export { type ConfidentialTransferAmount, type RelayerInstance, type RelayerSigner, type ViewConfidentialBalanceOptions, type ViewConfidentialTransferOptions, createEncryptedAmountInput, createRelayerInstance, publicDecrypt, userDecryptEuint64, viewConfidentialBalance, viewConfidentialTransferAmounts };

package/dist/web.d.ts

@@ -0,0 +1,71 @@
+export { C as ConfidentialPaymentAuthorization, f as ConfidentialPaymentInput, d as ConfidentialPaymentPayload, e as ConfidentialRequirementsExtra, a as confidentialPaymentTypes, c as confidentialTokenAbi, b as createNonce, h as hashEncryptedAmountInput, n as normalizeAmount } from './types-RdcpJuhT.js';
+import { createInstance } from '@zama-fhe/relayer-sdk/bundle';
+export { SepoliaConfig, initSDK } from '@zama-fhe/relayer-sdk/bundle';
+export * from '@x402/core/types';
+
+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: unknown): 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 ViewConfidentialBalanceOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    account?: `0x${string}`;
+    relayer: RelayerInstance;
+    signer?: RelayerSigner;
+    decrypt?: boolean;
+};
+declare function viewConfidentialBalance(options: ViewConfidentialBalanceOptions): Promise<{
+    handle: `0x${string}`;
+    balance?: bigint;
+}>;
+
+type ConfidentialTransferAmount = {
+    holder: `0x${string}`;
+    payee: `0x${string}`;
+    maxClearAmount: bigint;
+    resourceHash: `0x${string}`;
+    nonce: `0x${string}`;
+    handle: `0x${string}`;
+    amount?: bigint;
+};
+type ViewConfidentialTransferOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    txHash: `0x${string}`;
+    from?: `0x${string}`;
+    to?: `0x${string}`;
+    relayer: RelayerInstance;
+    signer?: RelayerSigner;
+    decrypt?: boolean;
+};
+declare function viewConfidentialTransferAmounts(options: ViewConfidentialTransferOptions): Promise<ConfidentialTransferAmount[]>;
+
+export { type ConfidentialTransferAmount, type RelayerInstance, type RelayerSigner, type ViewConfidentialBalanceOptions, type ViewConfidentialTransferOptions, createEncryptedAmountInput, createRelayerInstance, publicDecrypt, userDecryptEuint64, viewConfidentialBalance, viewConfidentialTransferAmounts };