@sahyadrinet/web3.js 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,110 @@
+type Hash = Uint8Array;
+type PublicKey = Uint8Array;
+type SecretKey = Uint8Array;
+type Signature = Uint8Array;
+type Address = string;
+type TransactionId = string;
+interface KeyPair {
+    publicKey: PublicKey;
+    secretKey: SecretKey;
+}
+interface RpcConfig {
+    url?: string;
+    timeout?: number;
+}
+interface BalanceResult {
+    address: Address;
+    balance: string;
+    nonce: number;
+}
+interface SubmitTxResult {
+    transactionId: TransactionId;
+    accepted: boolean;
+}
+
+declare class DomainHasher {
+    private init;
+    constructor(domain: string);
+    hash(data: Uint8Array): Uint8Array;
+    clone(): DomainHasher;
+}
+declare const TxHash: DomainHasher;
+declare const TxID: DomainHasher;
+declare const TxSigningHash: DomainHasher;
+declare const BlockHash: DomainHasher;
+declare const MerkleHash: DomainHasher;
+declare function sha3(data: Uint8Array): Uint8Array;
+declare function shake256Bytes(data: Uint8Array, len: number): Uint8Array;
+declare function shake128Bytes(data: Uint8Array, len: number): Uint8Array;
+declare function shake256Digest(data: Uint8Array, outputLen: number): Uint8Array;
+
+declare function pubkeyToAddress(pk: Uint8Array, testnet?: boolean): string;
+declare function isValidAddress(addr: string, testnet?: boolean): boolean;
+declare function addressToScriptPubkey(addr: string): Uint8Array;
+
+declare function keypair(): {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+};
+declare function sign(secretKey: Uint8Array, message: Uint8Array): Uint8Array;
+declare function verify(publicKey: Uint8Array, signature: Uint8Array, message: Uint8Array): boolean;
+
+declare class Wallet {
+    private rpc;
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+    address: string;
+    balance: number;
+    nonce: number;
+    constructor(rpcUrl?: string);
+    connect(): Promise<void>;
+    create(): void;
+    getBalance(): Promise<number>;
+    send(to: string, amountKana: number): Promise<string>;
+}
+
+declare class RpcClient {
+    private url;
+    private ws;
+    private connected;
+    constructor(url?: string);
+    connect(): Promise<void>;
+    isConnected(): boolean;
+    call(method: string, params: any): Promise<any>;
+    getBalance(address: string): Promise<number>;
+    submitTransaction(tx: any): Promise<string>;
+}
+
+interface DidDocument {
+    id: string;
+    controller: string;
+    publicKeyHex: string;
+    created: number;
+    services: Array<{
+        type: string;
+        endpoint: string;
+    }>;
+}
+declare function createDid(address: string, publicKeyHex: string): DidDocument;
+declare function addService(doc: DidDocument, type: string, endpoint: string): DidDocument;
+
+declare class Storage {
+    private store;
+    set(key: string, value: any): void;
+    get<T>(key: string): T | null;
+    remove(key: string): void;
+    clear(): void;
+}
+
+interface AccountTransaction {
+    sender: string;
+    receiver: string;
+    amount: number;
+    fee: number;
+    nonce: number;
+    payload: string;
+    signature: string;
+}
+declare function createTransaction(sender: string, receiver: string, amountKana: number, nonce: number, publicKeyHex: string): AccountTransaction;
+
+export { type Address, type BalanceResult, BlockHash, DomainHasher, type Hash, type KeyPair, MerkleHash, type PublicKey, RpcClient, type RpcConfig, type SecretKey, type Signature, Storage, type SubmitTxResult, type TransactionId, TxHash, TxID, TxSigningHash, Wallet, addService, addressToScriptPubkey, createDid, createTransaction, isValidAddress, keypair, pubkeyToAddress, sha3, shake128Bytes, shake256Bytes, shake256Digest, sign, verify };

package/dist/index.js

@@ -0,0 +1,315 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BlockHash: () => BlockHash,
+  DomainHasher: () => DomainHasher,
+  MerkleHash: () => MerkleHash,
+  RpcClient: () => RpcClient,
+  Storage: () => Storage,
+  TxHash: () => TxHash,
+  TxID: () => TxID,
+  TxSigningHash: () => TxSigningHash,
+  Wallet: () => Wallet,
+  addService: () => addService,
+  addressToScriptPubkey: () => addressToScriptPubkey,
+  createDid: () => createDid,
+  createTransaction: () => createTransaction,
+  isValidAddress: () => isValidAddress,
+  keypair: () => keypair,
+  pubkeyToAddress: () => pubkeyToAddress,
+  sha3: () => sha3,
+  shake128Bytes: () => shake128Bytes,
+  shake256Bytes: () => shake256Bytes,
+  shake256Digest: () => shake256Digest,
+  sign: () => sign,
+  verify: () => verify
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/sha3.ts
+var import_sha3 = require("@noble/hashes/sha3");
+var DomainHasher = class _DomainHasher {
+  constructor(domain) {
+    this.init = new Uint8Array((0, import_sha3.sha3_256)(new TextEncoder().encode(domain)));
+  }
+  hash(data) {
+    const h = import_sha3.sha3_256.create();
+    h.update(this.init);
+    h.update(data);
+    return new Uint8Array(h.digest());
+  }
+  clone() {
+    const d = new _DomainHasher("");
+    d.init = new Uint8Array(this.init);
+    return d;
+  }
+};
+var TxHash = new DomainHasher("TransactionHash");
+var TxID = new DomainHasher("TransactionID");
+var TxSigningHash = new DomainHasher("TransactionSigningHash");
+var BlockHash = new DomainHasher("BlockHash");
+var MerkleHash = new DomainHasher("MerkleBranchHash");
+function sha3(data) {
+  return new Uint8Array((0, import_sha3.sha3_256)(data));
+}
+function shake256Bytes(data, len) {
+  return new Uint8Array((0, import_sha3.shake256)(data, { dkLen: len }));
+}
+function shake128Bytes(data, len) {
+  return new Uint8Array((0, import_sha3.shake128)(data, { dkLen: len }));
+}
+function shake256Digest(data, outputLen) {
+  return new Uint8Array((0, import_sha3.shake256)(data, { dkLen: outputLen }));
+}
+
+// src/address.ts
+var _bech32 = __toESM(require("bech32"));
+var bech32 = _bech32;
+var PREFIX_MAIN = "csm";
+var PREFIX_TEST = "csmtest";
+function pubkeyToHash(pk) {
+  return sha3(pk).slice(0, 20);
+}
+function pubkeyToAddress(pk, testnet = false) {
+  const hash = pubkeyToHash(pk);
+  const words = bech32.toWords(hash);
+  return bech32.encode(testnet ? PREFIX_TEST : PREFIX_MAIN, words);
+}
+function isValidAddress(addr, testnet = false) {
+  try {
+    const { prefix, words } = bech32.decode(addr);
+    if (prefix !== (testnet ? PREFIX_TEST : PREFIX_MAIN)) return false;
+    const data = bech32.fromWords(words);
+    return data.length === 20;
+  } catch {
+    return false;
+  }
+}
+function addressToScriptPubkey(addr) {
+  const { words } = bech32.decode(addr);
+  const data = bech32.fromWords(words);
+  const script = new Uint8Array(22);
+  script[0] = 20;
+  script.set(data, 1);
+  script[21] = 172;
+  return script;
+}
+
+// src/dilithium/index.ts
+var import_ml_dsa = require("@noble/post-quantum/ml-dsa.js");
+function keypair() {
+  const keys = import_ml_dsa.ml_dsa65.keygen();
+  return {
+    publicKey: keys.publicKey,
+    secretKey: keys.secretKey
+  };
+}
+function sign(secretKey, message) {
+  return import_ml_dsa.ml_dsa65.sign(message, secretKey);
+}
+function verify(publicKey, signature, message) {
+  return import_ml_dsa.ml_dsa65.verify(signature, message, publicKey);
+}
+
+// src/rpc/client.ts
+var RpcClient = class {
+  constructor(url = "ws://127.0.0.1:27110") {
+    this.ws = null;
+    this.connected = false;
+    this.url = url;
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.url);
+      this.ws.onopen = () => {
+        this.connected = true;
+        resolve();
+      };
+      this.ws.onerror = (e) => reject(e);
+    });
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async call(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || !this.connected) {
+        reject("Not connected");
+        return;
+      }
+      const id = Date.now();
+      const handler = (e) => {
+        const data = JSON.parse(e.data);
+        if (data.id === id) {
+          this.ws.removeEventListener("message", handler);
+          resolve(data.result || data);
+        }
+      };
+      this.ws.addEventListener("message", handler);
+      this.ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+    });
+  }
+  async getBalance(address) {
+    const result = await this.call("getBalanceByAddress", { address });
+    return result?.balance || 0;
+  }
+  async submitTransaction(tx) {
+    const result = await this.call("submitAccountTransaction", tx);
+    return result?.transactionId || "";
+  }
+};
+
+// src/wallet/index.ts
+var Wallet = class {
+  constructor(rpcUrl = "ws://127.0.0.1:27110") {
+    this.publicKey = new Uint8Array(1952);
+    this.secretKey = new Uint8Array(4032);
+    this.address = "";
+    this.balance = 0;
+    this.nonce = 0;
+    this.rpc = new RpcClient(rpcUrl);
+  }
+  async connect() {
+    await this.rpc.connect();
+  }
+  create() {
+    const { publicKey, secretKey } = keypair();
+    this.publicKey = publicKey;
+    this.secretKey = secretKey;
+    this.address = pubkeyToAddress(publicKey);
+  }
+  async getBalance() {
+    this.balance = await this.rpc.getBalance(this.address);
+    return this.balance;
+  }
+  async send(to, amountKana) {
+    const payload = Buffer.from(this.publicKey).toString("hex");
+    const txData = `${this.address}:${to}:${amountKana}:${this.nonce}`;
+    const signature = sign(this.secretKey, new TextEncoder().encode(txData));
+    const sigHex = Buffer.from(signature).toString("hex");
+    const tx = {
+      sender: this.address,
+      receiver: to,
+      amount: amountKana,
+      fee: 1e3,
+      nonce: this.nonce,
+      payload,
+      signature: sigHex
+    };
+    const txId = await this.rpc.submitTransaction(tx);
+    this.nonce++;
+    return txId;
+  }
+};
+
+// src/did/index.ts
+function createDid(address, publicKeyHex) {
+  const did = `did:sahyadri:${address}`;
+  return {
+    id: did,
+    controller: address,
+    publicKeyHex,
+    created: Math.floor(Date.now() / 1e3),
+    services: []
+  };
+}
+function addService(doc, type, endpoint) {
+  doc.services.push({ type, endpoint });
+  return doc;
+}
+
+// src/storage/index.ts
+var Storage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.store.set(key, JSON.stringify(value));
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(key, JSON.stringify(value));
+    }
+  }
+  get(key) {
+    const value = this.store.get(key) || (typeof localStorage !== "undefined" ? localStorage.getItem(key) : null);
+    return value ? JSON.parse(value) : null;
+  }
+  remove(key) {
+    this.store.delete(key);
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem(key);
+    }
+  }
+  clear() {
+    this.store.clear();
+    if (typeof localStorage !== "undefined") {
+      localStorage.clear();
+    }
+  }
+};
+
+// src/tx/transaction.ts
+function createTransaction(sender, receiver, amountKana, nonce, publicKeyHex) {
+  const fee = 1e3;
+  return {
+    sender,
+    receiver,
+    amount: amountKana,
+    fee,
+    nonce,
+    payload: publicKeyHex,
+    signature: ""
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BlockHash,
+  DomainHasher,
+  MerkleHash,
+  RpcClient,
+  Storage,
+  TxHash,
+  TxID,
+  TxSigningHash,
+  Wallet,
+  addService,
+  addressToScriptPubkey,
+  createDid,
+  createTransaction,
+  isValidAddress,
+  keypair,
+  pubkeyToAddress,
+  sha3,
+  shake128Bytes,
+  shake256Bytes,
+  shake256Digest,
+  sign,
+  verify
+});

package/dist/index.mjs

@@ -0,0 +1,258 @@
+// src/sha3.ts
+import { sha3_256, shake256, shake128 } from "@noble/hashes/sha3";
+var DomainHasher = class _DomainHasher {
+  constructor(domain) {
+    this.init = new Uint8Array(sha3_256(new TextEncoder().encode(domain)));
+  }
+  hash(data) {
+    const h = sha3_256.create();
+    h.update(this.init);
+    h.update(data);
+    return new Uint8Array(h.digest());
+  }
+  clone() {
+    const d = new _DomainHasher("");
+    d.init = new Uint8Array(this.init);
+    return d;
+  }
+};
+var TxHash = new DomainHasher("TransactionHash");
+var TxID = new DomainHasher("TransactionID");
+var TxSigningHash = new DomainHasher("TransactionSigningHash");
+var BlockHash = new DomainHasher("BlockHash");
+var MerkleHash = new DomainHasher("MerkleBranchHash");
+function sha3(data) {
+  return new Uint8Array(sha3_256(data));
+}
+function shake256Bytes(data, len) {
+  return new Uint8Array(shake256(data, { dkLen: len }));
+}
+function shake128Bytes(data, len) {
+  return new Uint8Array(shake128(data, { dkLen: len }));
+}
+function shake256Digest(data, outputLen) {
+  return new Uint8Array(shake256(data, { dkLen: outputLen }));
+}
+
+// src/address.ts
+import * as _bech32 from "bech32";
+var bech32 = _bech32;
+var PREFIX_MAIN = "csm";
+var PREFIX_TEST = "csmtest";
+function pubkeyToHash(pk) {
+  return sha3(pk).slice(0, 20);
+}
+function pubkeyToAddress(pk, testnet = false) {
+  const hash = pubkeyToHash(pk);
+  const words = bech32.toWords(hash);
+  return bech32.encode(testnet ? PREFIX_TEST : PREFIX_MAIN, words);
+}
+function isValidAddress(addr, testnet = false) {
+  try {
+    const { prefix, words } = bech32.decode(addr);
+    if (prefix !== (testnet ? PREFIX_TEST : PREFIX_MAIN)) return false;
+    const data = bech32.fromWords(words);
+    return data.length === 20;
+  } catch {
+    return false;
+  }
+}
+function addressToScriptPubkey(addr) {
+  const { words } = bech32.decode(addr);
+  const data = bech32.fromWords(words);
+  const script = new Uint8Array(22);
+  script[0] = 20;
+  script.set(data, 1);
+  script[21] = 172;
+  return script;
+}
+
+// src/dilithium/index.ts
+import { ml_dsa65 } from "@noble/post-quantum/ml-dsa.js";
+function keypair() {
+  const keys = ml_dsa65.keygen();
+  return {
+    publicKey: keys.publicKey,
+    secretKey: keys.secretKey
+  };
+}
+function sign(secretKey, message) {
+  return ml_dsa65.sign(message, secretKey);
+}
+function verify(publicKey, signature, message) {
+  return ml_dsa65.verify(signature, message, publicKey);
+}
+
+// src/rpc/client.ts
+var RpcClient = class {
+  constructor(url = "ws://127.0.0.1:27110") {
+    this.ws = null;
+    this.connected = false;
+    this.url = url;
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.url);
+      this.ws.onopen = () => {
+        this.connected = true;
+        resolve();
+      };
+      this.ws.onerror = (e) => reject(e);
+    });
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async call(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || !this.connected) {
+        reject("Not connected");
+        return;
+      }
+      const id = Date.now();
+      const handler = (e) => {
+        const data = JSON.parse(e.data);
+        if (data.id === id) {
+          this.ws.removeEventListener("message", handler);
+          resolve(data.result || data);
+        }
+      };
+      this.ws.addEventListener("message", handler);
+      this.ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+    });
+  }
+  async getBalance(address) {
+    const result = await this.call("getBalanceByAddress", { address });
+    return result?.balance || 0;
+  }
+  async submitTransaction(tx) {
+    const result = await this.call("submitAccountTransaction", tx);
+    return result?.transactionId || "";
+  }
+};
+
+// src/wallet/index.ts
+var Wallet = class {
+  constructor(rpcUrl = "ws://127.0.0.1:27110") {
+    this.publicKey = new Uint8Array(1952);
+    this.secretKey = new Uint8Array(4032);
+    this.address = "";
+    this.balance = 0;
+    this.nonce = 0;
+    this.rpc = new RpcClient(rpcUrl);
+  }
+  async connect() {
+    await this.rpc.connect();
+  }
+  create() {
+    const { publicKey, secretKey } = keypair();
+    this.publicKey = publicKey;
+    this.secretKey = secretKey;
+    this.address = pubkeyToAddress(publicKey);
+  }
+  async getBalance() {
+    this.balance = await this.rpc.getBalance(this.address);
+    return this.balance;
+  }
+  async send(to, amountKana) {
+    const payload = Buffer.from(this.publicKey).toString("hex");
+    const txData = `${this.address}:${to}:${amountKana}:${this.nonce}`;
+    const signature = sign(this.secretKey, new TextEncoder().encode(txData));
+    const sigHex = Buffer.from(signature).toString("hex");
+    const tx = {
+      sender: this.address,
+      receiver: to,
+      amount: amountKana,
+      fee: 1e3,
+      nonce: this.nonce,
+      payload,
+      signature: sigHex
+    };
+    const txId = await this.rpc.submitTransaction(tx);
+    this.nonce++;
+    return txId;
+  }
+};
+
+// src/did/index.ts
+function createDid(address, publicKeyHex) {
+  const did = `did:sahyadri:${address}`;
+  return {
+    id: did,
+    controller: address,
+    publicKeyHex,
+    created: Math.floor(Date.now() / 1e3),
+    services: []
+  };
+}
+function addService(doc, type, endpoint) {
+  doc.services.push({ type, endpoint });
+  return doc;
+}
+
+// src/storage/index.ts
+var Storage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.store.set(key, JSON.stringify(value));
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(key, JSON.stringify(value));
+    }
+  }
+  get(key) {
+    const value = this.store.get(key) || (typeof localStorage !== "undefined" ? localStorage.getItem(key) : null);
+    return value ? JSON.parse(value) : null;
+  }
+  remove(key) {
+    this.store.delete(key);
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem(key);
+    }
+  }
+  clear() {
+    this.store.clear();
+    if (typeof localStorage !== "undefined") {
+      localStorage.clear();
+    }
+  }
+};
+
+// src/tx/transaction.ts
+function createTransaction(sender, receiver, amountKana, nonce, publicKeyHex) {
+  const fee = 1e3;
+  return {
+    sender,
+    receiver,
+    amount: amountKana,
+    fee,
+    nonce,
+    payload: publicKeyHex,
+    signature: ""
+  };
+}
+export {
+  BlockHash,
+  DomainHasher,
+  MerkleHash,
+  RpcClient,
+  Storage,
+  TxHash,
+  TxID,
+  TxSigningHash,
+  Wallet,
+  addService,
+  addressToScriptPubkey,
+  createDid,
+  createTransaction,
+  isValidAddress,
+  keypair,
+  pubkeyToAddress,
+  sha3,
+  shake128Bytes,
+  shake256Bytes,
+  shake256Digest,
+  sign,
+  verify
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@sahyadrinet/web3.js",
+  "version": "0.1.0",
+  "description": "Sahyadri L1 Blockchain SDK - Post-Quantum Secure Web3 Library",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "npx tsx test-full.ts"
+  },
+  "keywords": [
+    "sahyadri",
+    "blockchain",
+    "web3",
+    "post-quantum",
+    "dilithium",
+    "ml-dsa",
+    "crypto"
+  ],
+  "author": "Sahyadri Network",
+  "license": "MIT",
+  "dependencies": {
+    "@noble/hashes": "^2.0.0",
+    "@noble/post-quantum": "^0.7.1",
+    "@scure/base": "^1.1.7"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sahyadrinet/sahyadri-sdk.git"
+  }
+}