TypeScript / JavaScript SDK

npm install @wirexapp/wpay-baas-sdk viem

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

const sdk = await createSDK({
  env: 'dev',  // 'dev' | 'prod'
  companyId: '0x...', // Company ID in hex format
  chainId: 8453, // optional, defaults to the remote config's defaultChain
  getMainWalletClient: () => mainWalletClient, // Embedded wallet with EthereumProvider
  enableLogging: true, // optional, default false
  logger: customLogger, // optional, custom logger
});

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',
  userWallet: userEoaWallet,
  country: 'FR',
  initialData, // see Step 6 below
});

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

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

console.log('Policy installed:', isPolicyInstalled);
console.log('Executor installed:', isExecutorInstalled);

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

if (!isPolicyInstalled && !isExecutorInstalled) {
  const receipt = await sdk.crypto.onboarding.allInOneStepOnboarding();
  console.log('Transaction hash:', receipt.receipt.transactionHash);
} else {
  // fall back to the per-step calls below
}

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: message,
});

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

const receipt = await sdk.crypto.accountContract.registerInAccounts();
const isRegistered = await sdk.crypto.accountContract.isWalletInAccounts();
console.log('Registered in contract:', isRegistered);

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

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

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

// The API sees the wallet a few seconds after step 5, once its indexer has picked up the
// Accounts registration. Until then this returns 400 ErrorNotFound — wait and call again.
const userResponse = await sdk.auth.registerUser({
  authorizationToken: 'your-jwt-token',
  userWallet: userEoaAddress, // the user's EOA, sent as wallet_address
  country: 'FR',              // required by the type, not sent on this path
  initialData: {              // required for companies on the Full verification model
    profile: {
      first_name: 'Alex',
      last_name: 'Grey',
      date_of_birth: '1990-01-15',
      nationality: 'FR',
      phone_number: '+33612345678',
      email: '[email protected]',
    },
    residence_address: {
      line1: '10 Rue de Rivoli',
      city: 'Paris',
      post_code: '75001',
      country: 'FR',
    },
  },
});

const authResponse = await sdk.auth.login({
  privy: {
    accessToken: accessToken,
    identityToken: identityToken,
  },
});
console.log('Access token:', authResponse.access_token);

const authResponse = await sdk.auth.login({
  authorizationToken: 'your-jwt-token',
  userWallet: userEoaAddress, // sent as X-User-Wallet on every later call
});

// Option 1: Privy authentication
{
  privy: {
    accessToken: string;   // Privy access token
    identityToken: string; // Privy identity token
  }
}

// Option 2: JWT authentication
{
  authorizationToken: string; // Your JWT token
}

interface RegisterCompanyParams {
  privy?: PrivyAuth;
  authorizationToken?: string;
  companyAddress: string;
  companyName: string;
  registrationCountry: string;
  registrationNumber: string;
}

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

interface BatchTransferParams {
  tokenAddress: `0x${string}`;
  responses: BatchTransferResponse[];
}

interface BatchTransferResponse {
  transaction_id: string; // GUID
  operation_id: string;   // GUID
  crypto_transfers: {
    address: string;
    precise_amount: string; // amount in the token's smallest unit
  }[];
}

// Used by makeTransferWithoutDelayPolicy (FX swap payment leg)
interface SwapTransferParams {
  tokenAddress: `0x${string}`;     // wrapped synthetic token to unwrap and send (e.g. WUSD)
  recipientAddress: `0x${string}`; // FX deposit address returned by swap.estimate
  amount: string;                  // amount of the source token (decimal string)
}

interface IYieldData {
  apy: number;                 // annual rate in percent
  currentPendingYield: string; // accumulated yield pending withdrawal
  weeklyYield: string;         // weekly yield
  lifeTimeYield: string;       // claimed + pending
}

type SwapEstimateRequest = {
  source_asset_address: string;      // token to swap from (e.g. USDC)
  destination_asset_address: string; // token to receive (e.g. EURC)
  correlation_id?: string;
} & (
  | { source_asset_amount: string; destination_asset_amount?: never }
  | { destination_asset_amount: string; source_asset_amount?: never }
);

interface SwapEstimateResponse {
  estimation_id: string;
  destination_address: string;       // send source tokens here (preferred)
  deposit_address: string;           // @deprecated — mirrors destination_address
  source_asset_address: string;
  source_asset_amount: string;
  destination_asset_address: string;
  destination_asset_amount: string;
  trade_rate: string;
  expiration_time: string;           // RFC3339, estimation expiry
}

interface SwapExecuteRequest {
  estimation_id: string;
  payment_transaction_hash: string;  // hash of the on-chain payment
}

interface SwapExecuteResponse {
  trade_id: string;
}

// 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' }

const finalTxHash = await sdk.crypto.transfer.makeErc20TransferFull({
  tokenAddress: '0x...', // synthetic token, e.g. WUSD
  recipientAddress: '0x...',
  amount: 100,
});

console.log('Final tx:', finalTxHash);

const result = await sdk.crypto.transfer.makeFullErc20Transfer({
  tokenAddress: '0x...', // synthetic token, e.g. WUSD
  recipientAddress: '0x...',
  amount: 100,
});

console.log('First part tx:', result.firstPartTxHash);
console.log('Final tx:', result.finalTxHash);
console.log('Success:', result.success);

// Step 1: Initiate transfer
const txHash = await sdk.crypto.transfer.makeErc20TransferFirstPart({
  tokenAddress: '0x...', // synthetic token, e.g. WUSD
  recipientAddress: '0x...',
  amount: 100,
});

// Step 2: Get withdrawal requests
const withdrawals = await sdk.api.withdrawal.getWithdrawalRequests();
const withdrawal = withdrawals.find(w => w.to_address === recipientAddress && w.amount === 100);

// Step 3: Complete transfer (after valid_after time)
await sdk.crypto.transfer.makeErc20TransferFinal(withdrawal.call_data);

const txHashes = await sdk.crypto.transfer.batchTransfer({
  tokenAddress: '0x...', // token to send
  responses: [
    {
      transaction_id: '6f1c2a4e-8b3d-4f5a-9c7e-1d2b3c4d5e6f',
      operation_id: '7a2d3b5f-9c4e-4a6b-8d1f-2e3c4d5e6f7a',
      crypto_transfers: [
        { address: '0x...', precise_amount: '100000000' },
        { address: '0x...', precise_amount: '50000000' },
      ],
    },
  ],
});

// Step 1: estimate — issues a deposit address and locks a rate
const estimate = await sdk.api.baas.swap.estimate({
  source_asset_address: '0x...',      // e.g. USDC
  destination_asset_address: '0x...', // e.g. EURC
  source_asset_amount: '100',
});

// Step 2: on-chain payment to the deposit address (unwraps the synthetic, no delay policy)
const paymentTransactionHash = await sdk.crypto.transfer.makeTransferWithoutDelayPolicy({
  tokenAddress: '0x...', // wrapped synthetic of the source asset, e.g. WUSD
  recipientAddress: estimate.destination_address,
  amount: estimate.source_asset_amount,
});

// Step 3: execute — settles the swap
const { trade_id } = await sdk.api.baas.swap.execute({
  estimation_id: estimate.estimation_id,
  payment_transaction_hash: paymentTransactionHash,
});

const yieldData = await sdk.crypto.yield.fetchYieldData();
console.log('APY:', yieldData.apy);
console.log('Pending yield:', yieldData.currentPendingYield);
await sdk.crypto.yield.withdraw();

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

addresses.forEach(addr => {
  console.log(`Chain: ${addr.depositChain}`);
  console.log(`Address: ${addr.depositAddress}`);
  console.log(`Tokens: ${addr.supportedTokens.join(', ')}`);
});

import type {
  SDKConfig,
  SDKEnvironment,
  Logger,
  TokenInfo,
  ContractAddresses,
  Hex,
  TransactionHash,
  MainWalletClient,
  PrivyAuth,
  LoginUserParams,
  LoginCompanyParams,
  RegisterUserParams,
  RegisterCompanyParams,
  AuthResponse,
  RegisterUserResponse,
} from '@wirexapp/wpay-baas-sdk';

import { SDKError, AuthenticationError } from '@wirexapp/wpay-baas-sdk';

try {
  await sdk.auth.login({ authorizationToken: 'token' });
} catch (error) {
  if (error instanceof AuthenticationError) {
    // handle auth error
  }
}