SDK Reference

Complete API reference for the Stratos Wallet SDK.

---

Installation

npm install @stratos/wallet-sdk

---

Initialization

getSDK()

Get the singleton SDK instance.

import { getSDK } from '@stratos/wallet-sdk';

const sdk = getSDK();

// With configuration
const sdk = getSDK({
  timeout: 60000,  // Request timeout in ms
  debug: true,     // Enable console logging
});

---

Connection Methods

connect()

Connect to the parent wallet and get user information.

const state = await sdk.connect();

// Returns:
interface ConnectionState {
  connected: boolean;
  user: AuthUser | null;
  addresses: ChainAddress[];
}

isConnected()

Check if currently connected.

if (sdk.isConnected()) {
  // Safe to make requests
}

disconnect()

Disconnect from the wallet.

await sdk.disconnect();

---

User Methods

getUser()

Get the current authenticated user.

const user = await sdk.getUser();

// Returns:
interface AuthUser {
  id: string;
  username: string;
  displayName: string | null;
  role: 'user' | 'admin';
  partyId?: string;  // Canton party ID
}

getPartyId()

Get the user's Canton party ID.

const partyId = await sdk.getPartyId();
// Returns: string | null

---

Asset Methods

getAssets()

Get all assets with balances.

const assets = await sdk.getAssets();

// Returns:
interface Asset {
  symbol: string;
  name: string;
  balance: number;
  icon: string | null;
  chain?: string;
  chainType?: ChainType;
}

getBalance()

Get balance for a specific asset.

const ethBalance = await sdk.getBalance('ETH');
const usdcOnBase = await sdk.getBalance('USDC', 'base');

getAddresses()

Get all chain addresses for the user.

const addresses = await sdk.getAddresses();

// Returns:
interface ChainAddress {
  chain: string;        // "Ethereum", "Solana", etc.
  chainType: ChainType; // "evm", "svm", "btc", etc.
  address: string;
}

---

EVM Transactions

sendEVMTransaction()

Sign and broadcast an EVM transaction.

const result = await sdk.sendEVMTransaction({
  transaction: {
    to: '0xRecipient...',
    value: '0xDE0B6B3A7640000', // 1 ETH in wei (hex)
    data: '0x...',              // Optional call data
    chainId: 1,                 // Ethereum mainnet
    gasLimit: '0x5208',         // Optional
    maxFeePerGas: '0x...',      // Optional (EIP-1559)
  }
});

// Returns:
interface SendEVMTransactionResult {
  transactionHash: string;
  status: 'pending' | 'confirmed' | 'failed';
}

signEVMTransaction()

Sign without broadcasting.

const { signedTransaction, transactionHash } = await sdk.signEVMTransaction({
  transaction: { /* same as above */ }
});

signTypedData()

Sign EIP-712 typed data.

const signature = await sdk.signTypedData({
  typedData: {
    types: { /* EIP-712 types */ },
    primaryType: 'Permit',
    domain: { /* domain data */ },
    message: { /* message data */ },
  }
});

Convenience Methods

// Send native token
await sdk.sendNative(to, value, chainId);

// Send contract call
await sdk.sendContractCall(to, data, chainId, value?);

---

Solana Transactions

signRawSolanaTransaction()

Sign a raw Solana transaction.

const { signedTransaction, signature } = await sdk.signRawSolanaTransaction({
  transaction: base64EncodedTx,
  network: 'mainnet', // or 'devnet'
});

sendRawSolanaTransaction()

Broadcast a signed transaction.

const result = await sdk.sendRawSolanaTransaction({
  signedTransaction,
  network: 'mainnet',
});

---

TON Transactions

signRawTonMessage()

Sign a raw TON message.

const { boc, hash } = await sdk.signRawTonMessage({
  to: 'EQContract...',
  value: '1000000000', // nanotons
  payload: base64Boc,
  network: 'mainnet',
});

sendRawTonMessage()

Broadcast a signed message.

const result = await sdk.sendRawTonMessage({
  boc,
  network: 'mainnet',
});

---

TRON Transactions

triggerTronSmartContract()

Trigger a TRON smart contract.

const { txID, rawTransaction, signature } = await sdk.triggerTronSmartContract({
  contractAddress: 'TContract...',
  functionSelector: 'transfer(address,uint256)',
  parameter: abiEncodedParams,
  feeLimit: 100000000,
  network: 'mainnet',
});

broadcastTronTransaction()

Broadcast a signed transaction.

const result = await sdk.broadcastTronTransaction({
  signedTransaction: rawTransaction,
  network: 'mainnet',
});

---

Canton Methods

cantonQuery()

Query contracts by template.

const contracts = await sdk.cantonQuery<PayloadType>({
  templateId: 'packageId#Module:Template',
  filter: { owner: partyId }, // Optional
});

// Returns:
interface CantonContract<T> {
  contractId: string;
  templateId: string;
  payload: T;
  createdAt?: string;
  signatories?: string[];
  observers?: string[];
}

cantonCreate()

Create a new contract.

const result = await sdk.cantonCreate({
  templateId: 'packageId#Module:Template',
  payload: {
    owner: partyId,
    amount: '100.0',
  },
});

// Returns: { contractId: string }

cantonExercise()

Exercise a choice on a contract.

const result = await sdk.cantonExercise<ResultType>({
  contractId: 'contract123...',
  templateId: 'packageId#Module:Template',
  choice: 'Accept',
  argument: { /* choice arguments */ },
});

// Returns:
interface CantonExerciseResult<T> {
  exerciseResult: T;
  events?: CantonContract[];
}

getTransferOffers()

Get pending transfer offers.

const offers = await sdk.getTransferOffers();

// Returns:
interface TransferOffer {
  contractId: string;
  sender: string;
  senderName?: string;
  receiver: string;
  amount: string;
  symbol: string;
  memo?: string;
  createdAt: string;
}

acceptTransferOffer()

Accept a transfer offer.

await sdk.acceptTransferOffer(contractId);

transfer()

Send a Canton transfer.

await sdk.transfer({
  to: 'receiverPartyId',
  amount: '100.0',
  symbol: 'CC',
  chain: 'canton',
  memo: 'Payment',
});

---

Events

on()

Subscribe to an event.

sdk.on('assetsChanged', (assets) => {
  console.log('Assets updated:', assets);
});

Available Events

Event	Payload	Description
connect	ConnectionState	Connection established
disconnect	void	Disconnected
userChanged	AuthUser | null	User changed
assetsChanged	Asset[]	Assets updated
transactionsChanged	Transaction[]	Transactions updated
addressesChanged	ChainAddress[]	Addresses changed

off()

Unsubscribe from an event.

sdk.off('assetsChanged', handler);

removeAllListeners()

Remove all listeners.

sdk.removeAllListeners();

---

Lifecycle

destroy()

Clean up SDK resources. Call when unmounting.

useEffect(() => {
  return () => {
    sdk.destroy();
  };
}, []);

refresh()

Refresh all data from wallet.

await sdk.refresh();

---

Error Handling

All methods may throw errors:

try {
  await sdk.sendEVMTransaction({...});
} catch (error) {
  if (error.message.includes('User rejected')) {
    // User cancelled
  } else if (error.message.includes('Insufficient funds')) {
    // Not enough balance
  } else {
    console.error('Error:', error.message);
  }
}

Common Errors

Error	Cause
Not in iframe	App not in wallet
Request timeout	Wallet didn't respond
User rejected	User cancelled
Insufficient funds	Not enough balance
Template not found	DAR not installed

---

Types

ChainType

type ChainType = 'evm' | 'svm' | 'btc' | 'tron' | 'ton' | 'canton';

Chain IDs

const EVM_CHAINS = {
  ETHEREUM: 1,
  SEPOLIA: 11155111,
  BASE: 8453,
};

---

Next Steps

• Transactions Guide - Detailed transaction examples
• Canton Contracts - Working with Daml