TypeScript / JavaScript SDK

import { createSDK, type WirexPaySDK } from '@wirexapp/wpay-baas-sdk';

const sdk: WirexPaySDK = await createSDK({
  env: 'dev',                        // 'dev' → sandbox  |  'prod' → production
  companyId: process.env.COMPANY_ID, // hex company ID from Wirex onboarding
  getMainWalletClient: () => mainWalletClient,
  rhinoApiKey: process.env.RHINO_API_KEY, // optional, enables Smart Deposit Addresses
  enableLogging: false,              // optional
  logger: customLogger,              // optional, requires enableLogging: true
});

interface MainWalletClient {
  address: string;
  getEthereumProvider(): Promise<{
    request(args: { method: string; params?: unknown[] }): Promise<unknown>;
  }>;
}

import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { baseSepolia } from 'viem/chains';
import type { MainWalletClient } from '@wirexapp/wpay-baas-sdk';

export function createWalletClientFromKey(
  privateKey: `0x${string}`,
  rpcUrl: string,
): MainWalletClient {
  const account = privateKeyToAccount(privateKey);
  const client = createWalletClient({ account, chain: baseSepolia, transport: http(rpcUrl) });

  return {
    address: account.address,
    getEthereumProvider: async () => ({
      request: async ({ method, params = [] }) => {
        if (method === 'eth_accounts') return [account.address];
        if (method === 'personal_sign') {
          const [data] = params as [`0x${string}`, string];
          return client.signMessage({ account, message: { raw: data } });
        }
        if (method === 'eth_signTypedData_v4') {
          const [, json] = params as [string, string];
          const { domain, types, primaryType, message } = JSON.parse(json);
          const { EIP712Domain: _, ...filteredTypes } = types;
          return client.signTypedData({ account, domain, types: filteredTypes, primaryType, message });
        }
        return (client.transport as any).request({ method, params });
      },
    }),
  };
}

import type { MainWalletClient } from '@wirexapp/wpay-baas-sdk';

// Inside a React component / hook where usePrivy is available:
function getPrivyWalletClient(wallet: ConnectedWallet): MainWalletClient {
  return {
    address: wallet.address,
    getEthereumProvider: () => wallet.getEthereumProvider(),
  };
}

// Step 1 — Exchange company credentials
const tokenRes = await sdk.api.baas.token.getToken({
  grant_type: 'client_credentials',
  client_id:  process.env.CLIENT_ID,
  client_secret: process.env.CLIENT_SECRET,
  audience: 'https://api-business.wirexpaychain.tech', // same for dev and prod
});

// Step 2 — Prime SDK auth state with the company token + user EOA wallet
sdk.auth.setAuthState(
  { access_token: tokenRes.access_token, expires_at: tokenRes.expires_at },
  userEoaWallet,
);

// Step 3 — (After user registration) Login to get a per-user PSI token.
// All sdk.api.baas.* calls automatically use the PSI token after this.
await sdk.auth.login({
  authorizationToken: tokenRes.access_token,
  userWallet: userEoaWallet,
});

console.log('Authenticated:', sdk.auth.isAuthenticated()); // true
console.log('Token:', sdk.auth.getAccessToken());

import { getAccessToken, useIdentityToken } from '@privy-io/react-auth';

const accessToken  = await getAccessToken();
const { identityToken } = useIdentityToken();

// Login (existing user)
const authResponse = await sdk.auth.login({
  privy: { accessToken, identityToken },
});

// Or register (new user)
const userResponse = await sdk.auth.registerUser({
  privy: { accessToken, identityToken },
  country: 'FR',
});

// Login
const authResponse = await sdk.auth.login({
  authorizationToken: 'your-jwt-token',
  userWallet: userEoaWallet,
});

// Register
const userResponse = await sdk.auth.registerUser({
  authorizationToken: 'your-jwt-token',
  country: 'FR',
});

const smartWalletAddress = await sdk.crypto.wallet.getSmartWalletAddress();
console.log('Smart Wallet:', smartWalletAddress);

const isPolicyInstalled   = await sdk.crypto.accountAbstraction.isPolicyInstalled();
const isExecutorInstalled = await sdk.crypto.accountAbstraction.isExecutorInstalled();

if (!isPolicyInstalled || !isExecutorInstalled) {
  const result = await sdk.crypto.accountAbstraction.signInPolicyAndExecutor();
  console.log('TX hash:', result?.receipt?.transactionHash);
}

await sdk.crypto.accountAbstraction.signInPolicy();   // ExecutionDelayPolicy only
await sdk.crypto.accountAbstraction.signInExecutor(); // FundsManagementExecutor only

import { useLinkWithSiwe } from '@privy-io/react-auth';

const { generateSiweMessage, linkWithSiwe } = useLinkWithSiwe();
const smartWalletClient = await sdk.crypto.wallet.getSmartWalletClient();

const message = await generateSiweMessage({
  address: smartWalletClient.account.address,
  chainId: 'eip155:' + smartWalletClient.chain?.id,
});

const signature = await smartWalletClient.signMessage({
  account: smartWalletClient.account,
  message,
});

await linkWithSiwe({
  message,
  chainId: 'eip155:' + smartWalletClient.chain?.id,
  signature,
  walletClientType: 'smart_wallet',
  connectorType: 'kernel',
});

const isRegistered = await sdk.crypto.accountContract.isWalletInAccounts();

if (!isRegistered) {
  await sdk.crypto.accountContract.registerInAccounts();
}

await sdk.crypto.accountContract.registerInCorporateAccounts();

// Option A — Privy
const user = await sdk.auth.registerUser({
  privy: { accessToken, identityToken },
  country: 'FR',
});

// Option B — JWT / OAuth2
const user = await sdk.auth.registerUser({
  authorizationToken: companyToken,
  country: 'FR',
});

console.log('User ID:', user.id);

await sdk.auth.registerCompany({
  authorizationToken: companyToken,
  companyAddress: '0x...',
  companyName: 'Acme Corp',
  registrationCountry: 'GB',
  registrationNumber: '12345678',
});

// Option A — Privy
const auth = await sdk.auth.login({
  privy: { accessToken, identityToken },
});

// Option B — JWT / OAuth2
const auth = await sdk.auth.login({
  authorizationToken: companyToken,
  userWallet: userEoaAddress,
});

console.log('Access token:', auth.access_token);
// All subsequent sdk.api.baas.* calls now use this token automatically.

const tokenRes = await sdk.api.baas.token.getToken({
  grant_type: 'client_credentials',
  client_id: process.env.CLIENT_ID,
  client_secret: process.env.CLIENT_SECRET,
  audience: 'https://api-business.wirexpaychain.tech',
});
// → { access_token, token_type: 'Bearer', expires_at }

// Check user capabilities (e.g. card issuance eligibility)
const user = await sdk.api.baas.user.getUserV2();
const caps = user.capabilities;
const canIssueVirtualCard = caps.find(c => c.type === 'VisaVirtualCard')?.status === 'Active';

const wallet = await sdk.api.baas.wallet.getWallet();
// Response: { balances: [{ token_symbol, token_address, balance }] }
const balances = wallet.balances;

// 1. Request SMS OTP
const session = await sdk.api.baas.confirmation.requestSms({
  action_type: 'GetCardDetails',
});

// 2. Verify OTP → receive action token (UAT code is '000000')
const tokenRes = await sdk.api.baas.confirmation.verifySms({
  session_id: session.session_id,
  code: userInputCode,
});
const actionToken = tokenRes.token;

// 3. Use action token to retrieve sensitive data
const details = await sdk.api.baas.cards.getCardDetails(cardId, { action_token: actionToken });
// → { card_number: '4111111111111111', expiry_date: '12/2028' }

const cvv = await sdk.api.baas.cards.getCardCvv(cardId, { action_token: actionToken });
// → { cvv: '123' }

// Estimate a SEPA transfer
const estimate = await sdk.api.baas.bank.estimateCorridorTransferV2('SEPA', {
  destination_amount: 100,
  recipient_id: recipientId,
  recipient_payment_details_id: paymentDetailsId,
  account_id: eurAccountId,
});
// → { estimation_id, fee, ... }

// Create recipient with SEPA payment details
const recipient = await sdk.api.baas.recipients.createRecipient({
  first_name: 'John',
  last_name: 'Doe',
  is_business: false,
});

await sdk.api.baas.recipients.createRecipientPaymentDetails(recipient.id, {
  type: 'Sepa',
  currencies: ['EUR'],
  sepa: {
    iban: 'DE89370400440532013000',
    bic: 'COBADEFFXXX',
  },
});

// Paginated feed
const feed = await sdk.api.baas.activity.getFeed({ page_number: 0, page_size: 20 });

// Statement for the last 30 days
const statement = await sdk.api.baas.activity.getFullStatement({
  start: Math.floor((Date.now() - 30 * 24 * 60 * 60 * 1000) / 1000),
  end:   Math.floor(Date.now() / 1000),
});

interface Erc20TransferParams {
  tokenAddress:    `0x${string}`;
  recipientAddress:`0x${string}`;
  amount:          number;
}

interface BatchTransferItem {
  to:     `0x${string}`;
  amount: string;
  token:  string;   // e.g. 'USDC'
  guid:   string;   // unique transfer identifier for deduplication
}

interface YieldData {
  tokenSymbol:   string; // yield token symbol
  apy:           string; // annual percentage yield
  currentYield:  string; // accumulated yield pending withdrawal
  weeklyYield:   string; // yield earned this week
  lifetimeYield: string; // total yield since account creation
}

const result = await sdk.crypto.transfer.makeFullErc20Transfer({
  tokenAddress:     '0x920D17f7A226Ce306f2B51F74a0f0dA89C3b8dF3',
  recipientAddress: '0xRecipientAddress',
  amount: 100,
});

console.log('Phase 1 tx:', result.firstPartTxHash);
console.log('Phase 2 tx:', result.finalTxHash);
console.log('Success:   ', result.success);

// Phase 1 — submit request
await sdk.crypto.transfer.makeErc20TransferFirstPart({
  tokenAddress:     '0x920D17f7A226Ce306f2B51F74a0f0dA89C3b8dF3',
  recipientAddress: '0xRecipientAddress',
  amount: 100,
});

// Fetch pending requests to get call_data
const withdrawals = await sdk.api.withdrawal.getWithdrawalRequests();
const pending = withdrawals.find(w => w.status === 'Requested');

// Phase 2 — execute after valid_after timestamp
await sdk.crypto.transfer.makeErc20TransferFinal(pending.call_data);

await sdk.crypto.transfer.batchTransfer({
  items: [
    { to: '0xAddress1', amount: '100', token: 'USDC', guid: 'transfer-001' },
    { to: '0xAddress2', amount: '50',  token: 'USDC', guid: 'transfer-002' },
  ],
});

const data = await sdk.crypto.yield.fetchYieldData();
console.log('APY:    ', data.apy);
console.log('Earned: ', data.currentYield);

await sdk.crypto.yield.withdraw();
await sdk.crypto.yield.switchYieldToken('WEUR');

const addresses = await sdk.crypto.smartDepositAddress.initializeSmartDepositAddresses();

for (const addr of addresses) {
  console.log(`Chain:   ${addr.depositChain}`);
  console.log(`Address: ${addr.depositAddress}`);
  console.log(`Tokens:  ${addr.supportedTokens.join(', ')}`);
}

// Issue
const card = await sdk.api.baas.cards.issueVirtualCard({ card_name: 'My Card' });
const cardId = card.id;

// Block / Unblock
await sdk.api.baas.cards.blockCard(cardId);
await sdk.api.baas.cards.unblockCard(cardId);

// Get PAN (requires SMS OTP)
const session   = await sdk.api.baas.confirmation.requestSms({ action_type: 'GetCardDetails' });
const tokenRes  = await sdk.api.baas.confirmation.verifySms({ session_id: session.session_id, code: '000000' });
const details   = await sdk.api.baas.cards.getCardDetails(cardId, { action_token: tokenRes.token });
console.log('PAN:', details.card_number);

// Close
await sdk.api.baas.cards.closeCard(cardId);

import type {
  WirexPaySDK,
  SDKConfig,
  SDKEnvironment,
  MainWalletClient,
  Logger,
  // Auth
  PrivyAuth,
  LoginUserParams,
  LoginCompanyParams,
  RegisterUserParams,
  RegisterCompanyParams,
  AuthResponse,
  RegisterUserResponse,
  // Crypto
  Hex,
  TransactionHash,
  TransferRequest,
  TransferResult,
  BatchTransferItem,
  BatchTransferResult,
  YieldData,
  YieldGraphicDataPoint,
  // Wallet / contract
  TokenInfo,
  ContractAddresses,
  AccountStatus,
  PolicyStatus,
} from '@wirexapp/wpay-baas-sdk';

import {
  AuthenticationError,
  NetworkError,
  TransactionError,
  ContractError,
} from '@wirexapp/wpay-baas-sdk';

try {
  await sdk.crypto.transfer.makeFullErc20Transfer(params);
} catch (error) {
  if (error instanceof AuthenticationError) {
    // re-login
  } else if (error instanceof NetworkError) {
    console.error('HTTP', error.statusCode);
  } else if (error instanceof ContractError) {
    // execution delay not expired, or invalid calldata
  } else if (error instanceof TransactionError) {
    // UserOperation reverted on-chain
  }
}