@r3e/neo-js-sdk 0.3.0

package/dist/wallet/nep2.d.ts

@@ -0,0 +1,19 @@
+import { PrivateKey } from "../core/keypair.js";
+export declare class ScryptParams {
+    readonly n: number;
+    readonly r: number;
+    readonly p: number;
+    constructor(n?: number, r?: number, p?: number);
+    toJSON(): {
+        n: number;
+        r: number;
+        p: number;
+    };
+    static fromJSON(data: {
+        n: number;
+        r: number;
+        p: number;
+    }): ScryptParams;
+}
+export declare function encryptSecp256r1Key(privateKey: PrivateKey, passphrase: string, addressVersion?: number, scrypt?: ScryptParams): string;
+export declare function decryptSecp256r1Key(key: string, passphrase: string, addressVersion?: number, scrypt?: ScryptParams): PrivateKey;

package/dist/wallet/nep2.js

@@ -0,0 +1,96 @@
+import { createCipheriv, createDecipheriv, createHash, scryptSync } from "node:crypto";
+import bs58 from "bs58";
+import { PrivateKey } from "../core/keypair.js";
+/** NEP-2 encrypted key prefix: 0x01 0x42 0xe0 (flag byte = 0xe0 for secp256r1) */
+const NEP2_PREFIX = Buffer.from([0x01, 0x42, 0xe0]);
+export class ScryptParams {
+    n;
+    r;
+    p;
+    constructor(n = 16384, r = 8, p = 8) {
+        this.n = n;
+        this.r = r;
+        this.p = p;
+    }
+    toJSON() {
+        return { n: this.n, r: this.r, p: this.p };
+    }
+    static fromJSON(data) {
+        return new ScryptParams(data.n, data.r, data.p);
+    }
+}
+function addressHash(address) {
+    const first = createHash("sha256").update(address, "utf8").digest();
+    return createHash("sha256").update(first).digest().subarray(0, 4);
+}
+function computeChecksum(payload) {
+    return createHash("sha256").update(createHash("sha256").update(payload).digest()).digest().subarray(0, 4);
+}
+function base58CheckEncode(payload) {
+    const checksum = computeChecksum(payload);
+    return bs58.encode(Buffer.concat([Buffer.from(payload), checksum]));
+}
+function base58CheckDecode(value) {
+    const decoded = Buffer.from(bs58.decode(value));
+    if (decoded.length < 5) {
+        throw new Error("NEP-2: invalid base58check key");
+    }
+    const payload = decoded.subarray(0, -4);
+    const checksum = decoded.subarray(-4);
+    if (!checksum.equals(computeChecksum(payload))) {
+        throw new Error("NEP-2: invalid base58check checksum");
+    }
+    return payload;
+}
+function deriveKey(passphrase, salt, scrypt) {
+    return scryptSync(passphrase.normalize("NFC"), salt, 64, {
+        N: scrypt.n,
+        r: scrypt.r,
+        p: scrypt.p,
+    });
+}
+function encryptAesEcb(key, value) {
+    const cipher = createCipheriv("aes-256-ecb", key, null);
+    cipher.setAutoPadding(false);
+    return Buffer.concat([cipher.update(value), cipher.final()]);
+}
+function decryptAesEcb(key, value) {
+    const decipher = createDecipheriv("aes-256-ecb", key, null);
+    decipher.setAutoPadding(false);
+    return Buffer.concat([decipher.update(value), decipher.final()]);
+}
+export function encryptSecp256r1Key(privateKey, passphrase, addressVersion = 53, scrypt = new ScryptParams()) {
+    const checksum = addressHash(privateKey.publicKey().getAddress(addressVersion));
+    const derived = deriveKey(passphrase, checksum, scrypt);
+    const secretBytes = Buffer.from(privateKey.toBytes());
+    const xor = Buffer.allocUnsafe(32);
+    for (let index = 0; index < 32; index += 1) {
+        xor[index] = secretBytes[index] ^ derived[index];
+    }
+    const encrypted = encryptAesEcb(derived.subarray(32), xor);
+    const payload = Buffer.concat([NEP2_PREFIX, checksum, encrypted]);
+    return base58CheckEncode(payload);
+}
+export function decryptSecp256r1Key(key, passphrase, addressVersion = 53, scrypt = new ScryptParams()) {
+    const payload = base58CheckDecode(key);
+    if (payload.length !== 39) {
+        throw new Error("NEP-2 key must be 39 bytes");
+    }
+    if (!payload.subarray(0, 3).equals(NEP2_PREFIX)) {
+        throw new Error("NEP-2 key has invalid prefix");
+    }
+    const checksum = payload.subarray(3, 7);
+    const encrypted = payload.subarray(7);
+    const derived = deriveKey(passphrase, checksum, scrypt);
+    const decrypted = decryptAesEcb(derived.subarray(32), encrypted);
+    const secretBytes = Buffer.allocUnsafe(32);
+    for (let index = 0; index < 32; index += 1) {
+        secretBytes[index] = decrypted[index] ^ derived[index];
+    }
+    const privateKey = new PrivateKey(secretBytes);
+    const address = privateKey.publicKey().getAddress(addressVersion);
+    if (!addressHash(address).equals(checksum)) {
+        throw new Error("NEP-2 checksum mismatch");
+    }
+    return privateKey;
+}

package/dist/wallet/nep6.d.ts

@@ -0,0 +1,136 @@
+import { H160 } from "../core/hash.js";
+import { PrivateKey, PublicKey } from "../core/keypair.js";
+import { Witness } from "../core/witness.js";
+import { ScryptParams } from "./nep2.js";
+export declare class Parameter {
+    readonly name: string;
+    readonly type: string;
+    constructor(name: string, type: string);
+    toJSON(): {
+        name: string;
+        type: string;
+    };
+    static fromJSON(data: {
+        name: string;
+        type: string;
+    }): Parameter;
+}
+export declare class Contract {
+    readonly script: Uint8Array;
+    readonly parameters: Parameter[];
+    readonly deployed: boolean;
+    constructor(script: Uint8Array, parameters: Parameter[], deployed?: boolean);
+    toJSON(): {
+        script: string;
+        parameters: Array<{
+            name: string;
+            type: string;
+        }>;
+        deployed: boolean;
+    };
+    static fromJSON(data: {
+        script: string;
+        parameters: Array<{
+            name: string;
+            type: string;
+        }>;
+        deployed: boolean;
+    }): Contract;
+}
+export interface AccountOptions {
+    address: string;
+    key: string;
+    contract: Contract | null;
+    label?: string;
+    isDefault?: boolean;
+    locked?: boolean;
+}
+export declare class Account {
+    private privateKey;
+    readonly address: string;
+    readonly key: string;
+    readonly contract: Contract | null;
+    readonly label: string;
+    readonly isDefault: boolean;
+    readonly locked: boolean;
+    constructor({ address, key, contract, label, isDefault, locked }: AccountOptions);
+    setPrivateKey(privateKey: PrivateKey): void;
+    watchOnly(): boolean;
+    decrypt(passphrase: string, addressVersion?: number, scrypt?: ScryptParams): PublicKey;
+    signable(): boolean;
+    sign(message: Uint8Array): Uint8Array;
+    signWitness(signData: Uint8Array): Witness;
+    getScriptHash(): H160;
+    toJSON(): {
+        address: string;
+        key: string;
+        label: string;
+        isDefault: boolean;
+        lock: boolean;
+        contract: ReturnType<Contract["toJSON"]> | null;
+    };
+    static fromJSON(data: {
+        address: string;
+        key: string;
+        label: string;
+        isDefault: boolean;
+        lock: boolean;
+        contract: {
+            script: string;
+            parameters: Array<{
+                name: string;
+                type: string;
+            }>;
+            deployed: boolean;
+        } | null;
+    }): Account;
+}
+export interface WalletOptions {
+    name: string;
+    accounts?: Account[];
+    scrypt?: ScryptParams;
+    passphrase?: string;
+    version?: string;
+}
+export declare class Wallet {
+    readonly name: string;
+    readonly version: string;
+    readonly scrypt: ScryptParams;
+    readonly accounts: Account[];
+    private passphrase?;
+    constructor({ name, accounts, scrypt, passphrase, version }: WalletOptions);
+    createAccount(): Account;
+    decrypt(passphrase: string): void;
+    writeToFile(path: string): void;
+    toJSON(): {
+        name: string;
+        version: string;
+        scrypt: ReturnType<ScryptParams["toJSON"]>;
+        accounts: ReturnType<Account["toJSON"]>[];
+    };
+    static fromJSON(data: {
+        name: string;
+        version: string;
+        scrypt: {
+            n: number;
+            r: number;
+            p: number;
+        };
+        accounts: Array<{
+            address: string;
+            key: string;
+            label: string;
+            isDefault: boolean;
+            lock: boolean;
+            contract: {
+                script: string;
+                parameters: Array<{
+                    name: string;
+                    type: string;
+                }>;
+                deployed: boolean;
+            } | null;
+        }>;
+    }): Wallet;
+    static openNep6Wallet(path: string): Wallet;
+}

package/dist/wallet/nep6.js

@@ -0,0 +1,178 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { wallet as neonWallet } from "@cityofzion/neon-core";
+import { base64ToBytes, bytesToBase64 } from "../internal/bytes.js";
+import { H160 } from "../core/hash.js";
+import { PrivateKey } from "../core/keypair.js";
+import { ScryptParams, decryptSecp256r1Key, encryptSecp256r1Key } from "./nep2.js";
+export class Parameter {
+    name;
+    type;
+    constructor(name, type) {
+        this.name = name;
+        this.type = type;
+    }
+    toJSON() {
+        return { name: this.name, type: this.type };
+    }
+    static fromJSON(data) {
+        return new Parameter(data.name, data.type);
+    }
+}
+export class Contract {
+    script;
+    parameters;
+    deployed;
+    constructor(script, parameters, deployed = false) {
+        this.script = script;
+        this.parameters = parameters;
+        this.deployed = deployed;
+    }
+    toJSON() {
+        return {
+            script: bytesToBase64(this.script),
+            parameters: this.parameters.map((parameter) => parameter.toJSON()),
+            deployed: this.deployed,
+        };
+    }
+    static fromJSON(data) {
+        return new Contract(base64ToBytes(data.script), data.parameters.map((parameter) => Parameter.fromJSON(parameter)), data.deployed);
+    }
+}
+export class Account {
+    privateKey = null;
+    address;
+    key;
+    contract;
+    label;
+    isDefault;
+    locked;
+    constructor({ address, key, contract, label = "", isDefault = false, locked = false }) {
+        this.address = address;
+        this.key = key;
+        this.contract = contract;
+        this.label = label;
+        this.isDefault = isDefault;
+        this.locked = locked;
+    }
+    setPrivateKey(privateKey) {
+        this.privateKey = privateKey;
+    }
+    watchOnly() {
+        return this.contract === null;
+    }
+    decrypt(passphrase, addressVersion = 53, scrypt = new ScryptParams()) {
+        this.privateKey = decryptSecp256r1Key(this.key, passphrase, addressVersion, scrypt);
+        return this.privateKey.publicKey();
+    }
+    signable() {
+        return this.privateKey !== null && !this.locked && !this.watchOnly();
+    }
+    sign(message) {
+        if (this.privateKey === null) {
+            throw new Error("account is locked");
+        }
+        return this.privateKey.sign(message);
+    }
+    signWitness(signData) {
+        if (this.privateKey === null) {
+            throw new Error("account is locked");
+        }
+        return this.privateKey.signWitness(signData);
+    }
+    getScriptHash() {
+        if (this.privateKey !== null) {
+            return this.privateKey.publicKey().getScriptHash();
+        }
+        return new H160(`0x${neonWallet.getScriptHashFromAddress(this.address)}`);
+    }
+    toJSON() {
+        if (this.contract === null) {
+            throw new Error("neo: watch-only account cannot be serialized to NEP-6 by this compatibility layer");
+        }
+        return {
+            address: this.address,
+            key: this.key,
+            label: this.label,
+            isDefault: this.isDefault,
+            lock: this.locked,
+            contract: this.contract.toJSON(),
+        };
+    }
+    static fromJSON(data) {
+        if (data.contract === null || data.contract === undefined) {
+            throw new Error("contract is required in NEP-6 JSON");
+        }
+        return new Account({
+            address: data.address,
+            key: data.key,
+            label: data.label,
+            isDefault: data.isDefault,
+            locked: data.lock,
+            contract: Contract.fromJSON(data.contract),
+        });
+    }
+}
+export class Wallet {
+    name;
+    version;
+    scrypt;
+    accounts;
+    passphrase;
+    constructor({ name, accounts = [], scrypt = new ScryptParams(), passphrase, version = "1.0" }) {
+        this.name = name;
+        this.accounts = accounts;
+        this.scrypt = scrypt;
+        this.version = version;
+        this.passphrase = passphrase;
+    }
+    createAccount() {
+        if (!this.passphrase) {
+            throw new Error("passphrase is not set");
+        }
+        const privateKey = new PrivateKey();
+        const publicKey = privateKey.publicKey();
+        const address = publicKey.getAddress();
+        const contract = new Contract(publicKey.getSignatureRedeemScript(), [new Parameter("signature", "Signature")]);
+        const key = encryptSecp256r1Key(privateKey, this.passphrase, 53, this.scrypt);
+        const account = new Account({
+            address,
+            key,
+            contract,
+        });
+        account.setPrivateKey(privateKey);
+        this.accounts.push(account);
+        return account;
+    }
+    decrypt(passphrase) {
+        this.passphrase = passphrase;
+        for (const account of this.accounts) {
+            account.decrypt(passphrase, 53, this.scrypt);
+        }
+    }
+    writeToFile(path) {
+        if (existsSync(path)) {
+            throw new Error(`wallet file ${path} already exists`);
+        }
+        writeFileSync(path, JSON.stringify(this.toJSON()), "utf8");
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            version: this.version,
+            scrypt: this.scrypt.toJSON(),
+            accounts: this.accounts.map((account) => account.toJSON()),
+        };
+    }
+    static fromJSON(data) {
+        return new Wallet({
+            name: data.name,
+            version: data.version,
+            scrypt: ScryptParams.fromJSON(data.scrypt),
+            accounts: data.accounts.map((account) => Account.fromJSON(account)),
+        });
+    }
+    static openNep6Wallet(path) {
+        const raw = readFileSync(path, "utf8");
+        return Wallet.fromJSON(JSON.parse(raw));
+    }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@r3e/neo-js-sdk",
+  "version": "0.3.0",
+  "description": "Neo N3 JavaScript/TypeScript SDK — successor to neo-js (no longer maintained). Typed models, object-based RPC inputs, full N3 RPC coverage.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r3e-network/neo-js-sdk.git"
+  },
+  "homepage": "https://github.com/r3e-network/neo-js-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/r3e-network/neo-js-sdk/issues"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "coverage": "vitest run --coverage.enabled true --coverage.provider v8 --coverage.reporter=text --coverage.reporter=json-summary",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "test:integration": "RUN_NEO_LIVE=1 vitest run tests/integration/rpc-live.test.ts",
+    "test:integration:wif": "RUN_NEO_LIVE=1 vitest run tests/integration/rpc-live-wif.test.ts"
+  },
+  "keywords": [
+    "neo",
+    "neo-n3",
+    "neo-js",
+    "sdk",
+    "javascript",
+    "typescript",
+    "blockchain",
+    "n3"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@cityofzion/neon-core": "^5.8.1",
+    "bs58": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "@vitest/coverage-v8": "^3.2.4",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  }
+}