SDK Reference

npm install @veridex/sdk ethers

import { createSDK } from '@veridex/sdk';
 
const sdk = createSDK('base', {
  network: 'testnet',
  relayerUrl: 'https://relayer.veridex.network',
});

interface SimpleSDKConfig {
  network?: 'testnet' | 'mainnet';
  rpcUrl?: string;
  relayerUrl?: string;
  relayerApiKey?: string;
  sponsorPrivateKey?: string;
  integratorSponsorKey?: string;
  rpcUrls?: Record<ChainName, string>;
}

import { createHubSDK, createTestnetSDK, createMainnetSDK, createSessionSDK } from '@veridex/sdk';
 
const hubSdk  = createHubSDK();                 // Base hub chain
const testSdk = createTestnetSDK('optimism');    // Force testnet
const mainSdk = createMainnetSDK('base');        // Force mainnet
const sessSdk = createSessionSDK('base');        // Session-optimized

import { VeridexSDK, EVMClient } from '@veridex/sdk';
 
const evmClient = new EVMClient({
  chainId: 84532,
  wormholeChainId: 10004,
  rpcUrl: 'https://sepolia.base.org',
  hubContractAddress: '0x66D87dE68327f48A099c5B9bE97020Feab9a7c82',
  wormholeCoreBridge: '0x79A1027a6A159502049F10906D333EC57E95F083',
  name: 'Base Sepolia',
  explorerUrl: 'https://sepolia.basescan.org',
  vaultFactory: '0xCFaEb5652aa2Ee60b2229dC8895B4159749C7e53',
  vaultImplementation: '0x0d13367C16c6f0B24eD275CC67C7D9f42878285c',
});
 
const sdk = new VeridexSDK({
  chain: evmClient,
  testnet: true,
  relayerUrl: '/api/relayer',
  relayerApiKey: process.env.NEXT_PUBLIC_RELAYER_API_KEY,
  sponsorPrivateKey: process.env.NEXT_PUBLIC_VERIDEX_SPONSOR_KEY,
  chainRpcUrls: {
    10004: 'https://sepolia.base.org',
    10005: 'https://sepolia.optimism.io',
    10003: 'https://sepolia-rollup.arbitrum.io/rpc',
  },
});

let sdkInstance: VeridexSDK | null = null;
 
export async function getVeridexSDK() {
  if (!sdkInstance) {
    const { createSDK } = await import('@veridex/sdk');
    sdkInstance = createSDK('base', {
      network: 'testnet',
      relayerUrl: process.env.NEXT_PUBLIC_RELAYER_URL,
    });
  }
  return sdkInstance;
}

const credential = await sdk.passkey.register('alice', 'Alice Doe');

const { credential, signature } = await sdk.passkey.authenticate();

const credential = sdk.passkey.getCredential(); // PasskeyCredential | null

sdk.passkey.setCredential(credential);

const credentials = sdk.passkey.getAllStoredCredentials(); // PasskeyCredential[]

const signature = await sdk.passkey.sign(challenge); // WebAuthnSignature

sdk.passkey.saveToLocalStorage();
const credential = sdk.passkey.loadFromLocalStorage();
const hasStored = sdk.passkey.hasStoredCredential();

await sdk.passkey.saveCredentialToRelayer();
const credential = await sdk.passkey.loadCredentialFromRelayer();

sdk.setCredential(credential);    // Set active credential
sdk.clearCredential();             // Clear active credential
const cred = sdk.getCredential(); // Get active credential
const has = sdk.hasCredential();  // Check if credential is set

const address = sdk.getVaultAddress(); // string

const exists = await sdk.vaultExists(); // boolean

const info = await sdk.getVaultInfo(targetChainId?); // VaultInfo | null

const identity = await sdk.getUnifiedIdentity();
for (const addr of identity.addresses) {
  console.log(`${addr.chainName}: ${addr.address} (deployed: ${addr.deployed})`);
}

const addresses = sdk.getMultiChainAddresses();
// { 10004: '0x...', 10005: '0x...', 10003: '0x...' }

const portfolios = await sdk.getMultiChainPortfolio([10004, 10005]);
for (const p of portfolios) {
  console.log(`${p.chainName}: $${p.totalUsdValue}`);
}

const config = sdk.getChainConfig(); // ChainConfig

const addr = sdk.getReceiveAddress(); // ReceiveAddress

const nonce = await sdk.getNonce(); // bigint

if (sdk.supportsFeature('sessions')) {
  // Sessions are available
}
if (sdk.supportsFeature('crossChainBridge')) {
  // Bridging is available
}

const matrix = sdk.getCapabilityMatrix({
  webauthnSupported: true,
  conditionalUISupported: true,
  platformAuthenticatorAvailable: true,
});

const prepared = await sdk.prepareTransfer({
  targetChain: 10004,
  token: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
  recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f5A234',
  amount: 1_000_000n, // 1 USDC
});
 
console.log('Gas cost:', prepared.formattedCost);
console.log('Expires:', new Date(prepared.expiresAt));

const result = await sdk.executeTransfer(prepared, signer);
console.log('Tx:', result.transactionHash);

import { ethers } from 'ethers';
 
const result = await sdk.transferViaRelayer({
  targetChain: 10004,
  token: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
  recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f5A234',
  amount: ethers.parseUnits('10', 6),
});

const result = await sdk.transferWithTracking(params, signer, (status) => {
  console.log(status.state); // 'pending' → 'confirmed'
});

const summary = await sdk.getTransactionSummary(prepared);
console.log(summary.title);       // "Transfer"
console.log(summary.description); // "Send 1.0 USDC to 0x742d...5A234"
console.log(summary.risks);       // [{level:'warning', message:'Large transaction'}]

const prepared = await sdk.prepareBridge({
  sourceChain: 10004,
  destinationChain: 10005,
  token: '0x...',
  recipient: '0x...',
  amount: 1_000_000n,
});

const result = await sdk.executeBridge(prepared, signer, (progress) => {
  console.log(`Step ${progress.step}/${progress.totalSteps}: ${progress.message}`);
});

const result = await sdk.bridgeViaRelayer(params, onProgress?);

const fees = await sdk.getBridgeFees(params);
console.log('Total:', fees.formattedTotal); // "0.0012 ETH"

const limits = await sdk.getSpendingLimits(chainId?);
console.log('Daily remaining:', limits.dailyRemaining);

const formatted = await sdk.getFormattedSpendingLimits();
console.log(`${formatted.dailyUsedPercentage}% used`);
console.log(`Resets in: ${formatted.timeUntilReset}`);
console.log(`Per-tx limit: ${formatted.transactionLimit}`);

const check = await sdk.checkSpendingLimit(ethers.parseEther('1.0'));
if (!check.allowed) {
  console.log(check.message);
  console.log('Suggestions:', check.suggestions);
}

const prepared = await sdk.prepareSetDailyLimit(ethers.parseEther('5.0'));
await sdk.executeTransfer(prepared, signer);

const pause = await sdk.preparePauseVault();
const unpause = await sdk.prepareUnpauseVault();

const unsub = sdk.watchBalance(
  (event) => {
    for (const change of event.changes) {
      console.log(`${change.token.symbol}: ${change.delta > 0n ? '+' : ''}${change.delta}`);
    }
  },
  { intervalMs: 10_000, emitInitial: true },
  (error) => console.error('Watch error:', error),
);
 
// Later: stop watching
unsub();

const portfolio = await sdk.getVaultBalances();
for (const entry of portfolio.tokens) {
  console.log(`${entry.token.symbol}: ${entry.formatted}`);
}

const native = await sdk.getVaultNativeBalance();
console.log(`${native.token.symbol}: ${native.formatted}`);

const balance = await sdk.getVaultTokenBalance(tokenAddress);

const results = await sdk.getMultiChainBalances([10004, 10005, 10003]);

const canSponsor = sdk.isSponsorshipAvailable(); // boolean

const result = await sdk.ensureSponsoredVaultsOnAllChains();
console.log(`Created on ${result.results.filter(r => r.success).length} chains`);

const result = await sdk.createSponsoredVault(10004); // Base Sepolia

const chains = sdk.getSponsoredChains();

const newCred = await sdk.passkey.register('alice-backup', 'Alice Backup');
const result = await sdk.addBackupPasskey(newCred, signer);

const keys = await sdk.listAuthorizedPasskeys();

const hasBackup = await sdk.hasBackupPasskeys(); // boolean

await sdk.removePasskey(keyHash, signer);

// Configure policy
await sdk.multisig.configurePolicy({
  signature, threshold: 2, signer,
});
 
// Create proposal
const proposal = await sdk.multisig.proposeTransfer(params, signer);
 
// Approve
const approval = await sdk.multisig.approveProposal(proposal.proposalId, signer);
 
// Execute (once threshold reached)
if (approval.thresholdReached) {
  const result = await sdk.multisig.executeProposal(proposal.proposalId, signer);
}

import { EnterpriseManager } from '@veridex/sdk';
 
const enterprise = new EnterpriseManager({ sdk, maxConcurrency: 5 });

const result = await enterprise.batchCreateVaults(
  { keyHashes: ['0xabc...', '0xdef...'], maxConcurrency: 3 },
  (event) => console.log(event.type, event),
);
console.log(`${result.succeeded}/${result.total} vaults created`);

const result = await enterprise.batchTransfer({
  transfers: [
    { targetChain: 10004, token: USDC, recipient: '0xAlice', amount: 1_000_000n },
    { targetChain: 10004, token: USDC, recipient: '0xBob', amount: 2_000_000n },
  ],
  signer,
  maxConcurrency: 2,
});

const result = await enterprise.batchSetSpendingLimits({
  updates: [
    { newLimit: ethers.parseEther('5.0') },
    { newLimit: ethers.parseEther('10.0') },
  ],
  signer,
});

const unsub = enterprise.watchVaultBalance(10004, vaultAddress, (event) => {
  callWebhook(event);
});

const limits = await enterprise.getSpendingLimitsForVault('0xVault...', 10004);

import { VeridexError, VeridexErrorCode, normalizeError } from '@veridex/sdk';
 
try {
  await sdk.transferViaRelayer(params);
} catch (err) {
  if (err instanceof VeridexError) {
    switch (err.code) {
      case VeridexErrorCode.INSUFFICIENT_FUNDS:
        showToast('Not enough tokens');
        break;
      case VeridexErrorCode.DAILY_LIMIT_EXCEEDED:
        showToast('Daily limit reached');
        break;
      default:
        if (err.retryable) { /* retry */ }
    }
  }
}

const tokens = sdk.getTokenList();
const usdc = sdk.getTokenBySymbol('USDC');

import {
  NATIVE_TOKEN_ADDRESS,
  BASE_SEPOLIA_TOKENS,
  TOKEN_REGISTRY,
  getTokenList,
  getTokenBySymbol,
  getTokenByAddress,
  isNativeToken,
} from '@veridex/sdk';

import {
  getChainConfig,
  getSupportedChains,
  getHubChains,
  isChainSupported,
  getDefaultHub,
  CHAIN_PRESETS,
  CHAIN_NAMES,
} from '@veridex/sdk';
 
const chains = getSupportedChains('testnet');
const config = getChainConfig('stacks', 'testnet');

import {
  EVMClient,
  SolanaClient,
  AptosClient,
  SuiClient,
  StarknetClient,
  StacksClient,
} from '@veridex/sdk';

import {
  SessionManager,
  generateSecp256k1KeyPair,
  computeSessionKeyHash,
  signWithSessionKey,
  hashAction,
  verifySessionSignature,
  deriveEncryptionKey,
  encrypt,
  decrypt,
  createSessionStorage,
} from '@veridex/sdk';

import {
  getERC8004Addresses,
  isERC8004Chain,
  ERC8004_CHAINS,
  IDENTITY_REGISTRY_ABI,
  REPUTATION_REGISTRY_ABI,
} from '@veridex/sdk';
 
const addresses = getERC8004Addresses('mainnet');
const supported = isERC8004Chain('base'); // true

sdk.transactions.track(txHash, chainId, (state) => {
  console.log(state); // 'pending' | 'confirmed' | 'failed'
}, sequence);
 
const state = await sdk.waitForTransaction(txHash);

import { createEnterpriseSDK } from '@veridex/sdk';
 
const sdk = createEnterpriseSDK(chain, {
  network: 'mainnet',
  multisig: { threshold: number, signers: Signer[] },
  recovery: { guardians: string[], delay: number },
});

import { createHubSDK } from '@veridex/sdk';
 
const sdk = createHubSDK(chain, { network: 'testnet' });

import { createSessionSDK } from '@veridex/sdk';
 
const sdk = createSessionSDK(chain, {
  network: 'testnet',
  sessionKeyHash: '0x...',
});

const multisig = sdk.multisig;
 
await multisig.propose({ to, value, data });   // Propose transaction
await multisig.approve(proposalId);             // Approve as signer
await multisig.execute(proposalId);             // Execute (threshold met)
await multisig.getProposal(proposalId);         // Get proposal details
await multisig.listPending();                   // List pending proposals

const recovery = sdk.recovery;
 
await recovery.initiateRecovery(newOwner);       // Start recovery
await recovery.attestAsGuardian(requestId, signer); // Guardian attestation
await recovery.executeRecovery(requestId);        // Execute after delay
await recovery.cancelRecovery(requestId);         // Cancel (by current owner)
await recovery.getRecoveryStatus(requestId);      // Check status

import { createCrossOriginAuth } from '@veridex/sdk';
 
const auth = createCrossOriginAuth({
  rpId: 'veridex.network',              // default
  authPortalUrl: 'https://auth.veridex.network', // default
  relayerUrl: 'https://relayer.veridex.network/api/v1', // default
  mode: 'popup',                         // 'popup' | 'redirect'
  redirectUri: 'https://myapp.com/callback', // only for redirect mode
  timeout: 120000,                       // 2 minutes default
});

const rorSupported = await auth.supportsRelatedOrigins(); // boolean

const { credential, signature } = await auth.authenticate();
console.log('Key hash:', credential.keyHash);
console.log('Vault:', '0x' + credential.keyHash.slice(-40));

const session = await auth.connectWithVeridex();
console.log('Address:', session.address);
console.log('Credential:', session.credential.keyHash);

const { session, serverSession } = await auth.authenticateAndCreateSession({
  permissions: ['read', 'transfer'],
  expiresInMs: 3600000, // 1 hour
});
 
console.log('Vault address:', session.address);
console.log('Server session ID:', serverSession.id);
console.log('Expires at:', new Date(serverSession.expiresAt));
 
// Store for subsequent API calls
localStorage.setItem('veridex_session_id', serverSession.id);

const serverSession = await auth.createServerSession(session);

const valid = await auth.validateServerSession('ses_abc123');
if (valid) {
  console.log('Session valid, expires:', new Date(valid.expiresAt));
}

await auth.revokeServerSession('ses_abc123');

const session = auth.completeRedirectAuth(); // CrossOriginSession | null

import { WalletBackupManager } from '@veridex/sdk';
 
const backup = new WalletBackupManager({
  passkey: sdk.passkey,
  relayerUrl: 'https://relayer.veridex.network/api/v1',
});

const result = await backup.backupCredentials(keyHash);
console.log('Archive ID:', result.archiveId);
console.log('Backed up:', result.credentialCount, 'credentials');

const recovered = await backup.recoverCredentials(keyHash);
console.log('Recovered:', recovered.credentials.length, 'credentials');
// Credentials are automatically saved to localStorage

const status = await backup.getBackupStatus(keyHash);
console.log('Has archive:', status.hasArchive);
console.log('PRF supported:', status.prfSupported);
console.log('Guardians:', status.guardianCount);

const support = await WalletBackupManager.checkPlatformSupport();
console.log('WebAuthn:', support.webauthnSupported);
console.log('PRF:', support.prfSupported);
 
if (!support.prfSupported) {
  showWarning('Your device uses weaker backup encryption');
}

import { InjectedWalletAdapter } from '@veridex/sdk';
 
const adapter = new InjectedWalletAdapter();
const session = await adapter.createSessionFromInjected(sessionConfig);