const sdk = new SelendraSDK()
  .withEndpoint("https://rpc.selendra.org")
  .withNetwork(Network.Selendra)
  .withChainType(ChainType.Substrate);

await sdk.connect();

const staking = new StakingClient(api);

// Query examples
const validators = await staking.getValidators();
const era = await staking.getCurrentEra();
const info = await staking.getStakingInfo(address);

// Transaction examples
await staking.bond(signer, "1000000000000", controller);
await staking.nominate(signer, [validator1, validator2]);
await staking.unbond(signer, "500000000000");
await staking.withdrawUnbonded(signer);

const aleph = new AlephClient(api);

const session = await aleph.getCurrentSession();
const validators = await aleph.getSessionValidators();
const finalized = await aleph.getFinalizedBlockNumber();

const elections = new ElectionsClient(api);

const members = await elections.getMembers();
await elections.vote(signer, [candidate1, candidate2], amount);
await elections.submitCandidacy(signer);

const democracy = new DemocracyClient(api);

const referendums = await democracy.getReferendums();
await democracy.propose(signer, proposalHash, value);
await democracy.vote(signer, refIndex, { aye: true });

const accounts = new UnifiedAccountManager(api);

// Address conversion
const evmAddr = accounts.substrateToEvm("5GrwvaEF...");
const subAddr = accounts.evmToSubstrate("0x742d35Cc...");

// Validation
const validation = accounts.validateAddress(address);

// On-chain mapping
const mapped = await accounts.getEvmAddressFromMapping(substrateAddr);
await accounts.claimDefaultEvmAddress(signer);

// Balance query
const balance = await accounts.getUnifiedBalance(address);

import {
  useSelendra,
  useBalance,
  useAccount,
  useTransaction,
} from "@selendrajs/sdk";

function Component() {
  const { isConnected, connect } = useSelendra();
  const { balance } = useBalance(address);
  const { account } = useAccount();
  const { submit } = useTransaction();

  return <div>Balance: {balance?.free.toString()}</div>;
}

enum Network {
  Selendra = "selendra",
  Custom = "custom",
}

enum ChainType {
  Substrate = "substrate",
  EVM = "evm",
}

type NetworkType = "mainnet" | "testnet" | "custom";

interface Account {
  address: string;
  name?: string;
  type: "substrate" | "evm";
  publicKey: string;
}

interface Balance {
  free: bigint;
  reserved: bigint;
  frozen: bigint;
  total: bigint;
  tokenSymbol: string;
  decimals: number;
}

interface ValidatorInfo {
  address: string;
  commission: number;
  blocked: boolean;
  totalStake: string;
  ownStake: string;
  nominators: string[];
}

interface StakingInfo {
  address: string;
  staked: string;
  unlocking: UnlockingChunk[];
  available: string;
  isValidator: boolean;
  isNominator: boolean;
  nominations: string[];
}

interface UnlockingChunk {
  value: string;
  era: number;
}

interface Member {
  address: string;
  stake: string;
  backers: number;
}

interface Referendum {
  index: number;
  proposalHash: string;
  end: number;
  threshold: "SuperMajorityApprove" | "SuperMajorityAgainst" | "SimpleMajority";
  delay: number;
  tally: { ayes: string; nays: string; turnout: string };
}

interface ChainInfo {
  chainName: string;
  chainId: number;
  version: string;
  specVersion: number;
  implVersion: number;
  tokenDecimals: number;
  tokenSymbol: string;
}

interface FinalityStatus {
  finalizedBlock: number;
  currentBlock: number;
  lag: number;
}

interface Transaction {
  hash: string;
  from: string;
  to: string;
  amount?: bigint;
  data?: string;
  gasLimit?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
  nonce?: number;
  blockNumber?: number;
  blockHash?: string;
  status: "pending" | "included" | "finalized" | "failed";
  events: TransactionEvent[];
  timestamp?: number;
}

type EventType =
  | "transfer"
  | "contract.deployed"
  | "contract.interaction"
  | "block"
  | "error"
  | "connected"
  | "disconnected";

interface EventData {
  type: EventType;
  data: any;
  timestamp: number;
}

async validate(
  signer: any,
  preferences: ValidatorPreferences
): Promise<TransactionResult>

interface ValidatorPreferences {
  commission: number; // 0-100
  blocked: boolean;
}

await staking.validate(signer, {
  commission: 10, // 10%
  blocked: false,
});

async createAccount(options?: CreateAccountOptions): Promise<CreatedAccount>

interface CreateAccountOptions {
  type?: "substrate" | "evm" | "both";
  name?: string;
  password?: string;
  derivationPath?: string;
}

interface CreatedAccount {
  mnemonic: string;
  address: string;
  publicKey: string;
  type: "substrate" | "evm" | "both";
}

const account = await sdk.createAccount({
  type: "both",
  name: "My Wallet",
});

console.log("Mnemonic:", account.mnemonic);
console.log("Address:", account.address);

async importAccountFromMnemonic(
  mnemonic: string,
  options?: ImportAccountOptions
): Promise<Account>

const account = await sdk.importAccountFromMnemonic("word1 word2 word3 ...", {
  type: "substrate",
  derivationPath: "//m/44'/354'/0'/0'/0'",
});

async importAccountFromPrivateKey(
  privateKey: string,
  options?: ImportAccountOptions
): Promise<Account>

async getBalance(address: string): Promise<Balance>

interface Balance {
  free: bigint;
  reserved: bigint;
  frozen: bigint;
  total: bigint;
  tokenSymbol: string;
  decimals: number;
}

const balance = await sdk.getBalance(
  "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"
);
console.log(`Free balance: ${balance.free} ${balance.tokenSymbol}`);

async transfer(options: TransferOptions): Promise<Transaction>

interface TransferOptions {
  to: string;
  amount: bigint | string | number;
  from?: string;
  memo?: string;
  gasLimit?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
}

interface Transaction {
  hash: string;
  from: string;
  to: string;
  amount: bigint;
  blockNumber?: number;
  status: "pending" | "included" | "finalized" | "failed";
  events: TransactionEvent[];
}

const tx = await sdk.transfer({
  to: "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
  amount: BigInt("1000000000000"), // 1 SEL (assuming 12 decimals)
  memo: "Payment for services",
});

console.log("Transaction hash:", tx.hash);
console.log("Status:", tx.status);

async sendTransaction(options: SendTransactionOptions): Promise<Transaction>

interface SendTransactionOptions {
  from?: string;
  to?: string;
  data?: string;
  value?: bigint;
  gasLimit?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
  nonce?: number;
}

async estimateGas(options: SendTransactionOptions): Promise<bigint>

async getTransaction(hash: string): Promise<Transaction | null>

async getTransactionReceipt(hash: string): Promise<TransactionReceipt | null>

interface TransactionReceipt {
  transactionHash: string;
  transactionIndex: number;
  blockHash: string;
  blockNumber: number;
  from: string;
  to: string;
  gasUsed: bigint;
  logs: Log[];
  status: "success" | "failure";
}

new Contract(address: string, abi: any[], sdk: SelendraSDK)

const contract = new Contract("0x1234...abcd", abi, sdk);

async call(functionName: string, ...args: any[]): Promise<any>

const balance = await contract.call("balanceOf", "0xAddress...");
console.log("Token balance:", balance);

async send(
  functionName: string,
  options?: SendOptions,
  ...args: any[]
): Promise<Transaction>

interface SendOptions {
  from?: string;
  value?: bigint;
  gasLimit?: bigint;
  maxFeePerGas?: bigint;
}

const tx = await contract.send(
  "transfer",
  { from: "0xMyAddress...", value: BigInt("1000000000000") },
  "0xRecipientAddress...",
  BigInt("1000000000000")
);

async deployContract(options: DeployOptions): Promise<DeployedContract>

interface DeployOptions {
  bytecode: string;
  abi: any[];
  constructorArgs?: any[];
  from?: string;
  gasLimit?: bigint;
  maxFeePerGas?: bigint;
}

interface DeployedContract {
  address: string;
  transactionHash: string;
  blockNumber?: number;
}

const deployed = await sdk.deployContract({
  bytecode: "0x6080604052348015...",
  abi: erc20ABI,
  constructorArgs: ["My Token", "MTK", 18],
  from: "0xMyAddress...",
});

console.log("Contract deployed at:", deployed.address);

async getEvmAccount(address: string): Promise<EvmAccount>

interface EvmAccount {
  address: string;
  nonce: number;
  balance: bigint;
  codeHash: string;
  storageRoot: string;
}

async getEvmTransactionCount(address: string): Promise<number>

async getEvmBlock(blockHashOrNumber: string | number): Promise<EvmBlock>

async sendEvmTransaction(
  tx: EvmTransactionRequest
): Promise<EvmTransaction>

interface EvmTransactionRequest {
  from: string;
  to?: string;
  data?: string;
  value?: bigint;
  gas?: bigint;
  maxPriorityFeePerGas?: bigint;
  maxFeePerGas?: bigint;
  nonce?: number;
}

async query(pallet: string, storage: string, ...args: any[]): Promise<any>

const systemAccount = await sdk.query(
  "System",
  "Account",
  "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"
);

console.log("Account info:", systemAccount.toHuman());

tx(pallet: string, method: string, ...args: any[]): SubmittableExtrinsic

const transferTx = sdk.tx(
  "Balances",
  "transfer",
  "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
  BigInt("1000000000000")
);

const hash = await transferTx.signAndSend("my-mnemonic");
console.log("Transaction hash:", hash.toHex());

async getRuntimeVersion(): Promise<RuntimeVersion>

async subscribeToHeads(
  callback: (header: Header) => void
): Promise<() => void>

const unsubscribe = await sdk.subscribeToHeads((header) => {
  console.log("New block:", header.number.toNumber());
});

// Later: unsubscribe();

formatBalance(balance: bigint | string | number, decimals?: number): string

const formatted = sdk.formatBalance(BigInt("1000000000000"), 12);
console.log(formatted); // "1,000.000000000000"

parseBalance(balance: string, decimals?: number): bigint

addressToEvm(substrateAddress: string): string

evmToAddress(evmAddress: string): string

validateAddress(address: string): 'substrate' | 'evm' | 'invalid'

async getFeeEstimate(): Promise<FeeEstimate>

interface FeeEstimate {
  slow: {
    maxFeePerGas: bigint;
    maxPriorityFeePerGas: bigint;
    estimatedTime: number; // seconds
  };
  average: FeeTier;
  fast: FeeTier;
}

interface FeeTier {
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  estimatedTime: number;
}

<SelendraProvider sdk={sdk}>
  <App />
</SelendraProvider>

const sdk = useSelendra();

interface UseAccountReturn {
  account: Account | null;
  isConnected: boolean;
  connect: () => Promise<void>;
  disconnect: () => Promise<void>;
  balance: Balance | null;
}

const { account, isConnected, connect, disconnect, balance } = useAccount();

const { balance, loading, error } = useBalance(address);

interface UseTransactionReturn {
  send: (options: SendTransactionOptions) => Promise<Transaction>;
  transaction: Transaction | null;
  loading: boolean;
  error: Error | null;
}

const { send, transaction, loading, error } = useTransaction();

const { send, loading, error } = useTransaction();

const handleTransfer = async () => {
  try {
    const tx = await send({
      to: recipient,
      amount: BigInt("1000000000000"),
    });
    console.log("Transaction sent:", tx.hash);
  } catch (err) {
    console.error("Transfer failed:", err);
  }
};

interface Account {
  address: string;
  name?: string;
  type: "substrate" | "evm";
  publicKey: string;
}

interface Balance {
  free: bigint;
  reserved: bigint;
  frozen: bigint;
  total: bigint;
  tokenSymbol: string;
  decimals: number;
}

interface Transaction {
  hash: string;
  from: string;
  to: string;
  amount?: bigint;
  data?: string;
  gasLimit?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
  nonce?: number;
  blockNumber?: number;
  blockHash?: string;
  status: "pending" | "included" | "finalized" | "failed";
  events: TransactionEvent[];
  timestamp?: number;
}

interface ChainInfo {
  chainName: string;
  chainId: number;
  version: string;
  specVersion: number;
  implVersion: number;
  tokenDecimals: number;
  tokenSymbol: string;
}

type Network = "mainnet" | "testnet" | "custom";

type EventType =
  | "transfer"
  | "contract.deployed"
  | "contract.interaction"
  | "block"
  | "error"
  | "connected"
  | "disconnected";

interface EventData {
  type: EventType;
  data: any;
  timestamp: number;
}

class SelendraError extends Error {
  code: string;
  details?: any;

  constructor(message: string, code: string, details?: any);
}

try {
  await sdk.transfer({ to, amount });
} catch (error) {
  if (error instanceof SelendraError) {
    switch (error.code) {
      case "INSUFFICIENT_BALANCE":
        console.error("Not enough balance!");
        break;
      case "INVALID_ADDRESS":
        console.error("Invalid recipient address!");
        break;
      default:
        console.error("Transfer failed:", error.message);
    }
  }
}