Address Management

/**
 * Encode a public key or address to SS58 format
 * @param key - The public key or address to encode
 * @param ss58Format - Network prefix (default: generic Substrate)
 * @returns SS58-encoded address string
 */
function encodeAddress(key: string | Uint8Array, ss58Format?: number): string;

import { encodeAddress, sr25519PairFromSeed } from "@polkadot/util-crypto";

const seed = new Uint8Array(32); // Your seed
const pair = sr25519PairFromSeed(seed);

// Generic Substrate address (prefix 42)
const genericAddress = encodeAddress(pair.publicKey);

// Polkadot address (prefix 0)
const polkadotAddress = encodeAddress(pair.publicKey, 0);

// Kusama address (prefix 2)
const kusamaAddress = encodeAddress(pair.publicKey, 2);

/**
 * Decode an SS58 address to public key bytes
 * @param address - SS58 address string to decode
 * @param ignoreChecksum - Skip checksum validation (default: false)
 * @param prefix - Expected network prefix for validation
 * @returns Public key as Uint8Array (32 bytes)
 */
function decodeAddress(address: string, ignoreChecksum?: boolean, prefix?: number): Uint8Array;

import { decodeAddress } from "@polkadot/util-crypto";

const address = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY";
const publicKey = decodeAddress(address);
console.log(publicKey.length); // 32

/**
 * Check if an SS58 address is valid
 * @param address - Address string to validate
 * @param prefix - Expected network prefix for validation
 * @returns Tuple of [isValid, errorMessage]
 */
function checkAddress(address: string, prefix?: number): [boolean, string | null];

import { checkAddress } from "@polkadot/util-crypto";

const [isValid, error] = checkAddress("5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY");
if (isValid) {
  console.log("Valid address");
} else {
  console.log("Invalid address:", error);
}

/**
 * Compare two addresses for equality
 * @param a - First address
 * @param b - Second address
 * @returns true if addresses represent the same public key
 */
function addressEq(a: string, b: string): boolean;

/**
 * Check if string is a valid SS58 address
 * @param address - String to check
 * @param ignoreChecksum - Skip checksum validation
 * @param prefix - Expected network prefix
 * @returns true if valid address format
 */
function isAddress(address: string, ignoreChecksum?: boolean, prefix?: number): boolean;

/**
 * Validate SS58 address with detailed response
 * @param address - Address to validate
 * @param prefix - Expected network prefix
 * @returns Validation result with details
 */
function validateAddress(address: string, prefix?: number): boolean;

/**
 * Check SS58 address checksum validity
 * @param address - Address to check
 * @returns true if checksum is valid
 */
function checkAddressChecksum(address: string): boolean;

/**
 * Derive SS58 address from public key
 * @param publicKey - Public key bytes
 * @param prefix - Network prefix
 * @returns SS58 address string
 */
function deriveAddress(publicKey: Uint8Array, prefix?: number): string;

/**
 * Create multi-signature key and address
 * @param threshold - Minimum required signatures
 * @param signatories - Array of public keys or addresses
 * @param prefix - Network prefix
 * @returns Multi-signature public key
 */
function createKeyMulti(threshold: number, signatories: (Uint8Array | string)[], prefix?: number): Uint8Array;

/**
 * Encode multi-signature address
 * @param who - Threshold and signatories or multi-sig public key
 * @param prefix - Network prefix
 * @returns Multi-signature address
 */
function encodeMultiAddress(who: Uint8Array | [number, (Uint8Array | string)[]], prefix?: number): string;

/**
 * Create derived key from public key and chain code
 * @param publicKey - Parent public key
 * @param chainCode - Chain code for derivation
 * @param prefix - Network prefix
 * @returns Derived public key
 */
function createKeyDerived(publicKey: Uint8Array, chainCode: Uint8Array, prefix?: number): Uint8Array;

/**
 * Encode derived address
 * @param publicKey - Public key
 * @param chainCode - Chain code
 * @param prefix - Network prefix
 * @returns Derived address
 */
function encodeDerivedAddress(publicKey: Uint8Array, chainCode: Uint8Array, prefix?: number): string;

/**
 * Sort addresses array
 * @param addresses - Array of addresses to sort
 * @param prefix - Network prefix
 * @returns Sorted addresses array
 */
function sortAddresses(addresses: string[], prefix?: number): string[];

/**
 * Set global SS58 format (deprecated)
 * @param prefix - Default network prefix
 */
function setSS58Format(prefix: number): void;

/**
 * Convert SS58 address to EVM format
 * @param address - SS58 address
 * @returns EVM address bytes
 */
function addressToEvm(address: string): Uint8Array;

/**
 * Convert EVM address to SS58 format
 * @param evmAddress - EVM address bytes
 * @param prefix - SS58 network prefix
 * @param hashType - Hash algorithm to use
 * @returns SS58 address
 */
function evmToAddress(evmAddress: Uint8Array, prefix?: number, hashType?: 'blake2' | 'keccak'): string;