Add Robinhood stocks to your app

import { ChainKeys, type IEvmWalletProvider, type Hex } from '@sodax/sdk';
import { EvmWalletProvider } from '@sodax/wallet-sdk-core';

const hederaWalletProvider: IEvmWalletProvider = new EvmWalletProvider({
  privateKey: '0x...' as Hex, // Node.js only; never ship a private key to a browser
  chainId: ChainKeys.HEDERA_MAINNET,
  rpcUrl: 'https://mainnet.hashio.io/api',
});

import { ChainKeys, getSupportedSolverTokens, isRealWorldAsset } from '@sodax/sdk';

// Every tokenized stock and ETF a solver can swap on Hedera.
const hederaStocks = getSupportedSolverTokens(ChainKeys.HEDERA_MAINNET).filter(isRealWorldAsset);

hederaStocks.forEach(token => {
  console.log(`${token.symbol}: ${token.address} (${token.decimals} decimals)`);
});

import { Sodax, ChainKeys, hederaSupportedTokens, type SolverIntentQuoteRequest } from '@sodax/sdk';

const sodax = new Sodax();
await sodax.initialize(); // non-fatal on failure; the SDK falls back to packaged defaults

const usdc = hederaSupportedTokens.USDC; // 6 decimals
const aapl = hederaSupportedTokens.AAPL; // 8 decimals

const quoteResult = await sodax.swaps.getQuote({
  token_src: usdc.address,
  token_dst: aapl.address,
  token_src_blockchain_id: ChainKeys.HEDERA_MAINNET,
  token_dst_blockchain_id: ChainKeys.HEDERA_MAINNET,
  amount: 10_000_000n, // 10 USDC
  quote_type: 'exact_input',
} satisfies SolverIntentQuoteRequest);

if (!quoteResult.ok) {
  // Branch on quoteResult.error.code, never on the message. Keep the buy button disabled.
  console.error('No quote:', quoteResult.error);
  return;
}

const slippageBps = 100n; // 1%
const minOutputAmount = (quoteResult.value.quoted_amount * (10_000n - slippageBps)) / 10_000n;
console.log('Minimum AAPL out (8 decimals):', minOutputAmount);

import type { CreateIntentParams } from '@sodax/sdk';

const walletAddress = await hederaWalletProvider.getWalletAddress();

const params: CreateIntentParams<typeof ChainKeys.HEDERA_MAINNET> = {
  inputToken: usdc.address,
  outputToken: aapl.address,
  inputAmount: 10_000_000n,
  minOutputAmount,                // from Step 2, after slippage
  deadline: 0n,                   // or a deadline from sodax.swaps.getSwapDeadline()
  allowPartialFill: false,
  srcChainKey: ChainKeys.HEDERA_MAINNET,
  dstChainKey: ChainKeys.HEDERA_MAINNET,
  srcAddress: walletAddress,
  dstAddress: walletAddress,
  solver: '0x0000000000000000000000000000000000000000', // any solver
  data: '0x',
};

const allowance = await sodax.swaps.isAllowanceValid({ params, walletProvider: hederaWalletProvider });
if (allowance.ok && !allowance.value) {
  const approve = await sodax.swaps.approve({ params, walletProvider: hederaWalletProvider });
  if (!approve.ok) return;
  await hederaWalletProvider.waitForTransactionReceipt(approve.value);
}

const swapResult = await sodax.swaps.swap({ params, walletProvider: hederaWalletProvider });
if (!swapResult.ok) {
  console.error('Swap failed:', swapResult.error.code);
  return;
}

const status = await sodax.swaps.getDetailedStatus({
  srcChainKey: ChainKeys.HEDERA_MAINNET,
  srcTxHash: swapResult.value.intentDeliveryInfo.srcTxHash,
});
// getDetailedStatus is a one-off read: poll it until a final status, or use useDetailedStatus in React.

import { ChainKeys, hederaSupportedTokens, robinhoodSupportedTokens } from '@sodax/sdk';

const from = hederaSupportedTokens.AAPL;      // 8 decimals
const to = robinhoodSupportedTokens.AAPL;     // 18 decimals

if (!sodax.bridge.isBridgeable({ from, to })) throw new Error('Not bridgeable');

const limit = await sodax.bridge.getBridgeableAmount(from, to);
if (!limit.ok) return;

const amount = 1_000_000n; // 0.01 AAPL in Hedera's 8 decimals
// Cross-multiply so both sides share a scale: the limit may be in Robinhood's 18 decimals.
if (amount * 10n ** BigInt(limit.value.decimals) > limit.value.amount * 10n ** BigInt(from.decimals)) {
  console.log('Above the current limit:', limit.value.type); // 'DEPOSIT_LIMIT' | 'WITHDRAWAL_LIMIT'
  return;
}

const params = {
  srcChainKey: ChainKeys.HEDERA_MAINNET,
  srcAddress: hederaAddress,
  srcToken: from.address,
  amount,
  dstChainKey: ChainKeys.ROBINHOOD_MAINNET,
  dstToken: to.address,
  recipient: robinhoodAddress, // the user's address on Robinhood Chain
};

const allowance = await sodax.bridge.isAllowanceValid({ params, walletProvider: hederaWalletProvider });
if (allowance.ok && !allowance.value) {
  const approve = await sodax.bridge.approve({ params, walletProvider: hederaWalletProvider });
  if (!approve.ok) return;
  await hederaWalletProvider.waitForTransactionReceipt(approve.value);
}

const result = await sodax.bridge.bridge({ params, walletProvider: hederaWalletProvider });
if (!result.ok) {
  console.error('Bridge failed:', result.error.code);
  return;
}

const status = await sodax.bridge.getDetailedStatus({
  srcChainKey: ChainKeys.HEDERA_MAINNET,
  srcTxHash: result.value.srcChainTxHash,
});

import { createPublicClient, http, erc20Abi, formatUnits } from 'viem';

// SODAX SpokeAssetManager: the same address on Hedera and on Robinhood Chain.
const SODAX_SPOKE_ASSET_MANAGER = '0x0df73542cC68bDC01b361d231c60F726B0e0bC05';

const HEDERA_TOKEN = '0x0000000000000000000000000000000000a567e1';    // AAPL on Hedera (8 decimals)
const ROBINHOOD_TOKEN = '0xaF3D76f1834A1d425780943C99Ea8A608f8a93f9'; // AAPL on Robinhood Chain (18 decimals)

const hedera = createPublicClient({ transport: http('https://mainnet.hashio.io/api') });
const robinhood = createPublicClient({ transport: http('https://rpc.mainnet.chain.robinhood.com') });

const read = (client, address, functionName, args = []) =>
  client.readContract({ address, abi: erc20Abi, functionName, args });

const [hederaSupply, hederaHeldBySodax, robinhoodLocked] = await Promise.all([
  read(hedera, HEDERA_TOKEN, 'totalSupply'),
  read(hedera, HEDERA_TOKEN, 'balanceOf', [SODAX_SPOKE_ASSET_MANAGER]),
  read(robinhood, ROBINHOOD_TOKEN, 'balanceOf', [SODAX_SPOKE_ASSET_MANAGER]),
]);

const hederaCirculating = hederaSupply - hederaHeldBySodax;

console.log('In users\' hands on Hedera:', formatUnits(hederaCirculating, 8));
console.log('Locked on Robinhood Chain: ', formatUnits(robinhoodLocked, 18));
console.log('Covers Hedera:', robinhoodLocked >= hederaCirculating * 10n ** 10n); // scale 8 to 18 decimals