@veilux/sdk 0.2.0

package/README.md

@@ -0,0 +1,78 @@
+# @veilux/sdk
+
+TypeScript/JavaScript SDK for [VEILUX](https://github.com/VeiluxLabs/Veilux-Binary).
+Build, sign, and submit commands to a VEILUX node from Node.js or the browser.
+
+Signing (Ed25519) and hashing (BLAKE3) are **byte-compatible with the Rust
+node**, so signatures produced here verify on-chain.
+
+## Install
+
+```bash
+npm install @veilux/sdk
+```
+
+## Quick start
+
+```ts
+import { Client, PartyIdentity, builders, hashCommit, toHex } from "@veilux/sdk";
+
+const client = new Client("http://127.0.0.1:8645");
+
+// 32-byte seed (use real entropy in production)
+const alice = PartyIdentity.fromSeed("alice", new Uint8Array(32).fill(1));
+
+const info = await client.nodeInfo();
+console.log("height", info.height, "prisms", info.prisms);
+
+// Create a token
+const create = builders.tokenCreate(
+  "alice", "Public", 0, "Gold Coin", "GLD", 18, 1_000_000n, true,
+);
+const res = await client.submit(alice.sign(create));
+console.log("accepted", res.accepted);
+
+// Transfer (token id is derived the same way the node does)
+const te = new TextEncoder();
+const tokenId = toHex(hashCommit("token/id",
+  [te.encode("alice"), te.encode("GLD"), te.encode("Gold Coin")]));
+await client.submit(alice.sign(
+  builders.tokenTransfer("alice", "Public", 1, tokenId, "bob", 250_000n)));
+
+// Read state
+const bal = await client.getState(`token/bal/${tokenId}/bob`);
+console.log("bob:", Buffer.from(bal.value_hex, "hex").toString());
+```
+
+## API
+
+### `PartyIdentity`
+- `PartyIdentity.fromSeed(party, seed: Uint8Array)` — 32-byte seed
+- `PartyIdentity.fromPassphrase(party, passphrase)` — dev convenience
+- `PartyIdentity.generate(party)` — random
+- `id.publicKey(): Uint8Array`
+- `id.sign(command): SignedCommand`
+
+### `Client`
+- `nodeInfo()`, `blockNumber()`, `blockByNumber(h)`, `getState(key)`
+- `estimate(signed)`, `submit(signed)`
+
+### `builders`
+- `tokenCreate`, `tokenTransfer`
+- `nftCreateCollection`
+- `storagePut`
+- `contractDeploy`, `contractCall`
+
+### Encoding helpers
+- `signingBytes(command)`, `commandId(command)`, `hashCommit(domain, parts)`, `toHex(bytes)`
+
+## Compatibility notes
+
+- `Hash`-typed command fields (token id, contract address) are byte arrays on
+  the wire; the builders convert hex for you.
+- Token amounts are `u128` and serialized as decimal strings.
+- `Visibility` is `"Public"` or `{ Parties: ["alice", ...] }`.
+
+## License
+
+MIT

package/dist/builders.d.ts

@@ -0,0 +1,7 @@
+import type { Command, PartyId, Visibility } from "./types.js";
+export declare function tokenCreate(submitter: PartyId, visibility: Visibility, nonce: number, name: string, symbol: string, decimals: number, initialSupply: bigint | number | string, mintable: boolean): Command;
+export declare function tokenTransfer(submitter: PartyId, visibility: Visibility, nonce: number, tokenIdHex: string, to: PartyId, amount: bigint | number | string): Command;
+export declare function nftCreateCollection(submitter: PartyId, visibility: Visibility, nonce: number, name: string, symbol: string, maxSupply: number | null): Command;
+export declare function storagePut(submitter: PartyId, visibility: Visibility, nonce: number, key: string, data: Uint8Array | number[]): Command;
+export declare function contractDeploy(submitter: PartyId, visibility: Visibility, nonce: number, code: Uint8Array | number[]): Command;
+export declare function contractCall(submitter: PartyId, visibility: Visibility, nonce: number, addressHex: string, args: number[], value: number, gasLimit: number): Command;

package/dist/builders.js

@@ -0,0 +1,73 @@
+const enc = new TextEncoder();
+/** Encode a prism command object as the kernel `payload` byte array. */
+function payloadOf(obj) {
+    return Array.from(enc.encode(JSON.stringify(obj)));
+}
+/**
+ * Convert a `0x`-prefixed (or bare) hex hash to a 32-number array, because the
+ * Rust `Hash(pub [u8;32])` newtype serializes as a JSON array of bytes — not a
+ * hex string. Hash-typed command fields must use this.
+ */
+function hashBytes(hex) {
+    const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+    if (clean.length !== 64)
+        throw new Error(`hash must be 32 bytes (64 hex chars), got ${clean.length}`);
+    const out = [];
+    for (let i = 0; i < 64; i += 2)
+        out.push(parseInt(clean.slice(i, i + 2), 16));
+    return out;
+}
+function cmd(prism, submitter, visibility, nonce, payloadObj) {
+    return { prism, submitter, visibility, payload: payloadOf(payloadObj), nonce };
+}
+// ---- Token Prism (amounts are decimal strings, matching Rust u128 serde) ----
+export function tokenCreate(submitter, visibility, nonce, name, symbol, decimals, initialSupply, mintable) {
+    return cmd("token", submitter, visibility, nonce, {
+        op: "create",
+        name,
+        symbol,
+        decimals,
+        initial_supply: String(initialSupply),
+        mintable,
+    });
+}
+export function tokenTransfer(submitter, visibility, nonce, tokenIdHex, to, amount) {
+    return cmd("token", submitter, visibility, nonce, {
+        op: "transfer",
+        token_id: hashBytes(tokenIdHex),
+        to,
+        amount: String(amount),
+    });
+}
+// ---- NFT Prism ----
+export function nftCreateCollection(submitter, visibility, nonce, name, symbol, maxSupply) {
+    return cmd("nft", submitter, visibility, nonce, {
+        op: "create_collection",
+        name,
+        symbol,
+        max_supply: maxSupply,
+    });
+}
+// ---- Storage Prism ----
+export function storagePut(submitter, visibility, nonce, key, data) {
+    return cmd("storage", submitter, visibility, nonce, {
+        key,
+        data: Array.from(data),
+    });
+}
+// ---- Contract Prism (PhotonVM) ----
+export function contractDeploy(submitter, visibility, nonce, code) {
+    return cmd("contract", submitter, visibility, nonce, {
+        op: "deploy",
+        code: Array.from(code),
+    });
+}
+export function contractCall(submitter, visibility, nonce, addressHex, args, value, gasLimit) {
+    return cmd("contract", submitter, visibility, nonce, {
+        op: "call",
+        address: hashBytes(addressHex),
+        args,
+        value,
+        gas_limit: gasLimit,
+    });
+}

package/dist/client.d.ts

@@ -0,0 +1,31 @@
+import { type BlockView, type EstimateResult, type NodeInfo, type SignedCommand, type StateResult, type SubmitResult } from "./types.js";
+export declare class RpcClientError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+}
+/** A JSON-RPC client for a VEILUX node. Uses the global `fetch`. */
+export declare class Client {
+    private readonly endpoint;
+    private id;
+    constructor(endpoint: string);
+    private call;
+    nodeInfo(): Promise<NodeInfo>;
+    blockNumber(): Promise<number>;
+    blockByNumber(height: number): Promise<BlockView>;
+    getState(key: string): Promise<StateResult>;
+    estimate(command: SignedCommand): Promise<EstimateResult>;
+    submit(command: SignedCommand): Promise<SubmitResult>;
+    /**
+     * Read a token balance as a bigint (0 if the account has none).
+     * `tokenIdHex` is the `0x`-prefixed token id (see `ids.tokenId`).
+     */
+    tokenBalance(tokenIdHex: string, party: string): Promise<bigint>;
+    /**
+     * Poll until the chain reaches at least `target` height (or times out).
+     * Useful after submitting to a non-instant-mining node.
+     */
+    waitForHeight(target: number, opts?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }): Promise<number>;
+}

package/dist/client.js

@@ -0,0 +1,88 @@
+import { RPC_METHODS, } from "./types.js";
+export class RpcClientError extends Error {
+    constructor(code, message) {
+        super(`rpc error ${code}: ${message}`);
+        this.code = code;
+        this.name = "RpcClientError";
+    }
+}
+/** A JSON-RPC client for a VEILUX node. Uses the global `fetch`. */
+export class Client {
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+        this.id = 1;
+    }
+    async call(method, params) {
+        const body = JSON.stringify({
+            jsonrpc: "2.0",
+            method,
+            params,
+            id: this.id++,
+        });
+        const resp = await fetch(this.endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body,
+        });
+        const json = (await resp.json());
+        if (json.error) {
+            throw new RpcClientError(json.error.code, json.error.message);
+        }
+        if (json.result === undefined) {
+            throw new Error("missing result in RPC response");
+        }
+        return json.result;
+    }
+    nodeInfo() {
+        return this.call(RPC_METHODS.nodeInfo, {});
+    }
+    blockNumber() {
+        return this.call(RPC_METHODS.blockNumber, {});
+    }
+    blockByNumber(height) {
+        return this.call(RPC_METHODS.getBlockByNumber, { height });
+    }
+    getState(key) {
+        return this.call(RPC_METHODS.getState, { key });
+    }
+    estimate(command) {
+        return this.call(RPC_METHODS.estimate, { command });
+    }
+    submit(command) {
+        return this.call(RPC_METHODS.submit, { command });
+    }
+    /**
+     * Read a token balance as a bigint (0 if the account has none).
+     * `tokenIdHex` is the `0x`-prefixed token id (see `ids.tokenId`).
+     */
+    async tokenBalance(tokenIdHex, party) {
+        const r = await this.getState(`token/bal/${tokenIdHex}/${party}`);
+        if (!r.found)
+            return 0n;
+        const clean = r.value_hex.startsWith("0x") ? r.value_hex.slice(2) : r.value_hex;
+        const bytes = new Uint8Array(clean.length / 2);
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+        }
+        const text = new TextDecoder().decode(bytes);
+        return text ? BigInt(text) : 0n;
+    }
+    /**
+     * Poll until the chain reaches at least `target` height (or times out).
+     * Useful after submitting to a non-instant-mining node.
+     */
+    async waitForHeight(target, opts) {
+        const timeoutMs = opts?.timeoutMs ?? 30000;
+        const intervalMs = opts?.intervalMs ?? 500;
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            const h = await this.blockNumber();
+            if (h >= target)
+                return h;
+            if (Date.now() > deadline) {
+                throw new Error(`timed out waiting for height ${target} (current ${h})`);
+            }
+            await new Promise((r) => setTimeout(r, intervalMs));
+        }
+    }
+}

package/dist/encoding.d.ts

@@ -0,0 +1,25 @@
+import type { Command, Visibility } from "./types.js";
+/** Concatenate byte arrays. */
+declare function concat(...parts: Uint8Array[]): Uint8Array;
+declare function u64le(n: number): Uint8Array;
+/**
+ * Serialize `Visibility` exactly like serde_json on the Rust side, so the
+ * signed bytes match byte-for-byte:
+ *   Public        -> "Public"   (a quoted JSON string)
+ *   Parties([...]) -> {"Parties":["alice","bob"]}
+ */
+export declare function visibilityJson(v: Visibility): Uint8Array;
+/**
+ * Reproduce `Command::signing_bytes` from the Rust kernel:
+ *   b"veilux/command/v1" 0xff prism 0xff submitter 0xff nonce_le vis 0xff payload
+ */
+export declare function signingBytes(cmd: Command): Uint8Array;
+/**
+ * Reproduce `Hash::commit(domain, parts)`:
+ *   blake3(domain || 0xff || for each part: len_le_u64 || part)
+ */
+export declare function hashCommit(domain: string, parts: Uint8Array[]): Uint8Array;
+/** Reproduce `Command::id` -> 32-byte BLAKE3 hash. */
+export declare function commandId(cmd: Command): Uint8Array;
+export declare function toHex(bytes: Uint8Array): string;
+export { concat, u64le };

package/dist/encoding.js

@@ -0,0 +1,68 @@
+import { blake3 } from "@noble/hashes/blake3";
+const textEncoder = new TextEncoder();
+/** Concatenate byte arrays. */
+function concat(...parts) {
+    let len = 0;
+    for (const p of parts)
+        len += p.length;
+    const out = new Uint8Array(len);
+    let off = 0;
+    for (const p of parts) {
+        out.set(p, off);
+        off += p.length;
+    }
+    return out;
+}
+function u64le(n) {
+    const buf = new Uint8Array(8);
+    const view = new DataView(buf.buffer);
+    view.setBigUint64(0, BigInt(n), true);
+    return buf;
+}
+/**
+ * Serialize `Visibility` exactly like serde_json on the Rust side, so the
+ * signed bytes match byte-for-byte:
+ *   Public        -> "Public"   (a quoted JSON string)
+ *   Parties([...]) -> {"Parties":["alice","bob"]}
+ */
+export function visibilityJson(v) {
+    if (v === "Public") {
+        return textEncoder.encode('"Public"');
+    }
+    // serde_json emits compact JSON with no spaces.
+    const inner = v.Parties.map((p) => JSON.stringify(p)).join(",");
+    return textEncoder.encode(`{"Parties":[${inner}]}`);
+}
+/**
+ * Reproduce `Command::signing_bytes` from the Rust kernel:
+ *   b"veilux/command/v1" 0xff prism 0xff submitter 0xff nonce_le vis 0xff payload
+ */
+export function signingBytes(cmd) {
+    const sep = new Uint8Array([0xff]);
+    return concat(textEncoder.encode("veilux/command/v1"), sep, textEncoder.encode(cmd.prism), sep, textEncoder.encode(cmd.submitter), sep, u64le(cmd.nonce), visibilityJson(cmd.visibility), sep, Uint8Array.from(cmd.payload));
+}
+/**
+ * Reproduce `Hash::commit(domain, parts)`:
+ *   blake3(domain || 0xff || for each part: len_le_u64 || part)
+ */
+export function hashCommit(domain, parts) {
+    const chunks = [textEncoder.encode(domain), new Uint8Array([0xff])];
+    for (const p of parts) {
+        chunks.push(u64le(p.length));
+        chunks.push(p);
+    }
+    return blake3(concat(...chunks));
+}
+/** Reproduce `Command::id` -> 32-byte BLAKE3 hash. */
+export function commandId(cmd) {
+    return hashCommit("command", [
+        textEncoder.encode(cmd.prism),
+        textEncoder.encode(cmd.submitter),
+        u64le(cmd.nonce),
+        Uint8Array.from(cmd.payload),
+    ]);
+}
+export function toHex(bytes) {
+    return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+export { concat, u64le };

package/dist/identity.d.ts

@@ -0,0 +1,23 @@
+import type { Command, PartyId, SignedCommand } from "./types.js";
+/**
+ * A party's signing identity. Mirrors the Rust `PartyIdentity`:
+ * the 32-byte seed IS the Ed25519 secret key (dalek `from_bytes`).
+ */
+export declare class PartyIdentity {
+    readonly party: PartyId;
+    private readonly secret;
+    constructor(party: PartyId, seed: Uint8Array);
+    /** Deterministic identity from a label + raw 32-byte seed. */
+    static fromSeed(party: PartyId, seed: Uint8Array): PartyIdentity;
+    /**
+     * Convenience: derive a 32-byte seed from a passphrase via BLAKE3.
+     * (Use real entropy in production; this mirrors test/dev helpers.)
+     */
+    static fromPassphrase(party: PartyId, passphrase: string): PartyIdentity;
+    /** Generate a random identity. */
+    static generate(party: PartyId): PartyIdentity;
+    /** The 32-byte Ed25519 public key. */
+    publicKey(): Uint8Array;
+    /** Sign a command, producing a SignedCommand ready for submission. */
+    sign(command: Command): SignedCommand;
+}

package/dist/identity.js

@@ -0,0 +1,48 @@
+import * as ed from "@noble/ed25519";
+import { sha512 } from "@noble/hashes/sha512";
+import { blake3 } from "@noble/hashes/blake3";
+import { signingBytes } from "./encoding.js";
+// @noble/ed25519 v2 needs sha512 wired up for synchronous signing.
+ed.etc.sha512Sync = (...m) => sha512(ed.etc.concatBytes(...m));
+/**
+ * A party's signing identity. Mirrors the Rust `PartyIdentity`:
+ * the 32-byte seed IS the Ed25519 secret key (dalek `from_bytes`).
+ */
+export class PartyIdentity {
+    constructor(party, seed) {
+        if (seed.length !== 32)
+            throw new Error("seed must be 32 bytes");
+        this.party = party;
+        this.secret = seed;
+    }
+    /** Deterministic identity from a label + raw 32-byte seed. */
+    static fromSeed(party, seed) {
+        return new PartyIdentity(party, seed);
+    }
+    /**
+     * Convenience: derive a 32-byte seed from a passphrase via BLAKE3.
+     * (Use real entropy in production; this mirrors test/dev helpers.)
+     */
+    static fromPassphrase(party, passphrase) {
+        const seed = blake3(new TextEncoder().encode(passphrase));
+        return new PartyIdentity(party, seed);
+    }
+    /** Generate a random identity. */
+    static generate(party) {
+        return new PartyIdentity(party, ed.utils.randomPrivateKey());
+    }
+    /** The 32-byte Ed25519 public key. */
+    publicKey() {
+        return ed.getPublicKey(this.secret);
+    }
+    /** Sign a command, producing a SignedCommand ready for submission. */
+    sign(command) {
+        const msg = signingBytes(command);
+        const signature = ed.sign(msg, this.secret);
+        return {
+            command,
+            public_key: Array.from(this.publicKey()),
+            signature: Array.from(signature),
+        };
+    }
+}

package/dist/ids.d.ts

@@ -0,0 +1,27 @@
+import type { PartyId } from "./types.js";
+/**
+ * Derive a token id exactly like the Token Prism:
+ * `keccak/blake3 commit("token/id", [submitter, symbol, name])`.
+ */
+export declare function tokenId(submitter: PartyId, symbol: string, name: string): string;
+/**
+ * Derive an NFT collection id like the NFT Prism:
+ * `commit("nft/coll-id", [submitter, symbol, name])`.
+ */
+export declare function collectionId(submitter: PartyId, symbol: string, name: string): string;
+/**
+ * Derive a deployed contract address like the Contract Prism:
+ * `commit("contract/address", [submitter, nonce_le, code])`.
+ */
+export declare function contractAddress(submitter: PartyId, nonce: number, code: Uint8Array | number[]): string;
+/** State key helpers (matching each Prism's namespacing). */
+export declare const stateKeys: {
+    tokenMeta: (id: string) => string;
+    tokenBalance: (id: string, party: PartyId) => string;
+    tokenAllowance: (id: string, owner: PartyId, spender: PartyId) => string;
+    nftCollection: (id: string) => string;
+    nftOwner: (id: string, index: number) => string;
+    contractCode: (addr: string) => string;
+};
+/** Decode a hex state value into a UTF-8 string (e.g. token balances). */
+export declare function decodeStringValue(valueHex: string): string;

package/dist/ids.js

@@ -0,0 +1,45 @@
+import { hashCommit, toHex, u64le } from "./encoding.js";
+const te = new TextEncoder();
+/**
+ * Derive a token id exactly like the Token Prism:
+ * `keccak/blake3 commit("token/id", [submitter, symbol, name])`.
+ */
+export function tokenId(submitter, symbol, name) {
+    return toHex(hashCommit("token/id", [te.encode(submitter), te.encode(symbol), te.encode(name)]));
+}
+/**
+ * Derive an NFT collection id like the NFT Prism:
+ * `commit("nft/coll-id", [submitter, symbol, name])`.
+ */
+export function collectionId(submitter, symbol, name) {
+    return toHex(hashCommit("nft/coll-id", [te.encode(submitter), te.encode(symbol), te.encode(name)]));
+}
+/**
+ * Derive a deployed contract address like the Contract Prism:
+ * `commit("contract/address", [submitter, nonce_le, code])`.
+ */
+export function contractAddress(submitter, nonce, code) {
+    return toHex(hashCommit("contract/address", [
+        te.encode(submitter),
+        u64le(nonce),
+        Uint8Array.from(code),
+    ]));
+}
+/** State key helpers (matching each Prism's namespacing). */
+export const stateKeys = {
+    tokenMeta: (id) => `token/meta/${id}`,
+    tokenBalance: (id, party) => `token/bal/${id}/${party}`,
+    tokenAllowance: (id, owner, spender) => `token/allow/${id}/${owner}/${spender}`,
+    nftCollection: (id) => `nft/coll/${id}`,
+    nftOwner: (id, index) => `nft/owner/${id}/${index}`,
+    contractCode: (addr) => `contract/code/${addr}`,
+};
+/** Decode a hex state value into a UTF-8 string (e.g. token balances). */
+export function decodeStringValue(valueHex) {
+    const clean = valueHex.startsWith("0x") ? valueHex.slice(2) : valueHex;
+    const bytes = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+    }
+    return new TextDecoder().decode(bytes);
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * VEILUX TypeScript SDK
+ *
+ * Build, sign, and submit commands to a VEILUX node from JavaScript/TypeScript.
+ * Signing and hashing are byte-compatible with the Rust node, so signatures
+ * produced here verify on-chain.
+ */
+export * from "./types.js";
+export * from "./encoding.js";
+export * from "./identity.js";
+export * from "./client.js";
+export * from "./ids.js";
+export * as builders from "./builders.js";

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * VEILUX TypeScript SDK
+ *
+ * Build, sign, and submit commands to a VEILUX node from JavaScript/TypeScript.
+ * Signing and hashing are byte-compatible with the Rust node, so signatures
+ * produced here verify on-chain.
+ */
+export * from "./types.js";
+export * from "./encoding.js";
+export * from "./identity.js";
+export * from "./client.js";
+export * from "./ids.js";
+export * as builders from "./builders.js";

package/dist/types.d.ts

@@ -0,0 +1,66 @@
+/** A party identifier. Serializes as a bare JSON string (newtype struct). */
+export type PartyId = string;
+/**
+ * Disclosure scope for an event.
+ * Rust serde: `Public` -> "Public", `Parties(vec)` -> { "Parties": [...] }.
+ */
+export type Visibility = "Public" | {
+    Parties: PartyId[];
+};
+/**
+ * A command. `payload` is a byte array (Rust `Vec<u8>` -> JSON number array).
+ */
+export interface Command {
+    prism: string;
+    submitter: PartyId;
+    visibility: Visibility;
+    payload: number[];
+    nonce: number;
+}
+/** A signed command ready for submission. */
+export interface SignedCommand {
+    command: Command;
+    public_key: number[];
+    signature: number[];
+}
+export interface NodeInfo {
+    network: string;
+    protocol: string;
+    token: string;
+    height: number;
+    head_hash: string;
+    state_root: string;
+    prisms: string[];
+}
+export interface SubmitResult {
+    accepted: boolean;
+    command_id: string;
+    mempool_len: number;
+}
+export interface BlockView {
+    height: number;
+    hash: string;
+    parent: string;
+    state_root: string;
+    events_root: string;
+    proposer: string;
+    timestamp: number;
+    command_count: number;
+    event_count: number;
+}
+export interface StateResult {
+    key: string;
+    found: boolean;
+    value_hex: string;
+}
+export interface EstimateResult {
+    cost: number;
+}
+export declare const RPC_METHODS: {
+    readonly nodeInfo: "veilux_nodeInfo";
+    readonly submit: "veilux_submit";
+    readonly blockNumber: "veilux_blockNumber";
+    readonly getBlockByNumber: "veilux_getBlockByNumber";
+    readonly getState: "veilux_getState";
+    readonly estimate: "veilux_estimate";
+};

package/dist/types.js

@@ -0,0 +1,9 @@
+// Wire types mirroring the Rust kernel's serde representation exactly.
+export const RPC_METHODS = {
+    nodeInfo: "veilux_nodeInfo",
+    submit: "veilux_submit",
+    blockNumber: "veilux_blockNumber",
+    getBlockByNumber: "veilux_getBlockByNumber",
+    getState: "veilux_getState",
+    estimate: "veilux_estimate",
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@veilux/sdk",
+  "version": "0.2.0",
+  "description": "VEILUX TypeScript SDK — build, sign, and submit commands to a VEILUX node",
+  "license": "MIT",
+  "author": "nathan <nathan@winnode.xyz>",
+  "repository": "https://github.com/VeiluxLabs/Veilux-Binary",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "pretest": "tsc && tsc test/compat.test.ts --rootDir test --outDir test-dist --module ESNext --target ES2020 --moduleResolution Bundler --skipLibCheck --types node",
+    "test": "node --test test-dist/",
+    "example": "node --loader ts-node/esm examples/quickstart.ts",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});require('fs').rmSync('test-dist',{recursive:true,force:true})\""
+  },
+  "dependencies": {
+    "@noble/ed25519": "^2.1.0",
+    "@noble/hashes": "^1.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}