npm install @selendrajs/sdk

import { createSDK, SelendraSDK, ChainType } from "@selendrajs/sdk";

// Using factory function (recommended)
const sdk = createSDK({
  endpoint: "wss://rpc.selendra.org",
  chainType: ChainType.Substrate,
});

// Or using class directly
const sdk = new SelendraSDK({
  endpoint: "wss://rpc.selendra.org",
  chainType: ChainType.Substrate,
  autoReconnect: true,
  debug: false,
});

interface SDKConfig {
  endpoint?: string; // RPC endpoint URL
  network?: string; // Network name
  chainType?: ChainType; // Substrate or EVM
  autoReconnect?: boolean; // Auto-reconnect on disconnect
  retryAttempts?: number; // Number of retry attempts
  debug?: boolean; // Enable debug logging
}

sdk.on("connecting", () => console.log("Connecting..."));
sdk.on("connected", () => console.log("Connected!"));
sdk.on("disconnected", () => console.log("Disconnected"));
sdk.on("error", (error) => console.error("Error:", error));

// Queries (read-only)
const result = await sdk.pallets.<pallet>.queries.<method>(params);

// Transactions (write operations)
const tx = sdk.pallets.<pallet>.manager.<method>(params);
await tx.signAndSend(signer);

import { createSDK } from "@selendrajs/sdk";

const sdk = createSDK({ endpoint: "wss://rpc.selendra.org" });
await sdk.connect();

// Query balance
const balance = await sdk.pallets.balances.queries.account(address);
console.log("Free:", balance.free.toString());
console.log("Reserved:", balance.reserved.toString());

// Transfer tokens
const tx = sdk.pallets.balances.manager.transfer({
  dest: recipientAddress,
  value: "1000000000000000000", // 1 SEL in planck
});

// Sign and send
await tx.signAndSend(signer, {}, (result) => {
  if (result.status.isFinalized) {
    console.log("Transfer finalized!");
  }
});

import { BalancesManager } from "@selendrajs/sdk";

// Queries
const balance = await sdk.pallets.balances.queries.account(address);
const total = await sdk.pallets.balances.queries.totalIssuance();
const locks = await sdk.pallets.balances.queries.locks(address);

// Transactions
sdk.pallets.balances.manager.transfer({ dest, value });
sdk.pallets.balances.manager.transferKeepAlive({ dest, value });
sdk.pallets.balances.manager.transferAll({ dest, keepAlive: true });

import { StakingManager, RewardDestination } from "@selendrajs/sdk";

// Queries
const validators = await sdk.pallets.staking.queries.validators();
const era = await sdk.pallets.staking.queries.activeEra();
const ledger = await sdk.pallets.staking.queries.ledger(address);
const nominators = await sdk.pallets.staking.queries.nominators(address);

// Transactions
sdk.pallets.staking.manager.bond({
  value: "100000000000000000000",
  payee: RewardDestination.Staked,
});
sdk.pallets.staking.manager.bondExtra({ maxAdditional: amount });
sdk.pallets.staking.manager.unbond({ value: amount });
sdk.pallets.staking.manager.nominate({ targets: [validator1, validator2] });
sdk.pallets.staking.manager.chill();
sdk.pallets.staking.manager.payoutStakers({ validatorStash, era });

import { DemocracyManager, Conviction } from "@selendrajs/sdk";

// Queries
const referendum = await sdk.pallets.democracy.queries.referendumInfoOf(index);
const proposals = await sdk.pallets.democracy.queries.publicProps();
const voting = await sdk.pallets.democracy.queries.votingOf(address);

// Transactions
sdk.pallets.democracy.manager.propose({ proposalHash, value });
sdk.pallets.democracy.manager.vote({ refIndex, vote });
sdk.pallets.democracy.manager.delegate({
  to,
  conviction: Conviction.Locked1x,
  balance,
});
sdk.pallets.democracy.manager.removeVote({ index });

import { NominationPoolsManager } from "@selendrajs/sdk";

// Queries
const pool = await sdk.pallets.nominationPools.queries.bondedPools(poolId);
const member = await sdk.pallets.nominationPools.queries.poolMembers(address);
const metadata = await sdk.pallets.nominationPools.queries.metadata(poolId);

// Transactions
sdk.pallets.nominationPools.manager.join({ amount, poolId });
sdk.pallets.nominationPools.manager.bondExtra({
  extra: { FreeBalance: amount },
});
sdk.pallets.nominationPools.manager.claimPayout();
sdk.pallets.nominationPools.manager.unbond({ memberAccount, unbondingPoints });
sdk.pallets.nominationPools.manager.withdrawUnbonded({
  memberAccount,
  numSlashingSpans,
});

import { EvmManager } from "@selendrajs/sdk";

// Queries
const account = await sdk.pallets.evm.queries.accountBasic(evmAddress);
const code = await sdk.pallets.evm.queries.accountCodes(contractAddress);
const storage = await sdk.pallets.evm.queries.accountStorages(address, slot);

// Deploy contract (CREATE)
sdk.pallets.evm.manager.create({
  source: evmAddress,
  init: bytecode,
  value: 0n,
  gasLimit: 1000000n,
  maxFeePerGas: 1000000000n,
});

// Call contract
sdk.pallets.evm.manager.call({
  source: evmAddress,
  target: contractAddress,
  input: encodedData,
  value: 0n,
  gasLimit: 100000n,
  maxFeePerGas: 1000000000n,
});

import {
  UnifiedAccountsManager,
  calculateDefaultEvmAddress,
  calculateDefaultSubstrateAddress,
  isValidSubstrateAddress,
  isValidEvmAddress,
} from "@selendrajs/sdk";

// Utility functions
const evmAddr = calculateDefaultEvmAddress(substrateAddress);
const subAddr = calculateDefaultSubstrateAddress(evmAddress);

// Validate addresses
const isSubstrate = isValidSubstrateAddress(address);
const isEvm = isValidEvmAddress(address);

// Using UnifiedAccountsManager
const manager = new UnifiedAccountsManager(api);

// Get mapping info
const evmMapping = await manager.getEvmAddressForSubstrate(substrateAddress);
const substrateMapping = await manager.getSubstrateAddressForEvm(evmAddress);

// Claim default EVM address
const claimTx = manager.claimDefaultEvmAddress();
await claimTx.signAndSend(signer);

import { SelendraWallet, WalletUtils } from "@selendrajs/sdk";

// Create wallet from mnemonic
const wallet = SelendraWallet.fromMnemonic(mnemonic);

// Create wallet from private key
const wallet = SelendraWallet.fromPrivateKey(privateKey);

// Generate new wallet
const wallet = SelendraWallet.generate();

// Get addresses
const substrateAddress = wallet.substrateAddress;
const evmAddress = wallet.evmAddress;

// Sign transactions
const signature = await wallet.sign(message);

import { configureLogger, suppressNodeWarnings } from "@selendrajs/sdk";

// Suppress Node.js warnings (e.g., punycode deprecation)
suppressNodeWarnings();

// Configure logger
configureLogger({
  level: "info", // 'debug' | 'info' | 'warn' | 'error' | 'silent'
  prefix: "MyApp",
});

// Core types
import type { SDKConfig, ConnectionInfo, SDKEvents } from "@selendrajs/sdk";

// Pallet types
import type {
  AccountData,
  TransferParams,
  StakingLedger,
  ValidatorPrefs,
  ReferendumInfo,
  BondedPoolInfo,
} from "@selendrajs/sdk";

// Enums
import {
  ChainType,
  Network,
  RewardDestination,
  Conviction,
} from "@selendrajs/sdk";

try {
  const tx = sdk.pallets.balances.manager.transfer({ dest, value });
  const result = await tx.signAndSend(signer);

  // Check for errors in events
  result.events.forEach(({ event }) => {
    if (sdk.getApi().events.system.ExtrinsicFailed.is(event)) {
      const [error] = event.data;
      if (error.isModule) {
        const decoded = sdk.getApi().registry.findMetaError(error.asModule);
        throw new Error(`${decoded.section}.${decoded.name}: ${decoded.docs}`);
      }
    }
  });
} catch (error) {
  console.error("Transaction failed:", error);
}