@provex/utils 1.0.16 → 1.2.3

package/dist/src/payment.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/payment.test.js

@@ -0,0 +1,272 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { base } from 'viem/chains';
+import { providerConfigs, getCurrenciesForProvider, verifierGetsKey, providerKeyToContractId } from './payment.js';
+import { SUPPORTED_CURRENCIES } from './currencies.js';
+describe('getCurrenciesForProvider', () => {
+    const configs = providerConfigs(base.id);
+    describe('Zelle (USD only)', () => {
+        it('returns exactly 1 currency', () => {
+            const currencies = getCurrenciesForProvider(configs.zelle);
+            assert.equal(currencies.length, 1, `Expected 1 currency for Zelle, got ${currencies.length}`);
+        });
+        it('returns USD', () => {
+            const currencies = getCurrenciesForProvider(configs.zelle);
+            assert.equal(currencies[0].ticker, 'USD');
+        });
+        it('does not include EUR', () => {
+            const currencies = getCurrenciesForProvider(configs.zelle);
+            const tickers = currencies.map(c => c.ticker);
+            assert.ok(!tickers.includes('EUR'), 'Zelle should not include EUR');
+        });
+    });
+    describe('Revolut (multi-currency)', () => {
+        it('returns more than 10 currencies', () => {
+            const currencies = getCurrenciesForProvider(configs.revolut);
+            assert.ok(currencies.length > 10, `Expected >10 currencies for Revolut, got ${currencies.length}`);
+        });
+        it('includes USD', () => {
+            const currencies = getCurrenciesForProvider(configs.revolut);
+            const tickers = currencies.map(c => c.ticker);
+            assert.ok(tickers.includes('USD'), 'Revolut should include USD');
+        });
+        it('includes EUR', () => {
+            const currencies = getCurrenciesForProvider(configs.revolut);
+            const tickers = currencies.map(c => c.ticker);
+            assert.ok(tickers.includes('EUR'), 'Revolut should include EUR');
+        });
+        it('includes GBP', () => {
+            const currencies = getCurrenciesForProvider(configs.revolut);
+            const tickers = currencies.map(c => c.ticker);
+            assert.ok(tickers.includes('GBP'), 'Revolut should include GBP');
+        });
+    });
+    describe('Wise (multi-currency)', () => {
+        it('returns more than 15 currencies', () => {
+            const currencies = getCurrenciesForProvider(configs.wise);
+            assert.ok(currencies.length > 15, `Expected >15 currencies for Wise, got ${currencies.length}`);
+        });
+        it('includes JPY (zero-decimal currency)', () => {
+            const currencies = getCurrenciesForProvider(configs.wise);
+            const tickers = currencies.map(c => c.ticker);
+            assert.ok(tickers.includes('JPY'), 'Wise should include JPY');
+        });
+        it('includes CNY', () => {
+            const currencies = getCurrenciesForProvider(configs.wise);
+            const tickers = currencies.map(c => c.ticker);
+            assert.ok(tickers.includes('CNY'), 'Wise should include CNY');
+        });
+    });
+    describe('Venmo (USD only)', () => {
+        it('returns exactly 1 currency', () => {
+            const currencies = getCurrenciesForProvider(configs.venmo);
+            assert.equal(currencies.length, 1, `Expected 1 currency for Venmo, got ${currencies.length}`);
+        });
+        it('returns USD', () => {
+            const currencies = getCurrenciesForProvider(configs.venmo);
+            assert.equal(currencies[0].ticker, 'USD');
+        });
+    });
+    describe('Monzo (GBP only)', () => {
+        it('returns exactly 1 currency', () => {
+            const currencies = getCurrenciesForProvider(configs.monzo);
+            assert.equal(currencies.length, 1, `Expected 1 currency for Monzo, got ${currencies.length}`);
+        });
+        it('returns GBP', () => {
+            const currencies = getCurrenciesForProvider(configs.monzo);
+            assert.equal(currencies[0].ticker, 'GBP');
+        });
+    });
+    describe('MercadoPago (ARS only)', () => {
+        it('returns exactly 1 currency', () => {
+            const currencies = getCurrenciesForProvider(configs.mercadopago);
+            assert.equal(currencies.length, 1, `Expected 1 currency for MercadoPago, got ${currencies.length}`);
+        });
+        it('returns ARS', () => {
+            const currencies = getCurrenciesForProvider(configs.mercadopago);
+            assert.equal(currencies[0].ticker, 'ARS');
+        });
+    });
+    describe('return type validation', () => {
+        it('returns Currency instances with all expected properties', () => {
+            const currencies = getCurrenciesForProvider(configs.zelle);
+            const usd = currencies[0];
+            assert.ok(usd.ticker, 'Currency should have ticker');
+            assert.ok(usd.symbol, 'Currency should have symbol');
+            assert.ok(usd.name, 'Currency should have name');
+            assert.ok(typeof usd.decimals === 'number', 'Currency should have decimals as number');
+            assert.ok(usd.contractId, 'Currency should have contractId');
+        });
+        it('returns currencies matching SUPPORTED_CURRENCIES', () => {
+            const currencies = getCurrenciesForProvider(configs.zelle);
+            const usd = currencies[0];
+            assert.equal(usd.ticker, SUPPORTED_CURRENCIES.USD.ticker);
+            assert.equal(usd.contractId, SUPPORTED_CURRENCIES.USD.contractId);
+        });
+    });
+});
+/**
+ * Tests for verifierGetsKey - handles both V2 (address) and V3 (bytes32 hash)
+ */
+describe('verifierGetsKey', () => {
+    describe('32-byte paymentMethod hash (V3)', () => {
+        it('returns correct provider key for venmo hash', () => {
+            // Generate the venmo contract ID (keccak256 hash)
+            const venmoHash = providerKeyToContractId('venmo');
+            const result = verifierGetsKey(base.id, venmoHash);
+            assert.equal(result, 'venmo', `Expected 'venmo' for hash ${venmoHash}, got '${result}'`);
+        });
+        it('returns correct provider key for zelle hash', () => {
+            const zelleHash = providerKeyToContractId('zelle');
+            const result = verifierGetsKey(base.id, zelleHash);
+            assert.equal(result, 'zelle', `Expected 'zelle' for hash ${zelleHash}, got '${result}'`);
+        });
+        it('returns correct provider key for revolut hash', () => {
+            const revolutHash = providerKeyToContractId('revolut');
+            const result = verifierGetsKey(base.id, revolutHash);
+            assert.equal(result, 'revolut', `Expected 'revolut' for hash ${revolutHash}, got '${result}'`);
+        });
+        it('returns correct provider key for wise hash', () => {
+            const wiseHash = providerKeyToContractId('wise');
+            const result = verifierGetsKey(base.id, wiseHash);
+            assert.equal(result, 'wise', `Expected 'wise' for hash ${wiseHash}, got '${result}'`);
+        });
+        it('returns MANUAL for unknown 32-byte hash', () => {
+            const unknownHash = '0x0000000000000000000000000000000000000000000000000000000000000001';
+            const result = verifierGetsKey(base.id, unknownHash);
+            assert.equal(result, 'manual', `Expected 'manual' for unknown hash, got '${result}'`);
+        });
+    });
+    describe('20-byte verifier address (V2)', () => {
+        it('returns correct provider key for venmo verifier address', () => {
+            // V2 venmo verifier on Base
+            const venmoVerifier = '0x9a733B55a875D0DB4915c6B36350b24F8AB99dF5';
+            const result = verifierGetsKey(base.id, venmoVerifier);
+            assert.equal(result, 'venmo', `Expected 'venmo' for address ${venmoVerifier}, got '${result}'`);
+        });
+        it('returns correct provider key for revolut verifier address', () => {
+            // V2 revolut verifier on Base
+            const revolutVerifier = '0xAA5A1B62B01781E789C900d616300717CD9A41aB';
+            const result = verifierGetsKey(base.id, revolutVerifier);
+            assert.equal(result, 'revolut', `Expected 'revolut' for address ${revolutVerifier}, got '${result}'`);
+        });
+        it('returns MANUAL for unknown address', () => {
+            const unknownAddress = '0x0000000000000000000000000000000000000001';
+            const result = verifierGetsKey(base.id, unknownAddress);
+            assert.equal(result, 'manual', `Expected 'manual' for unknown address, got '${result}'`);
+        });
+    });
+    describe('edge cases', () => {
+        it('returns MANUAL for empty string', () => {
+            const result = verifierGetsKey(base.id, '');
+            assert.equal(result, 'manual');
+        });
+        it('returns MANUAL for 0x', () => {
+            const result = verifierGetsKey(base.id, '0x');
+            assert.equal(result, 'manual');
+        });
+        it('handles null chainId gracefully', () => {
+            const venmoHash = providerKeyToContractId('venmo');
+            const result = verifierGetsKey(null, venmoHash);
+            // Should still work via contractId lookup
+            assert.ok(['venmo', 'manual'].includes(result), `Expected 'venmo' or 'manual', got '${result}'`);
+        });
+    });
+});
+/**
+ * Tests for providerConfigs - payment provider configuration
+ */
+describe('providerConfigs', () => {
+    const configs = providerConfigs(base.id);
+    describe('sendLink functions', () => {
+        it('venmo sendLink generates correct URL without QR code', () => {
+            const result = configs.venmo.sendLink?.({ username: 'testuser', amount: 100n });
+            assert.ok(result?.includes('account.venmo.com/pay'), 'Should use web URL');
+            assert.ok(result?.includes('testuser'), 'Should include username');
+            assert.ok(result?.includes('100'), 'Should include amount');
+        });
+        it('venmo sendLink generates correct URL with QR code', () => {
+            const result = configs.venmo.sendLink?.({ username: 'testuser', amount: 100n, qrCode: true });
+            assert.ok(result?.startsWith('venmo://'), 'Should use venmo:// protocol');
+        });
+        it('cashapp sendLink generates correct URL', () => {
+            const result = configs.cashapp.sendLink?.({ username: '$testuser', amount: 100n });
+            assert.ok(result?.includes('cash.app'), 'Should use cash.app URL');
+        });
+        it('cashapp sendLink handles username without $ prefix', () => {
+            const result = configs.cashapp.sendLink?.({ username: 'testuser', amount: 100n });
+            assert.ok(result?.includes('$testuser'), 'Should add $ prefix to username');
+        });
+        it('revolut sendLink generates correct URL', () => {
+            const result = configs.revolut.sendLink?.({ username: 'testuser', amount: 100n });
+            assert.ok(result?.includes('revolut.me'), 'Should use revolut.me URL');
+        });
+        it('wise sendLink generates correct URL', () => {
+            const result = configs.wise.sendLink?.({ username: 'testuser', amount: 100n });
+            assert.ok(result?.includes('wise.com/pay/me'), 'Should use wise.com URL');
+        });
+        it('mercadopago sendLink generates correct URL', () => {
+            const result = configs.mercadopago.sendLink?.({ username: 'testuser', amount: 100n });
+            assert.ok(result?.includes('mercadopago.com'), 'Should use mercadopago URL');
+        });
+        // PayPal sendLink tests removed — provider disabled
+    });
+    describe('risk levels', () => {
+        it('zelle has medium risk level', () => {
+            assert.equal(configs.zelle.riskLevel, 'medium');
+        });
+        it('venmo has high risk level', () => {
+            assert.equal(configs.venmo.riskLevel, 'high');
+        });
+        it('cashapp has high risk level', () => {
+            assert.equal(configs.cashapp.riskLevel, 'high');
+        });
+        it('revolut has low risk level', () => {
+            assert.equal(configs.revolut.riskLevel, 'low');
+        });
+        it('wise has low risk level', () => {
+            assert.equal(configs.wise.riskLevel, 'low');
+        });
+    });
+    describe('cooldown settings', () => {
+        it('zelle has cooldown', () => {
+            assert.equal(configs.zelle.hasCooldown, true);
+        });
+        it('venmo has cooldown', () => {
+            assert.equal(configs.venmo.hasCooldown, true);
+        });
+        it('revolut has no cooldown', () => {
+            assert.equal(configs.revolut.hasCooldown, false);
+        });
+        it('wise has no cooldown', () => {
+            assert.equal(configs.wise.hasCooldown, false);
+        });
+    });
+    describe('cap multipliers', () => {
+        it('zelle has cap multiplier of 1.5', () => {
+            assert.equal(configs.zelle.capMultiplier, 1.5);
+        });
+        it('venmo has cap multiplier of 1', () => {
+            assert.equal(configs.venmo.capMultiplier, 1);
+        });
+        it('revolut has cap multiplier of 5', () => {
+            assert.equal(configs.revolut.capMultiplier, 5);
+        });
+    });
+    describe('sub-providers', () => {
+        it('zelle has sub-providers', () => {
+            assert.ok(configs.zelle.subProviders.size > 0, 'Zelle should have sub-providers');
+        });
+        it('venmo has no sub-providers', () => {
+            assert.equal(configs.venmo.subProviders.size, 0, 'Venmo should not have sub-providers');
+        });
+    });
+    describe('currency lists', () => {
+        it('revolut has more than 10 currencies', () => {
+            assert.ok(configs.revolut.list.length > 10, `Expected >10 currencies for Revolut, got ${configs.revolut.list.length}`);
+        });
+        it('wise has more than 15 currencies', () => {
+            assert.ok(configs.wise.list.length > 15, `Expected >15 currencies for Wise, got ${configs.wise.list.length}`);
+        });
+    });
+});

package/dist/src/peer-types.d.ts

@@ -0,0 +1,327 @@
+/**
+ * @fileoverview Peer protocol types for attestation and proof verification.
+ *
+ * This module defines the type system for the V3 attestation flow, including:
+ * - Notarized proofs from the PeerAuth browser extension
+ * - Attestation requests/responses from the peer attestation service
+ * - EIP-712 typed data structures for on-chain verification
+ * - Payment proof encoding for the UnifiedPaymentVerifier contract
+ *
+ * @remarks
+ * **V3 Attestation Flow:**
+ * 1. Buyer generates zkTLS proof via PeerAuth extension (NotarizedProofData)
+ * 2. Proof + intent data sent to attestation service (V3AttestationRequest)
+ * 3. Service validates and returns EIP-712 signed attestation (V3AttestationResponse)
+ * 4. Attestation encoded as paymentProof bytes (encodeV3PaymentProof)
+ * 5. Buyer calls fulfillIntent() with encoded proof
+ *
+ * **Type Aliases:**
+ * For cleaner imports, V3-prefixed types have unprefixed aliases:
+ * - AttestationOptions = V3AttestationOptions
+ * - AttestationResponse = V3AttestationResponse
+ * - IntentData = V3IntentData
+ *
+ * @see {@link intent} for intent data structures
+ * @see {@link payment} for provider definitions
+ */
+import { type Hex } from "viem";
+import type { ProviderKey, SubProviderKey, ValidationDepositData } from "./payment.js";
+/**
+ * Options for validating a depositor's payee details with the peer gating service.
+ */
+export type ValidationOptions = {
+    providerKey: ProviderKey;
+    telegramHandle: string;
+    providerId: string;
+};
+export type PeerResponse<T> = {
+    success: boolean;
+    message: string;
+    statusCode: number;
+    responseObject: T;
+};
+export type CreateResponse = {
+    id: number;
+    processorName: string;
+    depositData: string;
+    hashedOnchainId: Hex;
+    createdAt: string;
+};
+export type PayeeDetails = {
+    /** Present in ZKP2P API responses; absent from locally-registered makers. */
+    id?: number;
+    processorName: string;
+    /** Present from local maker registration; may be absent in ZKP2P API responses. */
+    createdAt?: string;
+    hashedOnchainId: Hex;
+    /** Double-hash of the on-chain ID — returned by ZKP2P API, not locally generated. */
+    hashedHashedOnchainId?: Hex;
+    depositData: ValidationDepositData;
+    /**
+     * Account type string from ZKP2P API. Derived from their `isBusiness` flag:
+     * `true` → `'business'`, `false` → `'personal'`.
+     * Stored as a string to accommodate future types without a schema change.
+     */
+    accountType?: string;
+};
+export type IntentValidationOptions = {
+    processorName: ProviderKey;
+    depositId: string;
+    /** Token amount (was tokenAmount, renamed to amount for v2 API) */
+    amount: string;
+    payeeDetails: Hex;
+    toAddress: Hex;
+    /** Payment method bytes32 hash */
+    paymentMethod: Hex;
+    /** Fiat currency bytes32 hash */
+    fiatCurrency: Hex;
+    /** Conversion rate as string */
+    conversionRate: string;
+    chainId: string;
+    /** Orchestrator contract address */
+    orchestratorAddress: Hex;
+    /** Escrow contract address */
+    escrowAddress: Hex;
+    /** Optional sub-provider for providers like Zelle that have multiple banks (e.g., 'zelle-chase', 'zelle-bofa') */
+    subProvider?: SubProviderKey;
+};
+export type IntentValidation = {
+    signedIntent: Hex;
+    intentData: {
+        depositId: string;
+        tokenAmount: string;
+        recipientAddress: Hex;
+        verifierAddress: Hex;
+        currencyCodeHash: Hex;
+        gatingServiceSignature: Hex;
+    };
+    depositData: ValidationDepositData;
+};
+/**
+ * Notarized proof from PeerAuth extension.
+ * This is the zkTLS proof that proves a payment transaction occurred.
+ * Mirrors the NotarizedProof type from @provex/extension-react.
+ */
+export type NotarizedProofData = {
+    claim: {
+        context: string;
+        epoch: number;
+        identifier: Hex;
+        owner: Hex;
+        parameters: string;
+        provider: string;
+        timestampS: number;
+    };
+    signatures: {
+        attestorAddress: Hex;
+        claimSignature: Record<number, number>;
+        resultSignature: Record<number, number>;
+    };
+};
+/**
+ * Intent data required by the peer attestation service.
+ * This contains all the on-chain intent parameters needed to verify
+ * that the off-chain payment matches the signaled intent.
+ */
+export type V3IntentData = {
+    /** The intent hash from signalIntent */
+    intentHash: Hex;
+    /** Token amount in smallest unit (e.g., USDC with 6 decimals) */
+    amount: string;
+    /** Intent timestamp in milliseconds */
+    timestampMs: string;
+    /** Payment method bytes32 hash */
+    paymentMethod: Hex;
+    /** Fiat currency bytes32 hash */
+    fiatCurrency: Hex;
+    /** Conversion rate as string (scaled by 1e18) */
+    conversionRate: string;
+    /** Payee details hash */
+    payeeDetails: Hex;
+    /** Optional timestamp buffer in milliseconds (default: 3000) */
+    timestampBufferMs?: string;
+};
+/**
+ * V3 attestation request sent to the peer attestation service.
+ * The service validates Reclaim proofs and returns an EIP-712 signed attestation.
+ *
+ * Endpoint: POST /verify/{platform}/{action_type}
+ * Example: POST /verify/chase/transfer_zelle
+ */
+export type V3AttestationRequest = {
+    /** Type of proof being submitted */
+    proofType: 'reclaim';
+    /** JSON stringified array of Reclaim proofs */
+    proof: string;
+    /** Chain ID (e.g., 8453 for Base) */
+    chainId: number;
+    /** UnifiedPaymentVerifier contract address */
+    verifyingContract: Hex;
+    /** Intent data from on-chain signalIntent */
+    intent: V3IntentData;
+};
+/**
+ * Options passed to the v3 getAttestation API.
+ * These are transformed into V3AttestationRequest format.
+ */
+export type V3AttestationOptions = {
+    /** Platform for the attestation service path (e.g., 'chase') */
+    platform: string;
+    /** Action type for the attestation service path (e.g., 'transfer_zelle') */
+    actionType: string;
+    /** Chain ID */
+    chainId: number;
+    /** UnifiedPaymentVerifier contract address */
+    verifyingContract: Hex;
+    /** Array of Reclaim proofs from PeerAuth */
+    proofs: NotarizedProofData[];
+    /** Intent data from on-chain intent */
+    intent: V3IntentData;
+};
+/**
+ * EIP-712 typed data specification from attestation service.
+ */
+export type V3TypedDataSpec = {
+    primaryType: string;
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+};
+/**
+ * EIP-712 typed data values from attestation service.
+ * These are the actual values that were signed.
+ */
+export type V3TypedDataValue = {
+    intentHash: Hex;
+    releaseAmount: string;
+    dataHash: Hex;
+};
+/**
+ * Response object from the peer attestation service.
+ * Contains the EIP-712 signed attestation for on-chain verification.
+ */
+export type V3AttestationResponseObject = {
+    /** EIP-712 signature to submit to fulfillIntent as paymentProof */
+    signature: Hex;
+    /** Address of the attestation signer */
+    signer: Hex;
+    /** EIP-712 domain separator */
+    domainSeparator: Hex;
+    /** EIP-712 type hash */
+    typeHash: Hex;
+    /** EIP-712 type specification */
+    typedDataSpec: V3TypedDataSpec;
+    /** The actual values that were signed */
+    typedDataValue: V3TypedDataValue;
+    /** ABI-encoded payment details for on-chain verification */
+    encodedPaymentDetails: Hex;
+    /** Additional metadata */
+    metadata: Hex;
+    /** Original proof input (for debugging) */
+    proofInput: string;
+    /** Platform used (e.g., 'chase') */
+    platform: string;
+    /** Action type (e.g., 'transfer_zelle') */
+    actionType: string;
+};
+/**
+ * Full response from the peer attestation service.
+ * Wrapped in standard PeerResponse format.
+ */
+export type V3AttestationResponse = PeerResponse<V3AttestationResponseObject>;
+/**
+ * @deprecated Use V3AttestationResponseObject for the inner response data
+ */
+export type V3PaymentAttestation = {
+    depositor: Hex;
+    depositId: string;
+    amount: string;
+    paymentId: string;
+    timestamp: number;
+};
+export type V3IntentSignalOptions = {
+    depositId: string;
+    amount: string;
+    attestation: V3AttestationResponse;
+    chainId: number;
+};
+export type V3IntentFulfillOptions = {
+    intentId: string;
+    chainId: number;
+};
+/**
+ * EIP-712 domain separator fields.
+ * Used for typed structured data hashing and signing per EIP-712.
+ * @see https://eips.ethereum.org/EIPS/eip-712
+ */
+export type EIP712Domain = {
+    /** Human-readable name of the signing domain (e.g., "Peer") */
+    name: string;
+    /** Version of the signing domain (e.g., "1") */
+    version: string;
+    /** Chain ID of the network where the contract is deployed */
+    chainId: number;
+    /** Address of the contract that will verify the signature */
+    verifyingContract: Hex;
+};
+/**
+ * A payment attestation with its EIP-712 signature.
+ * This is the complete attestation package sent to the contract for verification.
+ */
+export type SignedAttestation = {
+    /** The payment attestation data */
+    attestation: V3PaymentAttestation;
+    /** EIP-712 typed signature of the attestation */
+    signature: Hex;
+};
+/**
+ * Encodes a V3 attestation response into the paymentProof bytes format
+ * expected by the UnifiedPaymentVerifier contract's fulfillIntent function.
+ *
+ * The encoded struct contains (wrapped in outer tuple for offset prefix):
+ * - PaymentAttestation: { intentHash, releaseAmount, dataHash }
+ * - signatures: [signature] (array with the EIP-712 signature)
+ * - encodedPaymentDetails: payment details for on-chain verification
+ * - metadata: additional metadata bytes
+ * - attestorAddresses: [signer] (array with the attestor address)
+ *
+ * @param attestation - The V3AttestationResponseObject from the attestation service
+ * @returns ABI-encoded bytes to pass as paymentProof in fulfillIntent
+ */
+export declare function encodeV3PaymentProof(attestation: V3AttestationResponseObject): Hex;
+/**
+ * Extracts the Reclaim attestor address from the attestation proofInput.
+ * This is needed for the verificationData field in fulfillIntent.
+ *
+ * @param attestation - The V3AttestationResponseObject from the attestation service
+ * @returns The Reclaim attestor address as Hex, or null if not found
+ */
+export declare function extractReclaimAttestorAddress(attestation: V3AttestationResponseObject): Hex | null;
+/**
+ * Extracts the nullifier from a V3 attestation response.
+ *
+ * The nullifier is NOT directly stored in `encodedPaymentDetails`. Instead, it's derived
+ * from `paymentMethod` and `paymentId` using:
+ * `keccak256(abi.encodePacked(paymentMethod, paymentId))`
+ *
+ * The `encodedPaymentDetails` contains a tuple of `(PaymentDetails, IntentSnapshot)`.
+ * This function decodes the PaymentDetails struct to extract paymentMethod and paymentId,
+ * then derives the nullifier.
+ *
+ * @param attestation - The V3AttestationResponseObject from the attestation service
+ * @returns The derived nullifier as Hex, or null if extraction fails
+ */
+export declare function extractNullifier(attestation: V3AttestationResponseObject): Hex | null;
+/** @alias V3AttestationOptions */
+export type AttestationOptions = V3AttestationOptions;
+/** @alias V3AttestationRequest */
+export type AttestationRequest = V3AttestationRequest;
+/** @alias V3AttestationResponse */
+export type AttestationResponse = V3AttestationResponse;
+/** @alias V3AttestationResponseObject */
+export type AttestationResponseObject = V3AttestationResponseObject;
+/** @alias V3PaymentAttestation - @deprecated use V3AttestationResponseObject */
+export type PaymentAttestation = V3PaymentAttestation;
+/** @alias V3IntentData */
+export type IntentData = V3IntentData;