qsn-blockchain-sdk

v0.0.4

Published

8 days ago

QSN Blockchain SDK - TypeScript/JavaScript SDK for Quantum Sharded Network

Downloads

354

0High
0Medium
0Low

qsn_blockchain

blockchain qsn quantum post-quantum cryptography ethereum web3 sdk

qsn-blockchain-sdk

TypeScript/JavaScript SDK for Quantum Sharded Network (QSN) blockchain with Post-Quantum Cryptography support.

NPM: https://www.npmjs.com/package/qsn-blockchain-sdk

Features

Post-Quantum Security: Hybrid Ed25519 + Dilithium3 (NIST Level 3) signatures
Complete API: Wallet, Token, NFT, DEX, Bridge, Staking, Contracts, Explorer
Server-Side Key Generation: Secure key generation via blockchain RPC
Cross-Chain Bridge: Ethereum, BSC, Polygon, Polkadot, Cosmos, TON
Full TypeScript Support: Complete type definitions

Installation

npm install qsn-blockchain-sdk

Quick Start

import { QSN, createClient, TESTNET_RPC } from 'qsn-blockchain-sdk';

// Connect to network
const qsn = QSN.connect(TESTNET_RPC);

// Create wallet (server-side key generation)
const wallet = await qsn.createWallet();
console.log('Address:', wallet.quantAddress);
console.log('Save keys:', wallet.export());

// Check balance
const balance = await wallet.getBalance();
console.log('Balance:', balance.balance, 'tQSN');

// Use modules
const tokenInfo = await qsn.token.getInfo('token_address');
const validators = await qsn.staking.getValidators();
const stats = await qsn.explorer.getNetworkStats();

Network Endpoints

| Network | RPC URL | Chain ID | |---------|---------|----------| | Testnet | https://node.qsnchain.com/testnet/ | 99991 | | Mainnet | https://node.qsnchain.com/qvm/mainnet/ | 1 |

import { TESTNET_RPC, MAINNET_RPC, CHAIN_IDS } from 'qsn-blockchain-sdk';

TESTNET_RPC;          // 'https://node.qsnchain.com/testnet/'
MAINNET_RPC;          // 'https://node.qsnchain.com/qvm/mainnet/'
CHAIN_IDS.TESTNET;    // 99991
CHAIN_IDS.MAINNET;    // 1

Wallet

QSN uses hybrid post-quantum cryptography: Ed25519 (classical) + Dilithium3 (quantum-resistant).

Create New Wallet

import { QSN, TESTNET_RPC } from 'qsn-blockchain-sdk';

const qsn = QSN.connect(TESTNET_RPC);

// Create wallet via RPC (server generates keys)
const wallet = await qsn.createWallet();

console.log('Quantum Address:', wallet.quantAddress);  // qsn1...
console.log('EVM Address:', wallet.evmAddress);        // 0x...
console.log('Public Key:', wallet.publicKey);

// IMPORTANT: Export and save keys securely!
const keys = wallet.export();
console.log('Save these keys:', JSON.stringify(keys));

Import Existing Wallet

import { QSN, Wallet, TESTNET_RPC } from 'qsn-blockchain-sdk';

// From saved keys
const savedKeys = {
  privateKey: '...',
  publicKey: '...',
  quantumPrivateKey: '...',
  quantumPublicKey: '...',
  quantAddress: 'qsn1...',
  evmAddress: '0x...'
};

// Method 1: Via QSN class
const qsn = QSN.connect(TESTNET_RPC);
const wallet = qsn.importWallet(savedKeys);

// Method 2: Direct import
const client = createClient(TESTNET_RPC);
const wallet2 = Wallet.fromKeys(savedKeys).connect(client);

Wallet Operations

// Get balance
const balance = await wallet.getBalance();
console.log('Balance:', balance.balance);
console.log('Decimal:', balance.balanceDecimal);
console.log('Nonce:', balance.nonce);

// Get nonce for signing
const nonce = await wallet.getNonce();

// Transfer QSN
const result = await wallet.transfer('qsn1recipient...', '1000000000000000000');
console.log('TX Hash:', result.txHash);

// Sign message (hybrid signatures)
const signature = await wallet.signHybrid('message', MessageType.TRANSFER);
console.log('Ed25519:', signature.signature);
console.log('Dilithium3:', signature.quantumSignature);

Token (QRC-20)

Complete QRC-20 token operations with quantum-resistant signatures.

Deploy Token

import { QSN, TESTNET_RPC } from 'qsn-blockchain-sdk';

const qsn = QSN.connect(TESTNET_RPC);
const wallet = await qsn.createWallet();

// Deploy new token
const result = await qsn.token.deploy({
  name: 'My Token',
  symbol: 'MTK',
  totalSupply: '1000000000000000000000000', // 1M tokens (18 decimals)
  decimals: 18,
  mintable: true,
  burnable: true,
  pausable: false,
  // Optional metadata
  icon: 'https://example.com/icon.png',
  website: 'https://mytoken.io',
  description: 'My awesome token',
  twitter: 'https://twitter.com/mytoken',
  telegram: 'https://t.me/mytoken',
  discord: 'https://discord.gg/mytoken',
  github: 'https://github.com/mytoken'
});

console.log('Token Address:', result.token.address);
console.log('TX Hash:', result.txHash);

Token Operations

// Get token info
const info = await qsn.token.getInfo('token_address');
console.log('Name:', info.name);
console.log('Symbol:', info.symbol);
console.log('Total Supply:', info.totalSupply);
console.log('Owner:', info.owner);

// Get balance
const balance = await qsn.token.balanceOf('token_address', 'holder_address');
// Or your own balance
const myBalance = await qsn.token.myBalance('token_address');

// Transfer tokens
const tx = await qsn.token.transfer('token_address', 'recipient_address', '1000000000000000000');
console.log('TX Hash:', tx.txHash);

// Mint tokens (owner only)
const mintTx = await qsn.token.mint('token_address', 'recipient_address', '5000000000000000000');

// Mint to self
const mintSelfTx = await qsn.token.mintToSelf('token_address', '5000000000000000000');

// Burn tokens
const burnTx = await qsn.token.burn('token_address', '1000000000000000000');

// Approve spender
const approveTx = await qsn.token.approve('token_address', 'spender_address', '10000000000000000000');

// Check allowance
const allowance = await qsn.token.allowance('token_address', 'owner', 'spender');

// Pause/Unpause (owner only, if pausable)
await qsn.token.pause('token_address');
await qsn.token.unpause('token_address');

Query Token Data

// Get all tokens
const tokens = await qsn.token.getAllTokens(100, 0);

// Get token holders
const holders = await qsn.token.getHolders('token_address', 100);

// Get transfer history
const transfers = await qsn.token.getTransfers('token_address', 50);

// Get tokens owned by address
const ownedTokens = await qsn.token.getOwnedTokens('address');

Format Utilities

import { Token } from 'qsn-blockchain-sdk';

// Format from wei to human-readable
const formatted = Token.formatAmount('1500000000000000000', 18); // "1.5"

// Parse from human-readable to wei
const wei = Token.parseAmount('1.5', 18); // "1500000000000000000"

NFT

Complete NFT collection deployment and management.

Deploy NFT Collection

const result = await qsn.nft.deployCollection({
  name: 'My NFT Collection',
  symbol: 'MNFT',
  description: 'Awesome NFT collection',
  baseUri: 'https://api.example.com/nft/',
  maxSupply: 10000,           // 0 = unlimited
  mintPrice: '100000000000000000', // 0.1 QSN
  royaltyBps: 500,            // 5% royalty
  royaltyRecipient: 'qsn1...' // Optional, defaults to deployer
});

console.log('Collection:', result.collection.address);

Mint NFT

// Mint to recipient
const mintResult = await qsn.nft.mint({
  collection: 'collection_address',
  to: 'recipient_address',
  tokenUri: 'https://api.example.com/nft/1.json',
  metadata: {
    name: 'NFT #1',
    description: 'First NFT',
    image: 'https://example.com/nft/1.png',
    attributes: [
      { trait_type: 'Rarity', value: 'Legendary' }
    ]
  }
});

console.log('Token ID:', mintResult.tokenId);

// Mint to self
const selfMint = await qsn.nft.mintToSelf(
  'collection_address',
  'https://api.example.com/nft/2.json',
  { name: 'NFT #2' }
);

NFT Operations

// Transfer NFT
const transfer = await qsn.nft.transfer('collection', 'tokenId', 'recipient');

// Approve operator
await qsn.nft.approve('collection', 'tokenId', 'operator');

// Approve all NFTs in collection
await qsn.nft.setApprovalForAll('collection', 'operator', true);

// Get NFT info
const nft = await qsn.nft.getNFT('collection', 'tokenId');
console.log('Owner:', nft.owner);
console.log('TokenURI:', nft.tokenUri);

// Get NFT metadata
const metadata = await qsn.nft.getMetadata('collection', 'tokenId');

// Get collection info
const collection = await qsn.nft.getCollection('collection_address');

// Get all NFTs in collection
const nfts = await qsn.nft.getCollectionNFTs('collection', 100, 0);

// Get my NFTs
const myNfts = await qsn.nft.getMyNFTs();

// Get NFTs by owner
const ownerNfts = await qsn.nft.getNFTsByOwner('owner_address');

// Get transfer history
const nftTransfers = await qsn.nft.getTransfers('collection', 'tokenId', 50);

// Update collection (owner only)
await qsn.nft.updateCollection('collection', {
  description: 'Updated description',
  royaltyBps: 750 // 7.5%
});

DEX (Decentralized Exchange)

Liquidity pools, swaps, and automated market maker operations.

Create Pool

const pool = await qsn.dex.createPool({
  tokenA: 'token_a_address',
  tokenB: 'token_b_address',
  fee: 30 // 0.3%
});

console.log('Pool Address:', pool.poolAddress);

Add Liquidity

const liquidity = await qsn.dex.addLiquidity({
  tokenA: 'token_a_address',
  tokenB: 'token_b_address',
  amountA: '1000000000000000000000', // 1000 tokens
  amountB: '500000000000000000000',  // 500 tokens
  amountAMin: '990000000000000000000', // 1% slippage
  amountBMin: '495000000000000000000',
  deadline: Math.floor(Date.now() / 1000) + 3600 // 1 hour
});

console.log('LP Tokens:', liquidity.liquidity);

Swap

// Exact input swap
const swap = await qsn.dex.swap({
  tokenIn: 'token_in_address',
  tokenOut: 'token_out_address',
  amountIn: '100000000000000000000', // 100 tokens
  amountOutMin: '45000000000000000000', // Minimum 45 tokens out
  deadline: Math.floor(Date.now() / 1000) + 1800 // 30 min
});

console.log('Amount Out:', swap.amountOut);

// Get quote first
const quote = await qsn.dex.getQuote('token_in', 'token_out', '100000000000000000000');
console.log('Expected:', quote.amountOut);
console.log('Price Impact:', quote.priceImpact);

Remove Liquidity

const remove = await qsn.dex.removeLiquidity({
  tokenA: 'token_a_address',
  tokenB: 'token_b_address',
  liquidity: '50000000000000000000', // LP tokens to remove
  amountAMin: '400000000000000000000',
  amountBMin: '200000000000000000000',
  deadline: Math.floor(Date.now() / 1000) + 3600
});

console.log('Token A received:', remove.amountA);
console.log('Token B received:', remove.amountB);

Query DEX Data

// Get pool info
const poolInfo = await qsn.dex.getPool('token_a', 'token_b');
console.log('Reserve A:', poolInfo.reserveA);
console.log('Reserve B:', poolInfo.reserveB);
console.log('Total Liquidity:', poolInfo.totalSupply);

// Get all pools
const pools = await qsn.dex.getPools(100, 0);

// Get my LP positions
const positions = await qsn.dex.getMyPositions();

// Get swap history
const swaps = await qsn.dex.getSwapHistory('pool_address', 50);

Bridge (Cross-Chain)

Bridge assets between QSN and other blockchains.

Supported Chains

import { BRIDGE_TIMES } from 'qsn-blockchain-sdk';

// Supported chains: ethereum, bsc, polygon, polkadot, cosmos, ton
// Bridge fee: 0.3%

console.log(BRIDGE_TIMES);
// {
//   ethereum: 15,   // ~15 minutes
//   bsc: 5,         // ~5 minutes
//   polygon: 3,     // ~3 minutes
//   polkadot: 10,   // ~10 minutes
//   cosmos: 8,      // ~8 minutes
//   ton: 2          // ~2 minutes
// }

Lock (QSN → External Chain)

// Lock tokens on QSN to bridge to Ethereum
const lock = await qsn.bridge.lock({
  destinationChain: 'ethereum',
  token: 'qsn_token_address', // Use 'native' for QSN coin
  amount: '1000000000000000000', // 1 token
  recipient: '0x...ethereum_address...'
});

console.log('Bridge TX:', lock.txHash);
console.log('Bridge ID:', lock.bridgeId);

Unlock (External Chain → QSN)

// Unlock tokens on QSN from external chain
const unlock = await qsn.bridge.unlock({
  sourceChain: 'ethereum',
  txHash: '0x...ethereum_tx_hash...',
  proof: '0x...merkle_proof...'
});

console.log('Unlocked:', unlock.amount);

Query Bridge Status

// Get bridge transaction status
const status = await qsn.bridge.getStatus('bridge_tx_hash');
console.log('Status:', status.status); // pending, completed, failed

// Get bridge history
const history = await qsn.bridge.getHistory(50);

// Get my bridge transactions
const myBridges = await qsn.bridge.getMyBridges();

// Get supported tokens for chain
const tokens = await qsn.bridge.getSupportedTokens('ethereum');

// Get bridge fees
const fees = await qsn.bridge.getFees('ethereum');
console.log('Fee:', fees.feePercent, '%');
console.log('Min:', fees.minAmount);
console.log('Max:', fees.maxAmount);

// Get locked amount on QSN
const locked = await qsn.bridge.getLockedAmount('token_address', 'ethereum');

Staking

Proof of Stake operations including delegation and rewards.

Stake Tokens

// Stake to validator
const stake = await qsn.staking.stake({
  validator: 'validator_address',
  amount: '10000000000000000000000' // 10,000 QSN
});

console.log('TX Hash:', stake.txHash);
console.log('Gas Cost:', stake.gasCost);

Delegate

// Delegate to validator
const delegate = await qsn.staking.delegate({
  validator: 'validator_address',
  amount: '5000000000000000000000'
});

Unstake

// Unstake from validator (enters unbonding period)
const unstake = await qsn.staking.unstake('validator_address', '5000000000000000000000');

// Unstake all
const unstakeAll = await qsn.staking.unstake('validator_address');

// Withdraw after unbonding period
const withdraw = await qsn.staking.withdrawUnstaked();

Rewards

// Get pending rewards
const pending = await qsn.staking.getPendingRewards();
console.log('Pending:', pending, 'QSN');

// Claim rewards (from all validators)
const claim = await qsn.staking.claimRewards();
console.log('Claimed:', claim.amount);

// Claim from specific validator
const claimSpecific = await qsn.staking.claimRewards('validator_address');

Query Staking Data

// Get network staking info
const info = await qsn.staking.getStakingInfo();
console.log('Total Staked:', info.totalStaked);
console.log('Validators:', info.validatorCount);

// Get current APY
const apy = await qsn.staking.getAPY();
console.log('APY:', apy, '%');

// Get epoch info
const epoch = await qsn.staking.getEpochInfo();
console.log('Epoch:', epoch.epoch);
console.log('Progress:', epoch.progress, '%');

// Get all validators
const validators = await qsn.staking.getValidators();

// Get active validators only
const active = await qsn.staking.getActiveValidators();

// Get validator info
const validator = await qsn.staking.getValidator('validator_address');
console.log('Commission:', validator.commission);
console.log('Total Stake:', validator.totalStake);
console.log('Uptime:', validator.uptime);

// Get my staking positions
const positions = await qsn.staking.getMyPositions();
for (const pos of positions) {
  console.log('Validator:', pos.validator);
  console.log('Staked:', pos.amount);
  console.log('Rewards:', pos.pendingRewards);
}

Become a Validator

// Register as validator (requires minimum stake)
const bond = await qsn.staking.validatorBond('100000000000000000000000'); // 100,000 QSN

// Register validator keys
await qsn.staking.validatorRegisterKeys({
  consensusKey: '0x...',
  networkKey: '0x...'
});

// Activate validator
await qsn.staking.validatorActivate();

// Get validator status
const status = await qsn.staking.validatorGetStatus();
console.log('Status:', status.status); // active, inactive, jailed, unbonding

Utilities

import { Staking } from 'qsn-blockchain-sdk';

// Calculate expected rewards
const expectedRewards = Staking.calculateRewards(
  '10000000000000000000000', // 10,000 QSN staked
  12, // 12% APY
  30  // 30 days
);
console.log('Expected in 30 days:', Staking.formatStake(expectedRewards));

Smart Contracts

Deploy and interact with smart contracts (Qubit and Solidity).

Compile Contract

// Compile Qubit contract
const qubitCompiled = await qsn.contract.compileQubit(`
  contract Token {
    mapping(address => uint256) balances;

    fn transfer(to: address, amount: uint256) {
      require(balances[msg.sender] >= amount);
      balances[msg.sender] -= amount;
      balances[to] += amount;
    }
  }
`);

console.log('Bytecode:', qubitCompiled.bytecode);
console.log('ABI:', qubitCompiled.abi);

// Compile Solidity contract
const solidityCompiled = await qsn.contract.compileSolidity(`
  // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.0;

  contract SimpleStorage {
    uint256 public value;

    function setValue(uint256 _value) external {
      value = _value;
    }
  }
`, 'SimpleStorage');

Deploy Contract

// Deploy compiled contract
const deployed = await qsn.contract.deploy({
  bytecode: qubitCompiled.bytecode,
  abi: qubitCompiled.abi,
  args: [], // Constructor arguments
  value: '0' // QSN to send with deployment
});

console.log('Contract Address:', deployed.address);
console.log('TX Hash:', deployed.txHash);
console.log('Gas Used:', deployed.gasUsed);

// Get contract instance
const contractInstance = await qsn.contract.at(deployed.address);

Call Contract Methods

// Get contract instance
const contractInstance = await qsn.contract.at('contract_address');

// Read-only call
const value = await contractInstance.call('getValue', []);
console.log('Current value:', value);

// State-changing transaction
const tx = await contractInstance.send('setValue', [42]);
console.log('TX Hash:', tx.txHash);

// Estimate gas
const gas = await contractInstance.estimateGas('setValue', [42]);
console.log('Estimated gas:', gas);

// Get events
const events = await contractInstance.getEvents('Transfer', 100);

Query Contract Data

// Get contract info
const info = await qsn.contract.getContractInfo('contract_address');
console.log('Owner:', info.owner);
console.log('Balance:', info.balance);
console.log('TX Count:', info.transactionCount);

// Get contract code
const code = await qsn.contract.getCode('contract_address');

// Verify contract
const verified = await qsn.contract.verify('contract_address', sourceCode);

Explorer

Query blockchain data, statistics, and analytics.

Network Stats

// Get network stats
const stats = await qsn.explorer.getNetworkStats();
console.log('Block Height:', stats.blockHeight);
console.log('Total TXs:', stats.totalTransactions);
console.log('TPS:', stats.tps);
console.log('Total Supply:', stats.totalSupply);

// Get TPS metrics
const tps = await qsn.explorer.getTpsMetrics();
console.log('Current TPS:', tps.current);
console.log('24h Average:', tps.average24h);
console.log('Peak:', tps.peak);

// Get gas stats
const gas = await qsn.explorer.getGasStats();

// Get holders stats
const holders = await qsn.explorer.getHoldersStats();
console.log('Total Holders:', holders.total);
console.log('Active 24h:', holders.active24h);

// Check node health
const health = await qsn.explorer.health();
console.log('Status:', health.status);

Blocks

// Get current block number
const blockNumber = await qsn.explorer.getBlockNumber();

// Get latest blocks
const blocks = await qsn.explorer.getBlocks(20, 0);

// Get specific block
const block = await qsn.explorer.getBlockByNumber(12345, true);
console.log('Hash:', block.hash);
console.log('TXs:', block.transactionsCount);
console.log('Miner:', block.miner);

Transactions

// Get recent transactions
const txs = await qsn.explorer.getTransactions(20, 0);

// Get transaction by hash
const tx = await qsn.explorer.getTransaction('tx_hash');
console.log('From:', tx.from);
console.log('To:', tx.to);
console.log('Value:', tx.value);

// Get transaction receipt
const receipt = await qsn.explorer.getReceipt('tx_hash');

// Get transactions by address
const addressTxs = await qsn.explorer.getTransactionsByAddress('address', 50);

// Get pending transactions
const pending = await qsn.explorer.getPendingTransactions();

Accounts

// Get account info
const account = await qsn.explorer.getAccountInfo('address');

// Get balance
const balance = await qsn.explorer.getBalance('address');
console.log('Balance:', balance.balance);
console.log('Nonce:', balance.nonce);

// Get address analytics
const analytics = await qsn.explorer.getAddressAnalytics('address');
console.log('TX Count:', analytics.transactionCount);
console.log('Token Transfers:', analytics.tokenTransferCount);

Market Data

// Get all coins
const coins = await qsn.explorer.getCoinTable();

// Get specific coin data
const qsnData = await qsn.explorer.getCoinMarketData('QSN');
console.log('Price:', qsnData.price);
console.log('Market Cap:', qsnData.marketCap);
console.log('Volume 24h:', qsnData.volume24h);

// Get coin price
const price = await qsn.explorer.getCoinPrice('QSN');

// Get price history
const history = await qsn.explorer.getCoinPriceHistory('QSN', 30);

// Get top movers
const movers = await qsn.explorer.getTopMovers(10);

// Get trending tokens
const trending = await qsn.explorer.getTrendingTokens(10);

// Get new tokens
const newTokens = await qsn.explorer.getNewTokens(10);

Network Info

// Get chain info
const chain = await qsn.explorer.getChainInfo();
console.log('Chain ID:', chain.chainId);
console.log('Name:', chain.name);
console.log('Symbol:', chain.symbol);

// Get shard info
const shard = await qsn.explorer.getShardInfo();

// Get VM type
const vmType = await qsn.explorer.getVmType();

// Get sync status
const sync = await qsn.explorer.getSyncStatus();
console.log('Syncing:', sync.syncing);
console.log('Current Block:', sync.currentBlock);

// Get peer count
const peers = await qsn.explorer.peerCount();

// Get node version
const version = await qsn.explorer.version();

Low-Level Client

Direct RPC access for advanced usage.

import { createClient, QsnClient, TESTNET_RPC } from 'qsn-blockchain-sdk';

// Simple client
const client = createClient(TESTNET_RPC);

// Configured client
const configuredClient = new QsnClient({
  endpoint: TESTNET_RPC,
  chainId: 99991,
  timeout: 30000,
  retry: {
    maxRetries: 5,
    baseDelayMs: 1000
  }
});

// Direct RPC calls
const blockNumber = await client.request('qsn_blockNumber', []);
const balance = await client.request('qsn_getBalance', ['address']);

// All standard Ethereum methods
const block = await client.getBlock('latest');
const tx = await client.getTransaction('tx_hash');
const code = await client.getCode('contract_address');

Cryptographic Details

QSN uses hybrid post-quantum cryptography for all operations:

Signature Scheme

| Algorithm | Type | Security Level | |-----------|------|----------------| | Ed25519 | Classical | 128-bit | | Dilithium3 | Post-Quantum | NIST Level 3 (192-bit) |

Hash Functions

| Operation | Hash Algorithm | |-----------|----------------| | TRANSFER | Keccak256 | | DEPLOY_TOKEN | Keccak256 | | DEPLOY_CONTRACT | Keccak256 | | TOKEN_TRANSFER | Keccak256 | | MINT_TOKEN | BLAKE3 | | BURN_TOKEN | BLAKE3 | | NFT_MINT | Keccak256 | | NFT_TRANSFER | Keccak256 |

Message Format

OPERATION:param1:param2:...:nonce:chainId

Example:

TRANSFER:qsn1sender...:qsn1recipient...:1000000000000000000:42:99991

TypeScript Types

import type {
  // Wallet
  WalletData,
  SignatureResult,
  BalanceInfo,

  // Token
  TokenInfo,
  TokenDeployParams,
  TokenDeployResult,
  TokenMintResult,
  TokenTransferResult,
  TokenHolder,

  // NFT
  NFTCollectionInfo,
  NFTInfo,
  NFTDeployParams,
  NFTMintParams,

  // DEX
  PoolInfo,
  SwapParams,
  SwapResult,
  LiquidityParams,
  LiquidityResult,

  // Bridge
  BridgeChain,
  BridgeLockParams,
  BridgeLockResult,
  BridgeStatus,

  // Staking
  StakingInfo,
  StakePosition,
  ValidatorInfo,
  StakeParams,
  DelegateParams,

  // Explorer
  NetworkStats,
  AccountAnalytics,
  CoinMarketData,
  BlockInfo,
  TransactionInfo,

  // Contract
  ContractDeployParams,
  ContractDeployResult,
  CompileResult,
} from 'qsn-blockchain-sdk';

Error Handling

import { RpcError } from 'qsn-blockchain-sdk';

try {
  const result = await qsn.token.transfer('token', 'recipient', 'amount');
} catch (error) {
  if (error instanceof RpcError) {
    console.log('RPC Error Code:', error.code);
    console.log('Message:', error.message);
  } else {
    console.log('Unknown error:', error);
  }
}

Complete Example

import { QSN, TESTNET_RPC, Token } from 'qsn-blockchain-sdk';

async function main() {
  // Connect to network
  const qsn = QSN.connect(TESTNET_RPC);

  // Create wallet
  console.log('Creating wallet...');
  const wallet = await qsn.createWallet();
  console.log('Address:', wallet.quantAddress);

  // Save keys (IMPORTANT!)
  const keys = wallet.export();
  console.log('Keys:', JSON.stringify(keys));

  // Check balance
  const balance = await wallet.getBalance();
  console.log('Balance:', balance.balanceDecimal, 'QSN');

  // Get network stats
  const stats = await qsn.explorer.getNetworkStats();
  console.log('Block Height:', stats.blockHeight);

  // Get validators
  const validators = await qsn.staking.getValidators();
  console.log('Validators:', validators.length);

  // If you have balance, deploy a token
  if (BigInt(balance.balance) > 0) {
    const token = await qsn.token.deploy({
      name: 'My Token',
      symbol: 'MTK',
      totalSupply: Token.parseAmount('1000000', 18),
      decimals: 18,
      mintable: true,
      burnable: true
    });
    console.log('Token deployed:', token.token.address);
  }
}

main().catch(console.error);

License

MIT

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

qsn-blockchain-sdk

Features

Installation

Quick Start

Network Endpoints

Wallet

Create New Wallet

Import Existing Wallet

Wallet Operations

Token (QRC-20)

Deploy Token

Token Operations

Query Token Data

Format Utilities

NFT

Deploy NFT Collection

Mint NFT

NFT Operations

DEX (Decentralized Exchange)

Create Pool

Add Liquidity

Swap

Remove Liquidity

Query DEX Data

Bridge (Cross-Chain)

Supported Chains

Lock (QSN → External Chain)

Unlock (External Chain → QSN)

Query Bridge Status

Staking

Stake Tokens

Delegate

Unstake

Rewards

Query Staking Data

Become a Validator

Utilities

Smart Contracts

Compile Contract

Deploy Contract

Call Contract Methods

Query Contract Data

Explorer

Network Stats

Blocks

Transactions

Accounts

Market Data

Network Info

Low-Level Client

Cryptographic Details

Signature Scheme

Hash Functions

Message Format

TypeScript Types

Error Handling

Complete Example

License

Links