Reference

constructor(options: PortalOptions)

import Portal, { buildDefaultRpcConfig } from '@portal-hq/web';

// Zero-config: SDK auto-generates RPC URLs for 13 built-in chains
// via the Portal-managed gateway (web.portalhq.io).
const portal = new Portal({
  apiKey: 'your-api-key',
});

// Custom subdomain: set `host` once — RPC gateway derives automatically.
const portalCustom = new Portal({
  apiKey: 'your-api-key',
  host: 'YOUR-CUSTOM-SUBDOMAIN',
});

// Extended config: start from the default 13 chains and add extras.
// Use this when your app needs chains not in the built-in set (e.g. Tron, AVAX Fuji).
const portalExtended = new Portal({
  apiKey: 'your-api-key',
  rpcConfig: {
    ...buildDefaultRpcConfig('web.portalhq.io'),
    'tron:mainnet': 'https://web.portalhq.io/rpc/v1/tron/mainnet',
  },
  gdrive: {
    clientId: 'your-client-id',
  },
});

const portal = new Portal({
  apiKey: 'your-api-key',
  featureFlags: {
    usePresignatures: true,
  },
})

public setLogLevel(level: LogLevel): void

portal.setLogLevel('debug')  // Enable verbose logging
portal.setLogLevel('none')   // Disable all SDK logs

public getLogLevel(): LogLevel

const level = portal.getLogLevel()
console.log('Current log level:', level)

public onReady(callback: () => any | Promise<any>): () => void

const unsubscribe = portal.onReady(() => {
  console.log('Portal is ready!');
});

// Later, to remove the callback:
unsubscribe();

public onInitializationError(callback: (reason: string) => any | Promise<any>): () => void

const unsubscribe = portal.onInitializationError(reason => {
  console.error('Initialization failed:', reason);
});

public onWalletNotOnDevice(
  callback: (payload: WalletNotOnDevicePayload) => any | Promise<any>,
): () => void

const unsubscribe = portal.onWalletNotOnDevice(async (payload) => {
  if (payload.isBackedUp) {
    // prompt user to recover their wallet
  } else {
    // no backup — clear state and restart onboarding
    await portal.clearLocalWallet()
  }
});

public async createWallet(progress?: ProgressCallback): Promise<string>

const address = await portal.createWallet(status => {
  console.log('Status:', status);
});

console.log('Wallet created with address:', address);

public configureFirebaseStorage(options: FirebaseStorageConfigOptions): void

import type { FirebaseStorageConfigOptions } from '@portal-hq/web/types'

import Portal, { BackupMethods } from '@portal-hq/web'
import { getAuth } from 'firebase/auth'

const portal = new Portal({
  apiKey: 'YOUR_PORTAL_CLIENT_API_KEY',
})

portal.configureFirebaseStorage({
  getToken: async (options?: { forceRefresh?: boolean }) => {
    const user = getAuth().currentUser
    if (!user) {
      return null
    }
    return user.getIdToken(Boolean(options?.forceRefresh))
  },
})

await portal.backupWallet(BackupMethods.firebase)

public async backupWallet(
  backupMethod: BackupMethods,
  progress?: ProgressCallback,
  backupConfigs?: BackupConfigs
): Promise<BackupResponse>

import { getAuth } from 'firebase/auth'

// Password backup
const passwordBackup = await portal.backupWallet(BackupMethods.password, status => console.log(status), {
  passwordStorage: { password: 'your-password' },
});
await passwordBackup.storageCallback();
console.log('Password backup cipher text:', passwordBackup.cipherText);

// Firebase backup (call configureFirebaseStorage first)
portal.configureFirebaseStorage({
  getToken: async (options?: { forceRefresh?: boolean }) => {
    const user = getAuth().currentUser
    if (!user) {
      return null
    }
    return user.getIdToken(Boolean(options?.forceRefresh))
  },
})
const firebaseBackup = await portal.backupWallet(BackupMethods.firebase, status =>
  console.log(status),
)
await firebaseBackup.storageCallback();
console.log('Firebase backup cipher text:', firebaseBackup.cipherText);

public async recoverWallet(
  cipherText: string,
  backupMethod: BackupMethods,
  backupConfigs?: BackupConfigs,
  progress?: ProgressCallback
): Promise<string>

const address = await portal.recoverWallet('your-cipher-text', BackupMethods.password, {
  passwordStorage: { password: 'your-password' },
});

console.log('Wallet recovered:', address);

public async provisionWallet(
  cipherText: string,
  backupMethod: BackupMethods,
  backupConfigs: BackupConfigs,
  progress?: ProgressCallback
): Promise<string>

public async clearLocalWallet(): Promise<boolean>

const cleared = await portal.clearLocalWallet();
console.log('Wallet cleared:', cleared);

public async doesWalletExist(chainId?: string): Promise<boolean>

// Check if any wallet exists
const exists = await portal.doesWalletExist();

// Check for specific chain
const hasEthWallet = await portal.doesWalletExist('eip155:1');

public async isWalletOnDevice(chainId?: string): Promise<boolean>

public async isWalletBackedUp(chainId?: string): Promise<boolean>

public async isWalletRecoverable(chainId?: string): Promise<boolean>

public async availableRecoveryMethods(chainId?: string): Promise<BackupMethods[]>

const methods = await portal.availableRecoveryMethods();
console.log('Available recovery methods:', methods);
// e.g., ['GDRIVE', 'PASSWORD']

public async getEip155Address(): Promise<string>

const ethAddress = await portal.getEip155Address();
console.log('Ethereum address:', ethAddress);

public async getSolanaAddress(): Promise<string>

const solAddress = await portal.getSolanaAddress();
console.log('Solana address:', solAddress);

public async getTronAddress(): Promise<string>

const tronAddress = await portal.getTronAddress();
console.log('TRON address:', tronAddress);

public async eject(
  backupMethod: BackupMethods,
  backupConfigs: BackupConfigs,
  orgBackupShare?: string,
  clientBackupCipherText?: string
): Promise<EjectResult>

public async ejectPrivateKeys(
  backupMethod: BackupMethods,
  backupConfigs: BackupConfigs,
  orgBackupShares: OrgBackupShares,
  clientBackupCipherText?: string
): Promise<EjectPrivateKeysResult>

public async request(request: RequestArguments): Promise<any>

// Send Ethereum transaction
const txHash = await portal.request({
  chainId: 'eip155:1',
  method: 'eth_sendTransaction',
  params: [
    {
      from: portal.address,
      to: '0x...',
      value: '0xDE0B6B3A7640000', // 1 ETH in wei
    },
  ],
  signatureApprovalMemo: 'Send 1 ETH', // optional
});

// Sign Solana transaction
const signature = await portal.request({
  chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
  method: 'sol_signAndSendTransaction',
  params: [transaction],
});

public async sendAsset(chain: string, params: SendAssetParams): Promise<string>

// EVM
const txHash = await portal.sendAsset('eip155:1', {
  to: '0x...',
  token: 'NATIVE', // Native ETH
  amount: '1000000000000000000', // 1 ETH in wei
});
console.log('Transaction hash:', txHash);

// TRON
const txId = await portal.sendAsset('tron:mainnet', {
  to: 'TRecipientAddress',
  token: 'NATIVE', // TRX
  amount: '1',
  signatureApprovalMemo: 'Send TRX', // optional
});
console.log('Transaction ID:', txId);

public async sendSol({
  chainId,
  to,
  lamports
}: {
  chainId: string
  to: string
  lamports: number
}): Promise<string>

const signature = await portal.sendSol({
  chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
  to: 'DYw8...',
  lamports: 1000000000, // 1 SOL
});

public sendEth = async ({
  chainId,
  to,
  value
}: {
  chainId: string
  to: string
  value: string
}): Promise<any>

const txHash = await portal.sendEth({
  chainId: 'eip155:1',
  to: '0x...',
  value: '0xDE0B6B3A7640000', // 1 ETH in wei
});

console.log('Transaction hash:', txHash);

public async rawSign(
  curve: PortalCurve,
  param: string,
  options?: RawSignOptions
): Promise<string>

import { PortalCurve } from '@portal-hq/web';

// Sign with SECP256K1 (Ethereum)
const signature = await portal.rawSign(PortalCurve.SECP256K1, 'your-data-to-sign');

// With optional approval memo (shown to user during approval)
const signatureWithMemo = await portal.rawSign(
  PortalCurve.SECP256K1,
  'your-data-to-sign',
  { signatureApprovalMemo: 'Sign login challenge' }
);

console.log('Signature:', signature);

public async sendBatchUserOp(
  data: SendBatchUserOpRequest
): Promise<BroadcastBatchedUserOpResponse>

import type { SendBatchUserOpRequest } from '@portal-hq/web'

const result = await portal.sendBatchUserOp({
  chain: 'eip155:10143',
  transactions: [
    { token: 'USDC', value: '5.00', to: '0xAlice...' },
    { token: 'USDC', value: '5.00', to: '0xBob...' },
  ],
  signatureApprovalMemo: 'Batch transfer',
})
console.log('UserOp hash:', result.data.userOpHash)

public async sendBatchedAssets(
  data: SendBatchedAssetsRequest
): Promise<BroadcastBatchedUserOpResponse>

public async buildBatchedUserOp(
  data: BuildBatchedUserOpRequest
): Promise<BuildBatchedUserOpResponse>

public async broadcastBatchedUserOp(
  data: BroadcastBatchedUserOpRequest
): Promise<BroadcastBatchedUserOpResponse>

interface ApproveDelegationRequest {
  chain: string
  token: string
  delegateAddress: string
  amount: string
}

interface RevokeDelegationRequest {
  chain: string
  token: string
  delegateAddress: string
}

interface GetDelegationStatusRequest {
  chain: string
  token: string
  delegateAddress: string
}

interface TransferFromRequest {
  chain: string
  token: string
  fromAddress: string
  toAddress: string
  amount: string
}

interface DelegationSubmitOptions {
  signAndSendTransaction?: (
    transaction: unknown,
    chainId: string
  ) => Promise<string>
  onProgress?: (event: DelegationSubmitProgress) => void
}

interface DelegationSubmitProgress {
  step: 'signing' | 'submitted'
  index: number
  total: number
  hash?: string
}

type YieldDepositParams =
  | { yieldId: string; amount: string; address?: string; arguments?: YieldXyzEnterArguments }
  | { chain: string; token: string; amount: string; address?: string; arguments?: YieldXyzEnterArguments }

type YieldWithdrawParams = YieldDepositParams

interface YieldSubmitOptions {
  onProgress?: (event: YieldSubmitProgress) => void
  signAndSendTransaction?: (transaction: unknown, network: string) => Promise<string>
  waitForConfirmation?: (txHash: string, network: string) => Promise<void | boolean>
  evmRequestFn?: (method: string, params: unknown[], network: string) => Promise<unknown>
  evmPollerOptions?: { pollIntervalMs?: number; timeoutMs?: number }
}

interface YieldSubmitProgress {
  step: 'signing' | 'submitted' | 'confirming' | 'confirmed'
  index: number
  total: number
  hash?: string
}

interface YieldDepositResult {
  hashes: string[]
  yieldId: string
  chain?: string
  token?: string
  yieldOpportunityDetails: {
    yieldId: string
    intent?: string
    type?: string
    executionPattern?: string
    status?: string
    amount?: string | null
    amountUsd?: string | null
  }
}

interface YieldWithdrawResult {
  hashes: string[]
  yieldId: string
  chain?: string
  token?: string
  yieldOpportunityDetails: {
    yieldId: string
    intent?: string
    type?: string
    executionPattern?: string
    status?: string
    amount?: string | null
    amountUsd?: string | null
  }
}

interface YieldXyzValidator {
  address: string
  name?: string
  commission?: string
  apy?: string
  [key: string]: unknown
}

public async getClient(): Promise<ClientResponse>

const client = await portal.getClient();
console.log('Client ID:', client.id);
console.log('Wallets:', client.wallets);

public async getAssets(chainId: string, includeNfts?: boolean): Promise<GetAssetsResponse>

const assets = await portal.getAssets('eip155:1', false);
console.log('Assets:', assets);

public async getNFTAssets(chainId: string): Promise<NFTAsset[]>

const nfts = await portal.getNFTAssets('eip155:1');
console.log('NFT assets:', nfts);

public async getTransactionHistory(
  params: GetTransactionHistoryParams
): Promise<GetTransactionHistoryResponse>

{
  data: {
    transactions: SolanaTransactionDetails[]
  },
  metadata: {
    address: string
    chainId: string
    clientId: string
    limit: number
    offset: number
    count: number
  }
}

{
  data: {
    transactions: TransactionHistoryItem[]
  },
  metadata: {
    address: string
    chainId: string
    clientId: string
    limit: number
    offset: number
    count: number
  }
}

// Get EVM transactions including UserOperations
const evmTxs = await portal.getTransactionHistory({
  chainId: 'eip155:1',
  limit: 20,
  order: 'desc',
  userOperations: 'include',  // Include both regular txs and UserOps
});

// Type narrowing based on transaction type
evmTxs.data.transactions.forEach(tx => {
  if (tx.type === 'userOperation') {
    console.log('UserOp hash:', tx.userOpHash);
    console.log('Entry point:', tx.entryPoint);
    // tx.asset not available (compile error)
  } else {
    console.log('Token:', tx.asset);
    console.log('Token address:', tx.tokenAddress);
    // tx.userOpHash not available (compile error)
  }
});

// EVM + Account Abstraction: omit `userOperations`
// If wallet is AA-enabled, SDK injects `userOperations='only'`
// Otherwise (EOA), the parameter is not sent
const aaEvmHistory = await portal.getTransactionHistory({
  chainId: 'eip155:42161',
  limit: 20,
});

// Get Solana transactions
const solanaTxs = await portal.getTransactionHistory({
  chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
  limit: 15,
});

// Solana transactions have a different structure
solanaTxs.data.transactions.forEach(tx => {
  console.log('Signature:', tx.signature);
  console.log('Block time:', tx.blockTime);
  console.log('Status:', tx.status);
});

// Get only UserOperations (EVM only)
const userOps = await portal.getTransactionHistory({
  chainId: 'eip155:137',
  userOperations: 'only',
  limit: 10,
});

public async getTransactions(
  chainId: string,
  limit?: number,
  offset?: number,
  order?: GetTransactionsOrder
): Promise<Transaction[]>

import { GetTransactionsOrder } from '@portal-hq/web';

// ⚠️ DEPRECATED: Use getTransactionHistory() instead
const txs = await portal.getTransactions('eip155:1', 10, 0, GetTransactionsOrder.DESC);

// ✅ RECOMMENDED: Use the new method with improved type safety
const walletTxs = await portal.getTransactionHistory({
  chainId: 'eip155:1',
  limit: 10,
  offset: 0,
  order: 'desc',
});

public async evaluateTransaction(
  chainId: string,
  transaction: EvaluateTransactionParam,
  operationType?: EvaluateTransactionOperationType
): Promise<EvaluatedTransaction>

const evaluation = await portal.evaluateTransaction('eip155:1', {
  from: portal.address,
  to: '0x...',
  value: '0x1',
});

console.log('Security warnings:', evaluation.warnings);

public async buildTransaction(
  chainId: string,
  to: string,
  token: string,
  amount: string
): Promise<BuiltTransaction>

const builtTx = await portal.buildTransaction(
  'eip155:1',
  '0x...',
  '0x0000000000000000000000000000000000000000', // Native ETH
  '1000000000000000000' // 1 ETH in wei
);

// Use the built transaction
const txHash = await portal.request({
  chainId: 'eip155:1',
  method: 'eth_sendTransaction',
  params: [builtTx.transaction],
});

public async receiveTestnetAsset(chainId: string, params: FundParams): Promise<FundResponse>

const fundResponse = await portal.receiveTestnetAsset('eip155:11155111', {
  amount: '1',
  token: 'ETH',
});

console.log('Transaction hash:', fundResponse.data?.txHash);
console.log('Explorer URL:', fundResponse.data?.explorerUrl);

public async getQuote(
  apiKey: string,
  args: QuoteArgs,
  chainId: string
): Promise<QuoteResponse>

public async getSources(apiKey: string, chainId: string): Promise<Record<string, string>>

public updateChain(newChainId: string): void

portal.updateChain('eip155:137'); // Switch to Polygon

public getRpcUrl(chainId?: string): string

public async storedClientBackupShare(success: boolean, backupMethod: BackupMethods): Promise<void>

import { BackupMethods } from '@portal-hq/web';

// After successfully storing a backup
await portal.storedClientBackupShare(true, BackupMethods.gdrive);

public getValidators(yieldId: string): Promise<YieldXyzValidator[]>

const validators = await portal.yield.getValidators('monad-testnet-mon-native-staking')
console.log('Validators:', validators)

public async deposit(
  params: YieldDepositParams,
  options?: YieldSubmitOptions,
): Promise<YieldDepositResult>

public async withdraw(
  params: YieldWithdrawParams,
  options?: YieldSubmitOptions,
): Promise<YieldWithdrawResult>

public async discover(data: YieldXyzGetYieldsRequest): Promise<YieldXyzGetYieldsResponse>

const yields = await portal.yield.yieldXyz.discover({
  // Discovery parameters
});
console.log('Available yields:', yields);

public async getBalances(data: YieldXyzGetBalancesRequest): Promise<YieldXyzGetBalancesResponse>

public async getHistoricalActions(
  data: YieldXyzGetHistoricalActionsRequest
): Promise<YieldXyzGetHistoricalActionsResponse>