blue-js-sdk 2.0.0

package/examples/query-nodes.mjs

@@ -0,0 +1,94 @@
+/**
+ * query-nodes.mjs — Browse the Sentinel dVPN node network
+ *
+ * Query online nodes, filter by country/protocol/price, and display a formatted table.
+ * No wallet or tokens needed — this is read-only chain data.
+ *
+ * Usage:
+ *   node query-nodes.mjs
+ *   node query-nodes.mjs --country germany
+ *   node query-nodes.mjs --protocol wireguard
+ *   node query-nodes.mjs --country US --max-price 0.1
+ */
+
+import {
+  queryOnlineNodes,
+  filterNodes,
+  formatPriceP2P,
+  countryNameToCode,
+  getFlagEmoji,
+  groupNodesByCountry,
+} from 'sentinel-dvpn-sdk';
+
+// Parse CLI flags
+const args = process.argv.slice(2);
+const flag = (name) => args.includes(`--${name}`) ? args[args.indexOf(`--${name}`) + 1] : null;
+const countryArg = flag('country');
+const protocolArg = flag('protocol');       // 'wireguard' or 'v2ray'
+const maxPriceArg = flag('max-price');      // max P2P per GB (e.g. 0.1)
+
+async function main() {
+  // 1. Query online nodes (probes each node for status — takes 5-15s)
+  console.log('Scanning Sentinel network...');
+  const nodes = await queryOnlineNodes({ maxNodes: 100 });
+  console.log(`Found ${nodes.length} online nodes\n`);
+
+  // 2. Apply filters
+  let filtered = nodes;
+  if (countryArg || protocolArg || maxPriceArg) {
+    filtered = filterNodes(nodes, {
+      country: countryArg || undefined,
+      serviceType: protocolArg || undefined,
+      maxPriceDvpn: maxPriceArg ? parseFloat(maxPriceArg) : undefined,
+    });
+    console.log(`After filters: ${filtered.length} nodes\n`);
+  }
+
+  // 3. Display as table
+  console.log(
+    'Address'.padEnd(20),
+    'Country'.padEnd(16),
+    'Proto'.padEnd(6),
+    'Price/GB'.padEnd(12),
+    'Price/Hr'.padEnd(12),
+    'Peers'.padEnd(6),
+    'Score',
+  );
+  console.log('-'.repeat(90));
+
+  for (const node of filtered.slice(0, 30)) {
+    const code = countryNameToCode(node.country);
+    const emoji = code ? getFlagEmoji(code) : '  ';
+    const gbPrice = node.gigabytePrices?.find(p => p.denom === 'udvpn');
+    const hrPrice = node.hourlyPrices?.find(p => p.denom === 'udvpn');
+
+    console.log(
+      node.address.slice(0, 18).padEnd(20),
+      `${emoji} ${(node.country || '?').slice(0, 12)}`.padEnd(16),
+      (node.serviceType === 'wireguard' ? 'WG' : 'V2').padEnd(6),
+      (gbPrice ? `${formatPriceP2P(gbPrice.quote_value || gbPrice.base_value)} P2P` : 'N/A').padEnd(12),
+      (hrPrice ? `${formatPriceP2P(hrPrice.quote_value || hrPrice.base_value)} P2P` : 'N/A').padEnd(12),
+      String(node.peers || 0).padEnd(6),
+      String(node.qualityScore ?? '?'),
+    );
+  }
+
+  // 4. Country summary
+  console.log('\n--- Nodes by Country ---');
+  const groups = groupNodesByCountry(
+    filtered.map((n) => ({
+      ...n,
+      countryCode: countryNameToCode(n.country),
+      flagEmoji: getFlagEmoji(countryNameToCode(n.country) || ''),
+      online: true,
+    })),
+  );
+  for (const g of groups.slice(0, 15)) {
+    console.log(`  ${g.flagEmoji || '  '} ${(g.country || '?').padEnd(20)} ${g.onlineCount} nodes`);
+  }
+}
+
+main().catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/examples/wallet-basics.mjs

@@ -0,0 +1,61 @@
+/**
+ * wallet-basics.mjs — Create a Sentinel wallet and check balance
+ *
+ * Demonstrates wallet generation, import from mnemonic, and balance queries.
+ * The Sentinel chain uses 'sent' prefix addresses and 'udvpn' (micro P2P) denomination.
+ * 1 P2P = 1,000,000 udvpn.
+ *
+ * Usage:
+ *   node wallet-basics.mjs                     # Generate new wallet
+ *   MNEMONIC="word1 word2 ..." node wallet-basics.mjs  # Import existing wallet
+ */
+
+import {
+  generateWallet,
+  createWallet,
+  createClient,
+  getBalance,
+  formatP2P,
+  isMnemonicValid,
+  DENOM,
+  CHAIN_ID,
+} from 'sentinel-dvpn-sdk';
+
+async function main() {
+  console.log(`Chain: ${CHAIN_ID} | Denom: ${DENOM}\n`);
+
+  if (process.env.MNEMONIC) {
+    // --- Import existing wallet ---
+    const mnemonic = process.env.MNEMONIC;
+
+    if (!isMnemonicValid(mnemonic)) {
+      console.error('Invalid mnemonic. Must be 12 or 24 BIP39 words.');
+      process.exit(1);
+    }
+
+    const { account } = await createWallet(mnemonic);
+    console.log('Imported wallet:');
+    console.log(`  Address: ${account.address}`);
+
+    // Query on-chain balance
+    const client = await createClient(mnemonic);
+    const balance = await getBalance(client, account.address);
+    console.log(`  Balance: ${formatP2P(balance.udvpn)} (${balance.udvpn} udvpn)`);
+  } else {
+    // --- Generate new wallet ---
+    console.log('No MNEMONIC set — generating a new wallet.\n');
+
+    const { mnemonic, account } = await generateWallet();
+    console.log('New wallet generated:');
+    console.log(`  Address:  ${account.address}`);
+    console.log(`  Mnemonic: ${mnemonic}`);
+    console.log(`  Balance:  ${formatP2P(0)} (new wallet, unfunded)`);
+    console.log('\nSave your mnemonic securely. Fund this address with P2P tokens to use dVPN.');
+    console.log('You can get P2P tokens from exchanges or the Sentinel community.');
+  }
+}
+
+main().catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/generated/amino/amino.ts

@@ -0,0 +1,9 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v7.34.0
+// source: amino/amino.proto
+
+/* eslint-disable */
+
+export const protobufPackage = "amino";

package/generated/cosmos/base/v1beta1/coin.ts

@@ -0,0 +1,365 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v7.34.0
+// source: cosmos/base/v1beta1/coin.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { messageTypeRegistry } from "../../../typeRegistry";
+
+export const protobufPackage = "cosmos.base.v1beta1";
+
+/**
+ * Coin defines a token with a denomination and an amount.
+ *
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface Coin {
+  $type: "cosmos.base.v1beta1.Coin";
+  denom: string;
+  amount: string;
+}
+
+/**
+ * DecCoin defines a token with a denomination and a decimal amount.
+ *
+ * NOTE: The amount field is a Dec which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface DecCoin {
+  $type: "cosmos.base.v1beta1.DecCoin";
+  denom: string;
+  amount: string;
+}
+
+/**
+ * IntProto defines a Protobuf wrapper around an Int object.
+ * Deprecated: Prefer to use math.Int directly. It supports binary Marshal and Unmarshal.
+ */
+export interface IntProto {
+  $type: "cosmos.base.v1beta1.IntProto";
+  int: string;
+}
+
+/**
+ * DecProto defines a Protobuf wrapper around a Dec object.
+ * Deprecated: Prefer to use math.LegacyDec directly. It supports binary Marshal and Unmarshal.
+ */
+export interface DecProto {
+  $type: "cosmos.base.v1beta1.DecProto";
+  dec: string;
+}
+
+function createBaseCoin(): Coin {
+  return { $type: "cosmos.base.v1beta1.Coin", denom: "", amount: "" };
+}
+
+export const Coin: MessageFns<Coin, "cosmos.base.v1beta1.Coin"> = {
+  $type: "cosmos.base.v1beta1.Coin" as const,
+
+  encode(message: Coin, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+    if (message.amount !== "") {
+      writer.uint32(18).string(message.amount);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Coin {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCoin();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.denom = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.amount = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Coin {
+    return {
+      $type: Coin.$type,
+      denom: isSet(object.denom) ? globalThis.String(object.denom) : "",
+      amount: isSet(object.amount) ? globalThis.String(object.amount) : "",
+    };
+  },
+
+  toJSON(message: Coin): unknown {
+    const obj: any = {};
+    if (message.denom !== "") {
+      obj.denom = message.denom;
+    }
+    if (message.amount !== "") {
+      obj.amount = message.amount;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Coin>, I>>(base?: I): Coin {
+    return Coin.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Coin>, I>>(object: I): Coin {
+    const message = createBaseCoin();
+    message.denom = object.denom ?? "";
+    message.amount = object.amount ?? "";
+    return message;
+  },
+};
+
+messageTypeRegistry.set(Coin.$type, Coin);
+
+function createBaseDecCoin(): DecCoin {
+  return { $type: "cosmos.base.v1beta1.DecCoin", denom: "", amount: "" };
+}
+
+export const DecCoin: MessageFns<DecCoin, "cosmos.base.v1beta1.DecCoin"> = {
+  $type: "cosmos.base.v1beta1.DecCoin" as const,
+
+  encode(message: DecCoin, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+    if (message.amount !== "") {
+      writer.uint32(18).string(message.amount);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DecCoin {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDecCoin();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.denom = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.amount = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DecCoin {
+    return {
+      $type: DecCoin.$type,
+      denom: isSet(object.denom) ? globalThis.String(object.denom) : "",
+      amount: isSet(object.amount) ? globalThis.String(object.amount) : "",
+    };
+  },
+
+  toJSON(message: DecCoin): unknown {
+    const obj: any = {};
+    if (message.denom !== "") {
+      obj.denom = message.denom;
+    }
+    if (message.amount !== "") {
+      obj.amount = message.amount;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DecCoin>, I>>(base?: I): DecCoin {
+    return DecCoin.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DecCoin>, I>>(object: I): DecCoin {
+    const message = createBaseDecCoin();
+    message.denom = object.denom ?? "";
+    message.amount = object.amount ?? "";
+    return message;
+  },
+};
+
+messageTypeRegistry.set(DecCoin.$type, DecCoin);
+
+function createBaseIntProto(): IntProto {
+  return { $type: "cosmos.base.v1beta1.IntProto", int: "" };
+}
+
+export const IntProto: MessageFns<IntProto, "cosmos.base.v1beta1.IntProto"> = {
+  $type: "cosmos.base.v1beta1.IntProto" as const,
+
+  encode(message: IntProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.int !== "") {
+      writer.uint32(10).string(message.int);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): IntProto {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIntProto();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.int = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): IntProto {
+    return { $type: IntProto.$type, int: isSet(object.int) ? globalThis.String(object.int) : "" };
+  },
+
+  toJSON(message: IntProto): unknown {
+    const obj: any = {};
+    if (message.int !== "") {
+      obj.int = message.int;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<IntProto>, I>>(base?: I): IntProto {
+    return IntProto.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<IntProto>, I>>(object: I): IntProto {
+    const message = createBaseIntProto();
+    message.int = object.int ?? "";
+    return message;
+  },
+};
+
+messageTypeRegistry.set(IntProto.$type, IntProto);
+
+function createBaseDecProto(): DecProto {
+  return { $type: "cosmos.base.v1beta1.DecProto", dec: "" };
+}
+
+export const DecProto: MessageFns<DecProto, "cosmos.base.v1beta1.DecProto"> = {
+  $type: "cosmos.base.v1beta1.DecProto" as const,
+
+  encode(message: DecProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.dec !== "") {
+      writer.uint32(10).string(message.dec);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DecProto {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDecProto();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.dec = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DecProto {
+    return { $type: DecProto.$type, dec: isSet(object.dec) ? globalThis.String(object.dec) : "" };
+  },
+
+  toJSON(message: DecProto): unknown {
+    const obj: any = {};
+    if (message.dec !== "") {
+      obj.dec = message.dec;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DecProto>, I>>(base?: I): DecProto {
+    return DecProto.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DecProto>, I>>(object: I): DecProto {
+    const message = createBaseDecProto();
+    message.dec = object.dec ?? "";
+    return message;
+  },
+};
+
+messageTypeRegistry.set(DecProto.$type, DecProto);
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in Exclude<keyof T, "$type">]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P> | "$type">]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T, V extends string> {
+  readonly $type: V;
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}