@rougechain/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,664 @@
+'use strict';
+
+var mlDsa_js = require('@noble/post-quantum/ml-dsa.js');
+
+// src/signer.ts
+
+// src/utils.ts
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateNonce() {
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  return bytesToHex(bytes);
+}
+
+// src/signer.ts
+var BURN_ADDRESS = "XRGE_BURN_0x000000000000000000000000000000000000000000000000000000000000DEAD";
+function serializePayload(payload) {
+  const json = JSON.stringify(payload, Object.keys(payload).sort());
+  return new TextEncoder().encode(json);
+}
+function signTransaction(payload, privateKey, publicKey) {
+  const payloadBytes = serializePayload(payload);
+  const signature = mlDsa_js.ml_dsa65.sign(payloadBytes, hexToBytes(privateKey));
+  return {
+    payload,
+    signature: bytesToHex(signature),
+    public_key: publicKey
+  };
+}
+function verifyTransaction(signedTx) {
+  try {
+    const payloadBytes = serializePayload(signedTx.payload);
+    return mlDsa_js.ml_dsa65.verify(
+      hexToBytes(signedTx.signature),
+      payloadBytes,
+      hexToBytes(signedTx.public_key)
+    );
+  } catch {
+    return false;
+  }
+}
+function isBurnAddress(address) {
+  return address === BURN_ADDRESS;
+}
+function buildAndSign(wallet, payload) {
+  const full = {
+    ...payload,
+    from: wallet.publicKey,
+    timestamp: Date.now(),
+    nonce: generateNonce()
+  };
+  return signTransaction(full, wallet.privateKey, wallet.publicKey);
+}
+function createSignedTransfer(wallet, to, amount, fee = 1, token = "XRGE") {
+  return buildAndSign(wallet, { type: "transfer", to, amount, fee, token });
+}
+function createSignedTokenCreation(wallet, tokenName, tokenSymbol, initialSupply, fee = 10) {
+  return buildAndSign(wallet, {
+    type: "create_token",
+    token_name: tokenName,
+    token_symbol: tokenSymbol,
+    initial_supply: initialSupply,
+    fee
+  });
+}
+function createSignedSwap(wallet, tokenIn, tokenOut, amountIn, minAmountOut) {
+  return buildAndSign(wallet, {
+    type: "swap",
+    token_in: tokenIn,
+    token_out: tokenOut,
+    amount_in: amountIn,
+    min_amount_out: minAmountOut
+  });
+}
+function createSignedPoolCreation(wallet, tokenA, tokenB, amountA, amountB) {
+  return buildAndSign(wallet, {
+    type: "create_pool",
+    token_a: tokenA,
+    token_b: tokenB,
+    amount_a: amountA,
+    amount_b: amountB
+  });
+}
+function createSignedAddLiquidity(wallet, poolId, amountA, amountB) {
+  return buildAndSign(wallet, {
+    type: "add_liquidity",
+    pool_id: poolId,
+    amount_a: amountA,
+    amount_b: amountB
+  });
+}
+function createSignedRemoveLiquidity(wallet, poolId, lpAmount) {
+  return buildAndSign(wallet, {
+    type: "remove_liquidity",
+    pool_id: poolId,
+    lp_amount: lpAmount
+  });
+}
+function createSignedStake(wallet, amount, fee = 1) {
+  return buildAndSign(wallet, { type: "stake", amount, fee });
+}
+function createSignedUnstake(wallet, amount, fee = 1) {
+  return buildAndSign(wallet, { type: "unstake", amount, fee });
+}
+function createSignedFaucetRequest(wallet) {
+  return buildAndSign(wallet, { type: "faucet" });
+}
+function createSignedBurn(wallet, amount, fee = 1, token = "XRGE") {
+  return buildAndSign(wallet, {
+    type: "transfer",
+    to: BURN_ADDRESS,
+    amount,
+    fee,
+    token
+  });
+}
+function createSignedNftCreateCollection(wallet, symbol, name, opts = {}) {
+  return buildAndSign(wallet, {
+    type: "nft_create_collection",
+    symbol,
+    name,
+    fee: 50,
+    maxSupply: opts.maxSupply,
+    royaltyBps: opts.royaltyBps,
+    image: opts.image,
+    description: opts.description
+  });
+}
+function createSignedNftMint(wallet, collectionId, name, opts = {}) {
+  return buildAndSign(wallet, {
+    type: "nft_mint",
+    collectionId,
+    name,
+    fee: 5,
+    metadataUri: opts.metadataUri,
+    attributes: opts.attributes
+  });
+}
+function createSignedNftBatchMint(wallet, collectionId, names, opts = {}) {
+  return buildAndSign(wallet, {
+    type: "nft_batch_mint",
+    collectionId,
+    names,
+    fee: 5 * names.length,
+    uris: opts.uris,
+    batchAttributes: opts.batchAttributes
+  });
+}
+function createSignedNftTransfer(wallet, collectionId, tokenId, to, salePrice) {
+  return buildAndSign(wallet, {
+    type: "nft_transfer",
+    collectionId,
+    tokenId,
+    to,
+    fee: 1,
+    salePrice
+  });
+}
+function createSignedNftBurn(wallet, collectionId, tokenId) {
+  return buildAndSign(wallet, {
+    type: "nft_burn",
+    collectionId,
+    tokenId,
+    fee: 0.1
+  });
+}
+function createSignedNftLock(wallet, collectionId, tokenId, locked) {
+  return buildAndSign(wallet, {
+    type: "nft_lock",
+    collectionId,
+    tokenId,
+    locked,
+    fee: 0.1
+  });
+}
+function createSignedNftFreezeCollection(wallet, collectionId, frozen) {
+  return buildAndSign(wallet, {
+    type: "nft_freeze_collection",
+    collectionId,
+    frozen,
+    fee: 0.1
+  });
+}
+
+// src/client.ts
+var RougeChain = class {
+  constructor(baseUrl, options = {}) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.headers = { "Content-Type": "application/json" };
+    if (options.apiKey) {
+      this.headers["X-API-Key"] = options.apiKey;
+    }
+    this.nft = new NftClient(this);
+    this.dex = new DexClient(this);
+    this.bridge = new BridgeClient(this);
+  }
+  // ===== Internal helpers =====
+  /** @internal */
+  async get(path) {
+    const res = await this.fetchFn(`${this.baseUrl}${path}`, {
+      headers: this.headers
+    });
+    if (!res.ok) {
+      throw new Error(`GET ${path} failed: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  }
+  /** @internal */
+  async post(path, body) {
+    const res = await this.fetchFn(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(
+        `POST ${path} failed: ${res.status} ${res.statusText} ${text}`
+      );
+    }
+    return res.json();
+  }
+  /** @internal */
+  async submitTx(endpoint, signedTx) {
+    try {
+      const raw = await this.post(endpoint, signedTx);
+      const { success, error, ...rest } = raw;
+      return {
+        success,
+        error,
+        data: Object.keys(rest).length > 0 ? rest : void 0
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  // ===== Stats & Health =====
+  async getStats() {
+    return this.get("/stats");
+  }
+  async getHealth() {
+    return this.get("/health");
+  }
+  // ===== Blocks =====
+  async getBlocks(opts = {}) {
+    const q = opts.limit ? `?limit=${opts.limit}` : "";
+    const data = await this.get(`/blocks${q}`);
+    return data.blocks;
+  }
+  async getBlocksSummary(range = "24h") {
+    return this.get(`/blocks/summary?range=${range}`);
+  }
+  // ===== Balance =====
+  async getBalance(publicKey) {
+    return this.get(`/balance/${publicKey}`);
+  }
+  async getTokenBalance(publicKey, token) {
+    const data = await this.get(
+      `/balance/${publicKey}/${token}`
+    );
+    return data.balance;
+  }
+  // ===== Transactions =====
+  async getTransactions(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit) params.set("limit", String(opts.limit));
+    if (opts.offset) params.set("offset", String(opts.offset));
+    const q = params.toString();
+    return this.get(`/txs${q ? `?${q}` : ""}`);
+  }
+  // ===== Tokens =====
+  async getTokens() {
+    const data = await this.get(
+      "/tokens"
+    );
+    return data.tokens;
+  }
+  async getTokenMetadata(symbol) {
+    return this.get(`/token/${symbol}/metadata`);
+  }
+  async getTokenHolders(symbol) {
+    const data = await this.get(
+      `/token/${symbol}/holders`
+    );
+    return data.holders;
+  }
+  async getTokenTransactions(symbol) {
+    return this.get(`/token/${symbol}/transactions`);
+  }
+  // ===== Validators =====
+  async getValidators() {
+    const data = await this.get("/validators");
+    return data.validators;
+  }
+  async getValidatorStats() {
+    return this.get("/validators/stats");
+  }
+  async getFinality() {
+    return this.get("/finality");
+  }
+  // ===== Peers =====
+  async getPeers() {
+    const data = await this.get("/peers");
+    return data.peers;
+  }
+  // ===== Burned =====
+  async getBurnedTokens() {
+    return this.get("/burned");
+  }
+  // ===== Write operations =====
+  async transfer(wallet, params) {
+    const tx = createSignedTransfer(
+      wallet,
+      params.to,
+      params.amount,
+      params.fee,
+      params.token
+    );
+    return this.submitTx("/v2/transfer", tx);
+  }
+  async createToken(wallet, params) {
+    const tx = createSignedTokenCreation(
+      wallet,
+      params.name,
+      params.symbol,
+      params.totalSupply,
+      params.fee
+    );
+    return this.submitTx("/v2/token/create", tx);
+  }
+  async stake(wallet, params) {
+    const tx = createSignedStake(wallet, params.amount, params.fee);
+    return this.submitTx("/v2/stake", tx);
+  }
+  async unstake(wallet, params) {
+    const tx = createSignedUnstake(wallet, params.amount, params.fee);
+    return this.submitTx("/v2/unstake", tx);
+  }
+  async faucet(wallet) {
+    const tx = createSignedFaucetRequest(wallet);
+    return this.submitTx("/v2/faucet", tx);
+  }
+  async burn(wallet, amount, fee = 1, token = "XRGE") {
+    const tx = createSignedBurn(wallet, amount, fee, token);
+    return this.submitTx("/v2/transfer", tx);
+  }
+  async updateTokenMetadata(wallet, params) {
+    try {
+      const data = await this.post("/token/metadata/update", {
+        token_symbol: params.symbol,
+        from_public_key: wallet.publicKey,
+        from_private_key: wallet.privateKey,
+        image: params.image,
+        description: params.description,
+        website: params.website,
+        twitter: params.twitter,
+        discord: params.discord
+      });
+      return data;
+    } catch (e) {
+      return {
+        success: false,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+};
+var NftClient = class {
+  constructor(rc) {
+    this.rc = rc;
+  }
+  // Queries
+  async getCollections() {
+    const data = await this.rc.get(
+      "/nft/collections"
+    );
+    return data.collections;
+  }
+  async getCollection(collectionId) {
+    return this.rc.get(
+      `/nft/collection/${encodeURIComponent(collectionId)}`
+    );
+  }
+  async getTokens(collectionId, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+    if (opts.offset !== void 0) params.set("offset", String(opts.offset));
+    const q = params.toString();
+    return this.rc.get(
+      `/nft/collection/${encodeURIComponent(collectionId)}/tokens${q ? `?${q}` : ""}`
+    );
+  }
+  async getToken(collectionId, tokenId) {
+    return this.rc.get(
+      `/nft/token/${encodeURIComponent(collectionId)}/${tokenId}`
+    );
+  }
+  async getByOwner(pubkey) {
+    const data = await this.rc.get(
+      `/nft/owner/${encodeURIComponent(pubkey)}`
+    );
+    return data.nfts;
+  }
+  // Write operations
+  async createCollection(wallet, params) {
+    const tx = createSignedNftCreateCollection(wallet, params.symbol, params.name, {
+      maxSupply: params.maxSupply,
+      royaltyBps: params.royaltyBps,
+      image: params.image,
+      description: params.description
+    });
+    return this.rc.submitTx("/v2/nft/collection/create", tx);
+  }
+  async mint(wallet, params) {
+    const tx = createSignedNftMint(wallet, params.collectionId, params.name, {
+      metadataUri: params.metadataUri,
+      attributes: params.attributes
+    });
+    return this.rc.submitTx("/v2/nft/mint", tx);
+  }
+  async batchMint(wallet, params) {
+    const tx = createSignedNftBatchMint(
+      wallet,
+      params.collectionId,
+      params.names,
+      { uris: params.uris, batchAttributes: params.batchAttributes }
+    );
+    return this.rc.submitTx("/v2/nft/batch-mint", tx);
+  }
+  async transfer(wallet, params) {
+    const tx = createSignedNftTransfer(
+      wallet,
+      params.collectionId,
+      params.tokenId,
+      params.to,
+      params.salePrice
+    );
+    return this.rc.submitTx("/v2/nft/transfer", tx);
+  }
+  async burn(wallet, params) {
+    const tx = createSignedNftBurn(wallet, params.collectionId, params.tokenId);
+    return this.rc.submitTx("/v2/nft/burn", tx);
+  }
+  async lock(wallet, params) {
+    const tx = createSignedNftLock(
+      wallet,
+      params.collectionId,
+      params.tokenId,
+      params.locked
+    );
+    return this.rc.submitTx("/v2/nft/lock", tx);
+  }
+  async freezeCollection(wallet, params) {
+    const tx = createSignedNftFreezeCollection(
+      wallet,
+      params.collectionId,
+      params.frozen
+    );
+    return this.rc.submitTx("/v2/nft/freeze-collection", tx);
+  }
+};
+var DexClient = class {
+  constructor(rc) {
+    this.rc = rc;
+  }
+  // Queries
+  async getPools() {
+    const data = await this.rc.get("/pools");
+    return data.pools;
+  }
+  async getPool(poolId) {
+    return this.rc.get(`/pool/${poolId}`);
+  }
+  async getPoolEvents(poolId) {
+    const data = await this.rc.get(
+      `/pool/${poolId}/events`
+    );
+    return data.events;
+  }
+  async getPoolPrices(poolId) {
+    return this.rc.get(`/pool/${poolId}/prices`);
+  }
+  async getPoolStats(poolId) {
+    return this.rc.get(`/pool/${poolId}/stats`);
+  }
+  async quote(params) {
+    return this.rc.post("/swap/quote", {
+      pool_id: params.poolId,
+      token_in: params.tokenIn,
+      amount_in: params.amountIn
+    });
+  }
+  // Write operations
+  async swap(wallet, params) {
+    const tx = createSignedSwap(
+      wallet,
+      params.tokenIn,
+      params.tokenOut,
+      params.amountIn,
+      params.minAmountOut
+    );
+    return this.rc.submitTx("/v2/swap/execute", tx);
+  }
+  async createPool(wallet, params) {
+    const tx = createSignedPoolCreation(
+      wallet,
+      params.tokenA,
+      params.tokenB,
+      params.amountA,
+      params.amountB
+    );
+    return this.rc.submitTx("/v2/pool/create", tx);
+  }
+  async addLiquidity(wallet, params) {
+    const tx = createSignedAddLiquidity(
+      wallet,
+      params.poolId,
+      params.amountA,
+      params.amountB
+    );
+    return this.rc.submitTx("/v2/pool/add-liquidity", tx);
+  }
+  async removeLiquidity(wallet, params) {
+    const tx = createSignedRemoveLiquidity(wallet, params.poolId, params.lpAmount);
+    return this.rc.submitTx("/v2/pool/remove-liquidity", tx);
+  }
+};
+var BridgeClient = class {
+  constructor(rc) {
+    this.rc = rc;
+  }
+  async getConfig() {
+    try {
+      const data = await this.rc.get("/bridge/config");
+      return {
+        enabled: data.enabled === true,
+        custodyAddress: data.custodyAddress,
+        chainId: data.chainId ?? 84532
+      };
+    } catch {
+      return { enabled: false, chainId: 84532 };
+    }
+  }
+  async getWithdrawals() {
+    const data = await this.rc.get(
+      "/bridge/withdrawals"
+    );
+    return data.withdrawals;
+  }
+  async withdraw(wallet, params) {
+    try {
+      const evm = params.evmAddress.startsWith("0x") ? params.evmAddress : `0x${params.evmAddress}`;
+      const data = await this.rc.post(
+        "/bridge/withdraw",
+        {
+          fromPrivateKey: wallet.privateKey,
+          fromPublicKey: wallet.publicKey,
+          amountUnits: params.amount,
+          evmAddress: evm,
+          fee: params.fee
+        }
+      );
+      return {
+        success: data.success === true,
+        error: data.error,
+        data
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  async claim(params) {
+    try {
+      const data = await this.rc.post(
+        "/bridge/claim",
+        {
+          evmTxHash: params.evmTxHash.startsWith("0x") ? params.evmTxHash : `0x${params.evmTxHash}`,
+          evmAddress: params.evmAddress.startsWith("0x") ? params.evmAddress : `0x${params.evmAddress}`,
+          evmSignature: params.evmSignature,
+          recipientRougechainPubkey: params.recipientPubkey
+        }
+      );
+      return {
+        success: data.success === true,
+        error: data.error,
+        data
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+};
+var Wallet = class _Wallet {
+  constructor(publicKey, privateKey) {
+    this.publicKey = publicKey;
+    this.privateKey = privateKey;
+  }
+  /**
+   * Generate a new ML-DSA-65 keypair.
+   * Uses crypto.getRandomValues for secure randomness.
+   */
+  static generate() {
+    const keypair = mlDsa_js.ml_dsa65.keygen();
+    return new _Wallet(
+      bytesToHex(keypair.publicKey),
+      bytesToHex(keypair.secretKey)
+    );
+  }
+  /**
+   * Restore a wallet from existing hex-encoded keys.
+   */
+  static fromKeys(publicKey, privateKey) {
+    return new _Wallet(publicKey, privateKey);
+  }
+  /**
+   * Export keys as a plain object (for serialization/storage).
+   */
+  toJSON() {
+    return { publicKey: this.publicKey, privateKey: this.privateKey };
+  }
+  /**
+   * Verify that the keypair is valid by signing and verifying a test message.
+   */
+  verify() {
+    try {
+      const msg = new TextEncoder().encode("rougechain-verify");
+      const sig = mlDsa_js.ml_dsa65.sign(msg, hexToBytes(this.privateKey));
+      return mlDsa_js.ml_dsa65.verify(sig, msg, hexToBytes(this.publicKey));
+    } catch {
+      return false;
+    }
+  }
+};
+
+exports.BURN_ADDRESS = BURN_ADDRESS;
+exports.RougeChain = RougeChain;
+exports.Wallet = Wallet;
+exports.bytesToHex = bytesToHex;
+exports.generateNonce = generateNonce;
+exports.hexToBytes = hexToBytes;
+exports.isBurnAddress = isBurnAddress;
+exports.serializePayload = serializePayload;
+exports.signTransaction = signTransaction;
+exports.verifyTransaction = verifyTransaction;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map