Reference

constructor(options: PortalOptions)

import Portal from '@portal-hq/web';

const portal = new Portal({
  rpcConfig: {
    'eip155:1': 'https://...',
    'eip155:11155111': 'https://...',
    'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': 'https://...',
  },
  apiKey: 'your-api-key',
  chainId: 'eip155:1',
  gdrive: {
    clientId: 'your-client-id',
  },
});

const portal = new Portal({
  rpcConfig: { 'eip155:1': 'https://...' },
  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 async createWallet(progress?: ProgressCallback): Promise<string>

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

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

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

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

// Complete the backup storage
await backup.storageCallback();
console.log('Backup cipher text:', backup.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 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<SendAssetResponse>

const result = await portal.sendAsset('ethereum', {
  to: '0x...',
  token: '0x0000000000000000000000000000000000000000', // Native ETH
  amount: '1000000000000000000', // 1 ETH in wei
});

console.log('Transaction hash:', result.transactionHash);

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);

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>

public async enter(data: YieldXyzEnterRequest): Promise<YieldXyzEnterYieldResponse>

const result = await portal.yield.yieldXyz.enter({
  // Enter parameters
});

public async exit(data: YieldXyzExitRequest): Promise<YieldXyzExitResponse>

public async manage(data: YieldXyzManageYieldRequest): Promise<YieldXyzManageYieldResponse>

public async track(data: YieldXyzTrackTransactionRequest): Promise<YieldXyzTrackTransactionResponse>

public async getTransaction(transactionId: string): Promise<YieldXyzGetTransactionResponse>

public async tradeAsset(
  params: LifiTradeAssetParams,
  options?: LifiTradeAssetOptions,
): Promise<LifiTradeAssetResult>

public async pollStatus(
  request: Pick<LifiStatusRequest, 'txHash' | 'fromChain' | 'toChain' | 'bridge'>,
  options?: LifiPollStatusOptions & {
    onUpdate?: (raw: LifiStatusRawResponse) => boolean | void
  },
): Promise<LifiStatusRawResponse>

public async getRoutes(data: LifiRoutesRequest): Promise<LifiRoutesResponse>

const routes = await portal.trading.lifi.getRoutes({
  fromChainId: 1,
  toChainId: 137,
  fromTokenAddress: '0x...',
  toTokenAddress: '0x...',
  fromAmount: '1000000000000000000',
});
console.log('Available routes:', routes);

public async getQuote(data: LifiQuoteRequest): Promise<LifiQuoteResponse>

const quote = await portal.trading.lifi.getQuote({
  fromChain: '1',
  toChain: '137',
  fromToken: '0x...',
  toToken: '0x...',
  fromAmount: '1000000000000000000',
  fromAddress: portal.address,
});

public async getStatus(data: LifiStatusRequest): Promise<LifiStatusResponse>

const status = await portal.trading.lifi.getStatus({
  txHash: '0x...',
  bridge: 'hop',
});
console.log('Transaction status:', status.status);

public async getRouteStep(data: LifiStepTransactionRequest): Promise<LifiStepTransactionResponse>

const step = await portal.trading.lifi.getRouteStep({
  route: selectedRoute,
  stepIndex: 0,
});

// Sign and send the transaction
const txHash = await portal.request({
  chainId: 'eip155:1',
  method: 'eth_sendTransaction',
  params: [step.transactionRequest],
});

public async tradeAsset(
  params: ZeroXTradeAssetParams,
  options?: ZeroXTradeAssetOptions,
): Promise<ZeroXTradeAssetResult>

public async getPrice(
  request: ZeroExPriceRequest,
  options?: { zeroXApiKey?: string },
): Promise<ZeroExPriceResponse>