import { RepublicKey, RepublicClient, signTx, msgSend } from 'republic-sdk';

// Generate a new key
const key = RepublicKey.generate();
console.log('Address:', key.getAddress()); // rai1...

// Connect to testnet (with automatic retry)
const client = new RepublicClient();

// Query node status
const status = await client.getStatus();
console.log('Block height:', status.syncInfo.latestBlockHeight);

// Query balance
const balance = await client.getBalance(key.getAddress());
console.log('Balance:', balance.amount, balance.denom);

// Send tokens
const msg = msgSend(key.getAddress(), 'rai1recipient...', [
  { denom: 'arai', amount: '1000000000000000000' }, // 1 RAI
]);

const accountInfo = await client.getAccountInfoSafe(key.getAddress());
const txBytes = signTx(key, [msg], {
  accountNumber: accountInfo.accountNumber,
  sequence: accountInfo.sequence,
});

const result = await client.broadcastTx(txBytes);
console.log('TX Hash:', result.hash);

import { RepublicClient, msgWithdrawReward, msgVote } from 'republic-sdk';

const client = new RepublicClient();

// Query validators
const validators = await client.getValidators('BOND_STATUS_BONDED');
validators.forEach(v => console.log(v.moniker, v.tokens));

// Query delegations & rewards
const delegations = await client.getDelegations('rai1...');
const rewards = await client.getRewards('rai1...');

// Query governance proposals
const proposals = await client.getProposals();

// Build withdraw & vote messages
const withdrawMsg = msgWithdrawReward('rai1delegator', 'raivaloper1validator');
const voteMsg = msgVote('1', 'rai1voter', 1); // 1=Yes, 2=Abstain, 3=No, 4=NoWithVeto

import { RepublicKey, RepublicClient, JobManager } from 'republic-sdk';

const key = RepublicKey.fromPrivateKey('your_hex_private_key');
const client = new RepublicClient();
const jobs = new JobManager(client, key);

const { txResponse, jobId } = await jobs.submitAndWait({
  targetValidator: 'raivaloper1...',
  executionImage: 'republic-llm-inference:latest',
  verificationImage: 'example-verification:latest',
  uploadEndpoint: 'http://example.com/upload',
  fetchEndpoint: 'http://example.com/result',
  feeAmount: '1000000arai',
});

// Watch job status
for await (const status of jobs.watchJob(jobId!)) {
  console.log('Status:', status.status);
}

import { RepublicClient, RpcError, BroadcastError, TimeoutError } from 'republic-sdk';

try {
  const client = new RepublicClient();
  await client.broadcastTx(txBytes);
} catch (err) {
  if (err instanceof BroadcastError) {
    console.error(`TX failed (code ${err.code}): ${err.log}`);
  } else if (err instanceof RpcError) {
    console.error(`RPC error at ${err.endpoint}: ${err.message}`);
  } else if (err instanceof TimeoutError) {
    console.error('Operation timed out');
  }
}

const client = new RepublicClient(
  { rpc: 'https://rpc.republicai.io' },
  { retryOptions: { maxRetries: 5, baseDelayMs: 2000, maxDelayMs: 15000 } }
);

import { araiToRai, raiToArai } from 'republic-sdk';

araiToRai('1000000000000000000'); // '1'
araiToRai('1500000000000000000'); // '1.5'
raiToArai('2.5');                 // '2500000000000000000'