@rougechain/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,441 @@
+interface WalletKeys {
+    publicKey: string;
+    privateKey: string;
+}
+interface ApiResponse<T = unknown> {
+    success: boolean;
+    error?: string;
+    data?: T;
+}
+type TransactionType = "transfer" | "create_token" | "swap" | "create_pool" | "add_liquidity" | "remove_liquidity" | "stake" | "unstake" | "faucet" | "nft_create_collection" | "nft_mint" | "nft_batch_mint" | "nft_transfer" | "nft_burn" | "nft_lock" | "nft_freeze_collection";
+interface TransactionPayload {
+    type: TransactionType;
+    from: string;
+    to?: string;
+    amount?: number;
+    fee?: number;
+    token?: string;
+    timestamp: number;
+    nonce: string;
+    token_name?: string;
+    token_symbol?: string;
+    initial_supply?: number;
+    token_in?: string;
+    token_out?: string;
+    amount_in?: number;
+    min_amount_out?: number;
+    pool_id?: string;
+    token_a?: string;
+    token_b?: string;
+    amount_a?: number;
+    amount_b?: number;
+    lp_amount?: number;
+    symbol?: string;
+    name?: string;
+    collectionId?: string;
+    description?: string;
+    image?: string;
+    maxSupply?: number;
+    royaltyBps?: number;
+    tokenId?: number;
+    metadataUri?: string;
+    attributes?: unknown;
+    locked?: boolean;
+    frozen?: boolean;
+    salePrice?: number;
+    names?: string[];
+    uris?: string[];
+    batchAttributes?: unknown[];
+}
+interface SignedTransaction {
+    payload: TransactionPayload;
+    signature: string;
+    public_key: string;
+}
+interface BlockHeader {
+    version: number;
+    chain_id: string;
+    height: number;
+    time: number;
+    prev_hash: string;
+    tx_hash: string;
+    proposer_pub_key: string;
+}
+interface Transaction {
+    version: number;
+    tx_type: string;
+    from_pub_key: string;
+    target_pub_key?: string | null;
+    amount: number;
+    fee: number;
+    sig: string;
+    token_name?: string | null;
+    token_symbol?: string | null;
+    token_decimals?: number | null;
+    token_total_supply?: number | null;
+    pool_id?: string | null;
+    token_a_symbol?: string | null;
+    token_b_symbol?: string | null;
+    amount_a?: number | null;
+    amount_b?: number | null;
+    min_amount_out?: number | null;
+    swap_path?: string[] | null;
+    lp_amount?: number | null;
+    faucet?: boolean;
+    signed_payload?: string | null;
+}
+interface Block {
+    version: number;
+    header: BlockHeader;
+    txs: Transaction[];
+    proposer_sig: string;
+    hash: string;
+}
+interface NodeStats {
+    height: number;
+    peers: number;
+    network_height: number;
+    mining: boolean;
+    total_fees: number;
+    last_block_fees: number;
+    finalized_height: number;
+    ws_clients: number;
+}
+interface TokenMetadata {
+    symbol: string;
+    name: string;
+    creator: string;
+    image?: string;
+    description?: string;
+    website?: string;
+    twitter?: string;
+    discord?: string;
+    created_at: number;
+    updated_at: number;
+}
+interface TokenHolder {
+    address: string;
+    balance: number;
+}
+interface BalanceResponse {
+    balance: number;
+    token_balances: Record<string, number>;
+    lp_balances: Record<string, number>;
+}
+interface LiquidityPool {
+    pool_id: string;
+    token_a_symbol: string;
+    token_b_symbol: string;
+    reserve_a: number;
+    reserve_b: number;
+    total_lp: number;
+    fee_rate: number;
+    created_at: number;
+}
+interface SwapQuote {
+    amount_out: number;
+    price_impact: number;
+    path: string[];
+}
+interface PoolEvent {
+    event_type: string;
+    pool_id: string;
+    actor: string;
+    token_a_amount?: number;
+    token_b_amount?: number;
+    lp_amount?: number;
+    timestamp: number;
+}
+interface PoolStats {
+    pool_id: string;
+    volume_24h: number;
+    trades_24h: number;
+    tvl: number;
+}
+interface NftCollection {
+    collection_id: string;
+    symbol: string;
+    name: string;
+    creator: string;
+    description?: string;
+    image?: string;
+    max_supply?: number;
+    minted: number;
+    royalty_bps: number;
+    royalty_recipient: string;
+    frozen: boolean;
+    created_at: number;
+}
+interface NftToken {
+    collection_id: string;
+    token_id: number;
+    owner: string;
+    creator: string;
+    name: string;
+    metadata_uri?: string;
+    attributes?: unknown;
+    locked: boolean;
+    minted_at: number;
+    transferred_at: number;
+}
+interface Validator {
+    public_key: string;
+    stake: number;
+    status: string;
+    jailed_until: number;
+    uptime: number;
+}
+interface BridgeConfig {
+    enabled: boolean;
+    custodyAddress?: string;
+    chainId: number;
+}
+interface BridgeWithdrawal {
+    tx_id: string;
+    from_pub_key: string;
+    evm_address: string;
+    amount_units: number;
+    status: string;
+    created_at: number;
+}
+interface TransferParams {
+    to: string;
+    amount: number;
+    fee?: number;
+    token?: string;
+}
+interface CreateTokenParams {
+    name: string;
+    symbol: string;
+    totalSupply: number;
+    fee?: number;
+}
+interface SwapParams {
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: number;
+    minAmountOut: number;
+}
+interface CreatePoolParams {
+    tokenA: string;
+    tokenB: string;
+    amountA: number;
+    amountB: number;
+}
+interface AddLiquidityParams {
+    poolId: string;
+    amountA: number;
+    amountB: number;
+}
+interface RemoveLiquidityParams {
+    poolId: string;
+    lpAmount: number;
+}
+interface StakeParams {
+    amount: number;
+    fee?: number;
+}
+interface CreateNftCollectionParams {
+    symbol: string;
+    name: string;
+    maxSupply?: number;
+    royaltyBps?: number;
+    image?: string;
+    description?: string;
+}
+interface MintNftParams {
+    collectionId: string;
+    name: string;
+    metadataUri?: string;
+    attributes?: unknown;
+}
+interface BatchMintNftParams {
+    collectionId: string;
+    names: string[];
+    uris?: string[];
+    batchAttributes?: unknown[];
+}
+interface TransferNftParams {
+    collectionId: string;
+    tokenId: number;
+    to: string;
+    salePrice?: number;
+}
+interface BurnNftParams {
+    collectionId: string;
+    tokenId: number;
+}
+interface LockNftParams {
+    collectionId: string;
+    tokenId: number;
+    locked: boolean;
+}
+interface FreezeCollectionParams {
+    collectionId: string;
+    frozen: boolean;
+}
+interface BridgeWithdrawParams {
+    amount: number;
+    evmAddress: string;
+    fee?: number;
+}
+interface SwapQuoteParams {
+    poolId: string;
+    tokenIn: string;
+    amountIn: number;
+}
+interface TokenMetadataUpdateParams {
+    symbol: string;
+    image?: string;
+    description?: string;
+    website?: string;
+    twitter?: string;
+    discord?: string;
+}
+
+type FetchFn = typeof globalThis.fetch;
+interface RougeChainOptions {
+    /** Custom fetch implementation (defaults to globalThis.fetch) */
+    fetch?: FetchFn;
+    /** Optional API key for authenticated endpoints */
+    apiKey?: string;
+}
+declare class RougeChain {
+    private readonly baseUrl;
+    private readonly fetchFn;
+    private readonly headers;
+    readonly nft: NftClient;
+    readonly dex: DexClient;
+    readonly bridge: BridgeClient;
+    constructor(baseUrl: string, options?: RougeChainOptions);
+    /** @internal */
+    get<T = unknown>(path: string): Promise<T>;
+    /** @internal */
+    post<T = unknown>(path: string, body: unknown): Promise<T>;
+    /** @internal */
+    submitTx(endpoint: string, signedTx: SignedTransaction): Promise<ApiResponse>;
+    getStats(): Promise<NodeStats>;
+    getHealth(): Promise<{
+        status: string;
+        chain_id: string;
+        height: number;
+    }>;
+    getBlocks(opts?: {
+        limit?: number;
+    }): Promise<Block[]>;
+    getBlocksSummary(range?: "1h" | "24h" | "7d"): Promise<unknown>;
+    getBalance(publicKey: string): Promise<BalanceResponse>;
+    getTokenBalance(publicKey: string, token: string): Promise<number>;
+    getTransactions(opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown>;
+    getTokens(): Promise<TokenMetadata[]>;
+    getTokenMetadata(symbol: string): Promise<TokenMetadata>;
+    getTokenHolders(symbol: string): Promise<TokenHolder[]>;
+    getTokenTransactions(symbol: string): Promise<unknown>;
+    getValidators(): Promise<Validator[]>;
+    getValidatorStats(): Promise<unknown>;
+    getFinality(): Promise<{
+        finalized_height: number;
+        tip_height: number;
+        total_stake: number;
+        finalized_stake: number;
+    }>;
+    getPeers(): Promise<string[]>;
+    getBurnedTokens(): Promise<{
+        burned: Record<string, number>;
+        total_xrge_burned: number;
+    }>;
+    transfer(wallet: WalletKeys, params: TransferParams): Promise<ApiResponse>;
+    createToken(wallet: WalletKeys, params: CreateTokenParams): Promise<ApiResponse>;
+    stake(wallet: WalletKeys, params: StakeParams): Promise<ApiResponse>;
+    unstake(wallet: WalletKeys, params: StakeParams): Promise<ApiResponse>;
+    faucet(wallet: WalletKeys): Promise<ApiResponse>;
+    burn(wallet: WalletKeys, amount: number, fee?: number, token?: string): Promise<ApiResponse>;
+    updateTokenMetadata(wallet: WalletKeys, params: TokenMetadataUpdateParams): Promise<ApiResponse>;
+}
+declare class NftClient {
+    private readonly rc;
+    constructor(rc: RougeChain);
+    getCollections(): Promise<NftCollection[]>;
+    getCollection(collectionId: string): Promise<NftCollection>;
+    getTokens(collectionId: string, opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        tokens: NftToken[];
+        total: number;
+    }>;
+    getToken(collectionId: string, tokenId: number): Promise<NftToken>;
+    getByOwner(pubkey: string): Promise<NftToken[]>;
+    createCollection(wallet: WalletKeys, params: CreateNftCollectionParams): Promise<ApiResponse>;
+    mint(wallet: WalletKeys, params: MintNftParams): Promise<ApiResponse>;
+    batchMint(wallet: WalletKeys, params: BatchMintNftParams): Promise<ApiResponse>;
+    transfer(wallet: WalletKeys, params: TransferNftParams): Promise<ApiResponse>;
+    burn(wallet: WalletKeys, params: BurnNftParams): Promise<ApiResponse>;
+    lock(wallet: WalletKeys, params: LockNftParams): Promise<ApiResponse>;
+    freezeCollection(wallet: WalletKeys, params: FreezeCollectionParams): Promise<ApiResponse>;
+}
+declare class DexClient {
+    private readonly rc;
+    constructor(rc: RougeChain);
+    getPools(): Promise<LiquidityPool[]>;
+    getPool(poolId: string): Promise<LiquidityPool>;
+    getPoolEvents(poolId: string): Promise<PoolEvent[]>;
+    getPoolPrices(poolId: string): Promise<unknown>;
+    getPoolStats(poolId: string): Promise<PoolStats>;
+    quote(params: SwapQuoteParams): Promise<SwapQuote>;
+    swap(wallet: WalletKeys, params: SwapParams): Promise<ApiResponse>;
+    createPool(wallet: WalletKeys, params: CreatePoolParams): Promise<ApiResponse>;
+    addLiquidity(wallet: WalletKeys, params: AddLiquidityParams): Promise<ApiResponse>;
+    removeLiquidity(wallet: WalletKeys, params: RemoveLiquidityParams): Promise<ApiResponse>;
+}
+declare class BridgeClient {
+    private readonly rc;
+    constructor(rc: RougeChain);
+    getConfig(): Promise<BridgeConfig>;
+    getWithdrawals(): Promise<BridgeWithdrawal[]>;
+    withdraw(wallet: WalletKeys, params: BridgeWithdrawParams): Promise<ApiResponse>;
+    claim(params: {
+        evmTxHash: string;
+        evmAddress: string;
+        evmSignature: string;
+        recipientPubkey: string;
+    }): Promise<ApiResponse>;
+}
+
+declare class Wallet implements WalletKeys {
+    readonly publicKey: string;
+    readonly privateKey: string;
+    private constructor();
+    /**
+     * Generate a new ML-DSA-65 keypair.
+     * Uses crypto.getRandomValues for secure randomness.
+     */
+    static generate(): Wallet;
+    /**
+     * Restore a wallet from existing hex-encoded keys.
+     */
+    static fromKeys(publicKey: string, privateKey: string): Wallet;
+    /**
+     * Export keys as a plain object (for serialization/storage).
+     */
+    toJSON(): WalletKeys;
+    /**
+     * Verify that the keypair is valid by signing and verifying a test message.
+     */
+    verify(): boolean;
+}
+
+declare const BURN_ADDRESS = "XRGE_BURN_0x000000000000000000000000000000000000000000000000000000000000DEAD";
+declare function serializePayload(payload: TransactionPayload): Uint8Array;
+declare function signTransaction(payload: TransactionPayload, privateKey: string, publicKey: string): SignedTransaction;
+declare function verifyTransaction(signedTx: SignedTransaction): boolean;
+declare function isBurnAddress(address: string): boolean;
+
+declare function hexToBytes(hex: string): Uint8Array;
+declare function bytesToHex(bytes: Uint8Array): string;
+declare function generateNonce(): string;
+
+export { type AddLiquidityParams, type ApiResponse, BURN_ADDRESS, type BalanceResponse, type BatchMintNftParams, type Block, type BlockHeader, type BridgeConfig, type BridgeWithdrawParams, type BridgeWithdrawal, type BurnNftParams, type CreateNftCollectionParams, type CreatePoolParams, type CreateTokenParams, type FreezeCollectionParams, type LiquidityPool, type LockNftParams, type MintNftParams, type NftCollection, type NftToken, type NodeStats, type PoolEvent, type PoolStats, type RemoveLiquidityParams, RougeChain, type RougeChainOptions, type SignedTransaction, type StakeParams, type SwapParams, type SwapQuote, type SwapQuoteParams, type TokenHolder, type TokenMetadata, type TokenMetadataUpdateParams, type Transaction, type TransactionPayload, type TransactionType, type TransferNftParams, type TransferParams, type Validator, Wallet, type WalletKeys, bytesToHex, generateNonce, hexToBytes, isBurnAddress, serializePayload, signTransaction, verifyTransaction };