@portal-hq/core

npm install @portal-hq/core
# or
yarn add @portal-hq/core

import { Portal, BackupMethods } from '@portal-hq/core'
import Keychain from '@portal-hq/keychain'
import GDriveStorage from '@portal-hq/gdrive-storage'
import ICloudStorage from '@portal-hq/icloud-storage'

const portal = new Portal({
  // Required
  apiKey: 'YOUR_PORTAL_CLIENT_API_KEY',
  backup: {
    [BackupMethods.GoogleDrive]: new GDriveStorage(),
    [BackupMethods.iCloud]: new ICloudStorage(),
  },
  // gatewayConfig is optional — Portal's RPC gateway is used automatically for 10 built-in chains.
  // Supply a value only if you need additional chains or a custom RPC provider.
  // gatewayConfig: { 'eip155:1': 'https://mainnet.infura.io/v3/YOUR_KEY' },

  // Optional
  isSimulator: false,
  autoApprove: false,
  keychain: new Keychain(),
  apiHost: 'api.portalhq.io',
  mpcHost: 'mpc.portalhq.io',
    featureFlags: {},
})

createWallet(progress?: ProgressCallback): Promise<AddressesByNamespace>

const addresses = await portal.createWallet((status) => {
  console.log('Status:', status.status, 'Done:', status.done)
})
console.log('EVM Address:', addresses.eip155)
console.log('Solana Address:', addresses.solana)

backupWallet(
  method: BackupMethods,
  progress?: ProgressCallback,
  backupConfig?: BackupConfigs
): Promise<string>

// Google Drive backup
const cipherText = await portal.backupWallet(BackupMethods.GoogleDrive)

// Password backup
const cipherText = await portal.backupWallet(
  BackupMethods.Password,
  undefined,
  { passwordStorage: { password: 'user-password' } }
)

recoverWallet(
  cipherText?: string,
  method: BackupMethods,
  progress?: ProgressCallback,
  backupConfig?: BackupConfigs
): Promise<AddressesByNamespace>

const addresses = await portal.recoverWallet(
  '',
  BackupMethods.GoogleDrive,
  (status) => console.log(status.status)
)

provisionWallet(
  cipherText: string,
  method: BackupMethods,
  progress?: ProgressCallback,
  backupConfig?: BackupConfigs
): Promise<AddressesByNamespace>

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

const exists = await portal.doesWalletExist()
const evmExists = await portal.doesWalletExist('eip155:1')
const solanaExists = await portal.doesWalletExist('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')

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

const onDevice = await portal.isWalletOnDevice()

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

const backedUp = await portal.isWalletBackedUp()

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

const recoverable = await portal.isWalletRecoverable()

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

const methods = await portal.availableRecoveryMethods()
// ['gdrive', 'icloud']

getAssets(chainId: string): Promise<AssetsResponse>

interface AssetsResponse {
  nativeBalance?: NativeBalance
  tokenBalances?: TokenBalance[]
  nfts?: Nft[]
}

const assets = await portal.getAssets('eip155:1')

console.log('Native balance:', assets.nativeBalance)
console.log('Token balances:', assets.tokenBalances)
console.log('NFTs:', assets.nfts)

personalSign(message: string, chainId?: string): Promise<any>

const signature = await portal.personalSign('Hello, World!')

import { PortalRequestMethod } from '@portal-hq/core'

const address = await portal.address
const signature = await portal.request(
  PortalRequestMethod.PersonalSign,
  ['Hello, World!', address],
  'eip155:1',
  { signatureApprovalMemo: 'Sign message' }
)

ethSign(message: string, chainId?: string, signatureApprovalMemo?: string): Promise<any>

const signature = await portal.ethSign('0x...')

import { PortalRequestMethod } from '@portal-hq/core'

const address = await portal.address
const signature = await portal.request(
  PortalRequestMethod.EthSign,
  [address, '0x...'],
  'eip155:1',
  { signatureApprovalMemo: 'Sign message' }
)

ethSignTypedData(typedData: string, chainId?: string): Promise<any>

const typedData = JSON.stringify({
  types: { ... },
  primaryType: 'Mail',
  domain: { ... },
  message: { ... }
})
const signature = await portal.ethSignTypedData(typedData)

import { PortalRequestMethod } from '@portal-hq/core'

const address = await portal.address
const typedData = JSON.stringify({
  types: { ... },
  primaryType: 'Mail',
  domain: { ... },
  message: { ... }
})
const signature = await portal.request(
  PortalRequestMethod.EthSignTypedDataV4,
  [address, typedData],
  'eip155:1',
  { signatureApprovalMemo: 'Sign typed data' }
)

rawSign(
  message: string,
  chainId?: string,
  options?: RawSignOptions
): Promise<any>

const signature = await portal.rawSign(
  '0xabcdef...',        // Hex-encoded message
  'eip155:11155111',    // Optional CAIP-2 chainId
  { signatureApprovalMemo: 'Sign login challenge' } // Optional RawSignOptions
)

ethSendTransaction(
  transaction: SigningRequestParams,
  chainId?: string
): Promise<any>

const txHash = await portal.ethSendTransaction({
  to: '0x...',
  value: '0x1',
  data: '0x',
})

import { PortalRequestMethod } from '@portal-hq/core'

const txHash = await portal.request(
  PortalRequestMethod.EthSendTransaction,
  [{
    to: '0x...',
    value: '0x1',
    data: '0x',
  }],
  'eip155:1',
  { signatureApprovalMemo: 'Send transaction' }
)

ethSignTransaction(
  transaction: SigningRequestParams,
  chainId?: string
): Promise<any>

const signedTx = await portal.ethSignTransaction({
  to: '0x...',
  value: '0x1',
})

import { PortalRequestMethod } from '@portal-hq/core'

const signedTx = await portal.request(
  PortalRequestMethod.EthSignTransaction,
  [{
    to: '0x...',
    value: '0x1',
  }],
  'eip155:1',
  { signatureApprovalMemo: 'Sign transaction' }
)

sendAsset(params: SendAssetParams, chain?: string): Promise<any>

sendAsset(to: string, token: string, amount: string, chain?: string): Promise<any>

interface SendAssetParams {
  to: string
  amount: string
  token: string
  sponsorGas?: boolean
  signatureApprovalMemo?: string
}

// Send ETH on Sepolia with Portal sponsoring gas (default)
const tx1 = await portal.sendAsset({
  to: '0xRecipient...',
  token: 'ETH',
  amount: '0.1',
}, 'sepolia')

// Send ETH on Sepolia but user pays gas
const tx2 = await portal.sendAsset({
  to: '0xRecipient...',
  token: 'ETH',
  amount: '0.1',
  sponsorGas: false
}, 'sepolia')

waitForConfirmation(txHash: string, network: string): Promise<boolean>

const confirmed = await portal.waitForConfirmation(txHash, 'eip155:11155111')
if (confirmed) {
  console.log('Transaction confirmed!')
} else {
  console.log('Transaction failed or timed out')
}

evaluateTransaction(
  params: EvaluateTransactionParam,
  chainId: string,
  operationType?: EvaluateTransactionOperationType
): Promise<BlockaidValidateTrxRes>

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

request(
  method: PortalRequestMethod,
  params: unknown[],
  chainId?: string,
  options?: RequestOptions
): Promise<any>

request(
  method: string,
  params: unknown[],
  chainId?: string,
  options?: RequestOptions
): Promise<any>

import { PortalRequestMethod } from '@portal-hq/core'

const balance = await portal.request(
  PortalRequestMethod.EthGetBalance,
  ['0xAddress...', 'latest'],
  'eip155:1'
)

// Send a transaction where the user pays gas
const txDetails = await portal.api.buildTransaction(
  '0xRecipientAddress',
  'USDC',
  '1',
  'eip155:1'
)

const txHash = await portal.request(
  PortalRequestMethod.EthSendTransaction,
  [txDetails.transaction],
  'eip155:1',
  {
    sponsorGas: false,
    signatureApprovalMemo: 'Swap via Portal'
  }
)
console.log('Transaction hash:', txHash)

ethGetBalance(chainId?: string): Promise<string>

import { PortalRequestMethod } from '@portal-hq/core'

const address = await portal.address
const balance = await portal.request(
  PortalRequestMethod.EthGetBalance,
  [address],
  'eip155:1'
)

ethGasPrice(chainId?: string): Promise<string>

import { PortalRequestMethod } from '@portal-hq/core'

const gasPrice = await portal.request(
  PortalRequestMethod.EthGasPrice,
  [],
  'eip155:1'
)

ethEstimateGas(
  transaction: SigningRequestParams,
  chainId?: string
): Promise<string>

import { PortalRequestMethod } from '@portal-hq/core'

const gas = await portal.request(
  PortalRequestMethod.EthEstimateGas,
  [transaction],
  'eip155:1'
)

getBalanceAsNumber(chainId: string): Promise<number>

const balance = await portal.getBalanceAsNumber('eip155:1')
console.log(`Balance: ${balance} ETH`)

updateChain(chainId: string): Promise<void>

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

on(event: string, callback: EventHandler): void

portal.on('chainChanged', (chainId) => {
  console.log('Chain changed to:', chainId)
})

emit(event: string, payload?: any): void

removeEventListener(event: string, callback?: EventHandler): void

deleteAddress(): Promise<boolean>

deleteSigningShare(): Promise<boolean>

deleteShares(): Promise<boolean>

getSigningSharesMetadata(chainId?: string): Promise<SigningSharePairMetadata[]>

getBackupSharesMetadata(chainId?: string): Promise<BackupSharePairMetadata[]>

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

const result = await portal.receiveTestnetAsset('eip155:11155111', {
  token: 'ETH',
  amount: '0.1',
})

createPortalConnectInstance(chainId: number): PortalConnect

const portalConnect = portal.createPortalConnectInstance(1)

portal.api.getClient(): Promise<ClientResponse>

portal.api.getAssets(chainId: string): Promise<{
  nativeBalance: NativeBalance
  tokenBalances: TokenBalance[]
  nfts?: NFT[]
}>

**Example:**

```typescript
const assets = await portal.api.getAssets('eip155:1')

portal.api.getNFTs(chainId?: string): Promise<NFT[]>

const nfts = await portal.api.getNFTs('eip155:1')

portal.api.getBalances(chainId?: string): Promise<Balance[]>

const balances = await portal.api.getBalances('eip155:1')

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

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

portal.api.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.api.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.api.getTransactionHistory({
  chainId: 'eip155:42161',
  limit: 20,
});

// Get Solana transactions
const solanaTxs = await portal.api.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.api.getTransactionHistory({
  chainId: 'eip155:137',
  userOperations: 'only',
  limit: 10,
});

portal.api.getTransactions(
  chainId?: string,
  limit?: number,
  offset?: number,
  order?: GetTransactionsOrder
): Promise<Transaction[]>

const txs = await portal.api.getTransactions('eip155:1', 10, 0, 'desc')

portal.api.getNetworks(): Promise<Network[]>

portal.api.getEnabledDapps(): Promise<Dapp[]>

portal.api.simulateTransaction(
  transaction: SimulateTransactionParam,
  chainId?: string
): Promise<SimulatedTransaction>

portal.api.getQuote(
  apiKey: string,
  args: QuoteArgs,
  chainId?: string
): Promise<QuoteResponse>

portal.api.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 createCustomer(
  request: MeldCreateCustomerRequest
): Promise<MeldCreateCustomerResponse>

public async searchCustomer(): Promise<MeldSearchCustomerResponse>

public async getRetailQuote(
  request: MeldGetRetailQuoteRequest
): Promise<MeldGetRetailQuoteResponse>

public async createRetailWidget(
  request: MeldCreateRetailWidgetRequest
): Promise<MeldCreateRetailWidgetResponse>

public async searchRetailTransactions(
  params?: MeldSearchRetailTransactionsParams
): Promise<MeldSearchRetailTransactionsResponse>

public async getRetailTransaction(id: string): Promise<MeldGetRetailTransactionResponse>

public async getRetailTransactionBySession(
  sessionId: string
): Promise<MeldGetRetailTransactionResponse>

public async getServiceProviders(
  params?: MeldDiscoveryParams
): Promise<MeldGetServiceProvidersResponse>

public async getCountries(
  params?: MeldDiscoveryParams
): Promise<MeldGetCountriesResponse>

public async getFiatCurrencies(
  params?: MeldDiscoveryParams
): Promise<MeldGetFiatCurrenciesResponse>

public async getCryptoCurrencies(
  params?: MeldDiscoveryParams
): Promise<MeldGetCryptoCurrenciesResponse>

public async getPaymentMethods(
  params?: MeldDiscoveryParams
): Promise<MeldGetPaymentMethodsResponse>

public async getDefaults(
  params?: MeldDiscoveryParams
): Promise<MeldGetDefaultsResponse>

public async getBuyLimits(
  params?: MeldDiscoveryParams
): Promise<MeldGetBuyLimitsResponse>

public async getSellLimits(
  params?: MeldDiscoveryParams
): Promise<MeldGetSellLimitsResponse>

public async getKycLimits(
  params?: MeldDiscoveryParams
): Promise<MeldGetKycLimitsResponse>

portal.mpc.generate(progress?: ProgressCallback): Promise<AddressesByNamespace>

portal.mpc.backup(
  method: BackupMethods,
  progress?: ProgressCallback,
  backupConfig?: BackupConfigs
): Promise<string>

portal.mpc.recover(
  cipherText: string,
  method: BackupMethods,
  progress?: ProgressCallback,
  backupConfig?: BackupConfigs
): Promise<AddressesByNamespace>

portal.mpc.ejectPrivateKey(
  backupShareCipherText?: string,
  backupMethod: BackupMethods,
  backupConfig?: BackupConfigs,
  orgShare?: string
): Promise<string>

portal.mpc.ejectPrivateKeys(
  backupShareCipherText?: string,
  backupMethod: BackupMethods,
  backupConfig?: BackupConfigs,
  orgShare?: orgShares
): Promise<EjectedKeys>

interface EjectedKeys {
  secp256k1Key?: string
  ed25519Key?: string
}

portal.mpc.isReady(): Promise<boolean>

portal.provider.request({
  method: string,
  params: any[],
  chainId?: string
}): Promise<any>

const txHash = await portal.provider.request({
  method: 'eth_sendTransaction',
  params: [{
    to: '0x...',
    value: '0x1',
    data: '0x',
  }],
  chainId: 'eip155:1',
})

import { Portal, PortalContextProvider } from '@portal-hq/core'

const App = () => {
  const [portal, setPortal] = useState<Portal | null>(null)

  useEffect(() => {
    setPortal(new Portal({ /* config */ }))
  }, [])

  if (!portal) return null

  return (
    <PortalContextProvider value={portal}>
      <YourApp />
    </PortalContextProvider>
  )
}

import { usePortal } from '@portal-hq/core'

const WalletComponent = () => {
  const portal = usePortal()

  const createWallet = async () => {
    const addresses = await portal.createWallet()
    console.log(addresses)
  }

  return <Button onPress={createWallet} title="Create Wallet" />
}

enum BackupMethods {
  Custom = 'custom',
  Firebase = 'firebase',
  GoogleDrive = 'gdrive',
  Password = 'password',
  Passkey = 'passkey',
  Unknown = 'unknown',
  iCloud = 'icloud',
}

enum PortalRequestMethod {
  EthSign = 'eth_sign',
  EthSignTransaction = 'eth_signTransaction',
  EthSignUserOperation = 'eth_signUserOperation'
  EthSignTypedDataV4 = 'eth_signTypedData_v4',
  EthSendTransaction = 'eth_sendTransaction',
  EthGetBalance = 'eth_getBalance',
  EthGasPrice = 'eth_gasPrice',
  EthEstimateGas = 'eth_estimateGas',
  PersonalSign = 'personal_sign',
  RawSign = 'raw_sign',
  SolSignAndSendTransaction = 'sol_signAndSendTransaction',
  SolSignTransaction = 'sol_signTransaction',
  SolSignMessage = 'sol_signMessage',
  // Additional Solana and other supported chain methods are also available.
}

enum PortalNamespace {
  eip155 = 'eip155',
  solana = 'solana',
}