import { Keypair } from "@rialo/ts-cdk";

const keypair = Keypair.generate();
console.log("Address:", keypair.publicKey.toString());

const message = new TextEncoder().encode("Hello Rialo");
const signature = keypair.sign(message);
const isValid = keypair.verify(message, signature);

import { createRialoClient, RIALO_DEVNET_CHAIN } from "@rialo/ts-cdk";

const client = createRialoClient({ chain: RIALO_DEVNET_CHAIN });

// Query blockchain
const balance = await client.getBalance(keypair.publicKey);
const height = await client.getBlockHeight();
const chainId = client.getChainIdentifier();

import { TransactionBuilder, transferInstruction } from "@rialo/ts-cdk";

// transaction valid from
const validFrom = BigInt(Date.now());

// Create transfer instruction
const transfer = transferInstruction(
  keypair.publicKey,
  recipientAddress,
  BigInt(1_000_000) // amount in kelvins
);

// Build and sign transaction
const tx = TransactionBuilder.create()
  .setPayer(keypair.publicKey)
  .setValidFrom(validFrom)
  .addInstruction(transfer)
  .build();

const signedTx = tx.sign(keypair);

// Send to network
const signature = await client.sendTransaction(signedTx.serialize());

import { Mnemonic } from "@rialo/ts-cdk";

// Generate 12-word mnemonic
const mnemonic = Mnemonic.generate();

// Derive keypair (default path: m/44'/756'/0'/0')
const keypair = await mnemonic.toKeypair();

// Use custom derivation path
const keypair2 = await mnemonic.toKeypair("m/44'/756'/0'/1'");

// Restore from existing mnemonic
const restored = Mnemonic.fromPhrase("your twelve word mnemonic phrase here...");
const restoredKeypair = await restored.toKeypair();

import { Keypair, PublicKey, Signature } from "@rialo/ts-cdk";

// Generate random keypair
const keypair = Keypair.generate();

// From existing secret key
const keypair = Keypair.fromSecretKey(secretBytes);

// Public key operations
const pubkey = PublicKey.fromString("base58string");
const address = pubkey.toString();
const bytes = pubkey.toBytes();

// Signature operations
const sig = Signature.fromBytes(signatureBytes);

// validFrom for transactions
const validFrom = BigInt(Date.now());

import { 
  TransactionBuilder, 
  transferInstruction,
  type Instruction,
  type AccountMeta 
} from "@rialo/ts-cdk";

// Simple transfer
const transfer = transferInstruction(from, to, amount);

// Custom instruction
const instruction: Instruction = {
  programId: PublicKey.fromString("YourProgramId"),
  accounts: [
    { pubkey: account1, isSigner: true, isWritable: true },
    { pubkey: account2, isSigner: false, isWritable: true },
  ],
  data: instructionData, // Uint8Array
};

// Build transaction
const tx = TransactionBuilder.create()
  .setPayer(payerPublicKey)
  .setValidFrom(validFrom)
  .addInstruction(instruction)
  .build();

// Single signer
const signed = tx.sign(keypair);

// Multi-sig
const partial = tx.partialSign(signer1);
const complete = partial.partialSign(signer2);

// Serialize for network
const bytes = signed.serialize();

import {
  createRialoClient,
  getDefaultRialoClientConfig,
  RIALO_DEVNET_CHAIN,
  RIALO_MAINNET_CHAIN
} from "@rialo/ts-cdk";

// Using preset chain configurations
const client = createRialoClient({ chain: RIALO_DEVNET_CHAIN });

// Using getDefaultRialoClientConfig helper
const config = getDefaultRialoClientConfig('mainnet');
const mainnetClient = createRialoClient({
  ...config,
  transport: {
    timeout: 30000,
    maxRetries: 3,
  }
});

// Query methods
const balance = await client.getBalance(publicKey);
const accountInfo = await client.getAccountInfo(publicKey);
const blockHeight = await client.getBlockHeight();
const chainId = client.getChainIdentifier();
const txInfo = await client.getTransaction(signature);

// Send transactions
const signature = await client.sendTransaction(serializedTx);

// Devnet only - request airdrop
await client.requestAirdrop(publicKey, BigInt(1_000_000_000));

import { KeypairSigner, type Signer } from "@rialo/ts-cdk";

// Keypair signer for local signing
const signer = new KeypairSigner(keypair);

// Use signer interface
const signature = await signer.sign(message);
const pubkey = signer.publicKey();

// Implement custom signer for hardware wallets, etc.
class CustomSigner implements Signer {
  async sign(message: Uint8Array): Promise<Signature> {
    // your signing logic
  }
  publicKey(): PublicKey {
    // return public key
  }
}

// Coin type 756 (R=7, L=5, O=6 on phone keypad)
const defaultPath = "m/44'/756'/0'/0'";

// Derive multiple accounts
const account0 = await mnemonic.toKeypair(0);
const account1 = await mnemonic.toKeypair(1);
const account2 = await mnemonic.toKeypair(2);

// Serialize signed transaction
const bytes = signedTx.serialize();

// Deserialize
import { Transaction } from "@rialo/ts-cdk";
const tx = Transaction.deserialize(bytes);

// Check signing status
const isSigned = tx.isSigned();
const sigCount = tx.getRequiredSignatureCount();

import { RialoError, RialoErrorType } from "@rialo/ts-cdk";

try {
  await client.sendTransaction(tx);
} catch (error) {
  if (error instanceof RialoError) {
    switch (error.type) {
      case RialoErrorType.NETWORK:
        // Retry logic
        break;
      case RialoErrorType.INVALID_INPUT:
        // Handle invalid input
        break;
      case RialoErrorType.RPC:
        // RPC specific error
        console.log(error.details); // RPC error details
        break;
    }
  }
}

// Generate keypair
const keypair = Keypair.generate();

// Use for signing
const signature = keypair.sign(message);

// Securely dispose when done
keypair.dispose(); // Zeros out private key in memory

import { 
  URL_MAINNET,
  URL_TESTNET,
  URL_DEVNET,
  URL_LOCALNET 
} from "@rialo/ts-cdk";

import {
  KELVIN_PER_RLO,        // 1_000_000_000
  SYSTEM_PROGRAM_ID,      // "11111111111111111111111111111111"
  PUBLIC_KEY_LENGTH,      // 32
  SECRET_KEY_LENGTH,      // 32
  SIGNATURE_LENGTH,       // 64
} from "@rialo/ts-cdk";