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

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 getTransactions(
  chainId: string,
  limit?: number,
  offset?: number,
  order?: GetTransactionsOrder
): Promise<Transaction[]>

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

const txs = await portal.getTransactions('eip155:1', 10, 0, GetTransactionsOrder.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 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 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 getQuote(
  apiKey: string,
  args: QuoteArgs,
  chainId: string
): Promise<QuoteResponse>

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

public async initiateKyc(data: NoahInitiateKycRequest): Promise<NoahInitiateKycResponse>

public async initiatePayin(data: NoahInitiatePayinRequest): Promise<NoahInitiatePayinResponse>

public async simulatePayin(data: NoahSimulatePayinRequest): Promise<NoahSimulatePayinResponse>

public async getPayoutCountries(): Promise<NoahGetPayoutCountriesResponse>

public async getPayoutChannels(data: NoahGetPayoutChannelsRequest): Promise<NoahGetPayoutChannelsResponse>

public async getPayoutChannelForm(channelId: string): Promise<NoahGetPayoutChannelFormResponse>

public async getPayoutQuote(data: NoahGetPayoutQuoteRequest): Promise<NoahGetPayoutQuoteResponse>

public async initiatePayout(data: NoahInitiatePayoutRequest): Promise<NoahInitiatePayoutResponse>

public async getPaymentMethods(): Promise<NoahGetPaymentMethodsResponse>

public async ethEstimateGas(chainId: string, transaction: EthereumTransaction): Promise<any>

public async ethGasPrice(chainId: string): Promise<string>

public async ethGetBalance(chainId: string): Promise<string>

public async ethSendTransaction(chainId: string, transaction: EthereumTransaction): Promise<string>

public async ethSignTransaction(chainId: string, transaction: EthereumTransaction): Promise<string>

public async ethSignTypedData(chainId: string, data: TypedData): Promise<string>

public async ethSignTypedDataV3(chainId: string, data: TypedData): Promise<string>

public async ethSignTypedDataV4(chainId: string, data: TypedData): Promise<string>

public async personalSign(chainId: string, message: string): Promise<string>

public async getBalances(chainId: string): Promise<Balance[]>

public async getNFTs(chainId: string): Promise<NFT[]>

public async simulateTransaction(
  chainId: string,
  transaction: SimulateTransactionParam
): Promise<SimulatedTransaction>