@r3e/neo-js-sdk 0.3.0

package/dist/core/script.js

@@ -0,0 +1,144 @@
+import { createHash } from "node:crypto";
+import { bytesToHex, concatBytes, toUint8Array, utf8ToBytes } from "../internal/bytes.js";
+import { H160, H256 } from "./hash.js";
+import { serialize } from "./serializing.js";
+import { PublicKey } from "./keypair.js";
+import { OpCode } from "./opcode.js";
+export var CallFlags;
+(function (CallFlags) {
+    CallFlags[CallFlags["NONE"] = 0] = "NONE";
+    CallFlags[CallFlags["ReadStates"] = 1] = "ReadStates";
+    CallFlags[CallFlags["WriteStates"] = 2] = "WriteStates";
+    CallFlags[CallFlags["AllowCall"] = 4] = "AllowCall";
+    CallFlags[CallFlags["AllowNotify"] = 8] = "AllowNotify";
+    CallFlags[CallFlags["States"] = 3] = "States";
+    CallFlags[CallFlags["ReadOnly"] = 5] = "ReadOnly";
+    CallFlags[CallFlags["All"] = 15] = "All";
+})(CallFlags || (CallFlags = {}));
+export function syscallCode(syscallName) {
+    const hash = createHash("sha256").update(syscallName).digest();
+    return hash.readUInt32LE(0);
+}
+function bigintToFixedLE(value) {
+    if (value >= -1n && value <= 16n) {
+        return new Uint8Array();
+    }
+    const widths = [8, 16, 32, 64, 128, 256];
+    for (const bits of widths) {
+        const min = -(1n << BigInt(bits - 1));
+        const max = (1n << BigInt(bits - 1)) - 1n;
+        if (value < min || value > max) {
+            continue;
+        }
+        const mod = 1n << BigInt(bits);
+        let unsigned = value < 0n ? mod + value : value;
+        const bytes = new Uint8Array(bits / 8);
+        for (let index = 0; index < bytes.length; index += 1) {
+            bytes[index] = Number(unsigned & 0xffn);
+            unsigned >>= 8n;
+        }
+        return bytes;
+    }
+    throw new Error(`push too large integer: ${value.toString()}`);
+}
+export class ScriptBuilder {
+    script = [];
+    emit(opcode, operand = new Uint8Array()) {
+        this.script.push(opcode, ...operand);
+        return this;
+    }
+    emitPush(item) {
+        if (item === null || item === undefined) {
+            return this.emit(OpCode.PUSHNULL);
+        }
+        if (typeof item === "boolean") {
+            return this.emit(item ? OpCode.PUSHT : OpCode.PUSHF);
+        }
+        if (typeof item === "number" || typeof item === "bigint") {
+            return this.emitPushInt(BigInt(item));
+        }
+        if (typeof item === "string") {
+            return this.emitPushBytes(utf8ToBytes(item));
+        }
+        if (Array.isArray(item)) {
+            return this.emitPushArray(item);
+        }
+        if (item instanceof Uint8Array || item instanceof ArrayBuffer) {
+            return this.emitPushBytes(toUint8Array(item));
+        }
+        if (item instanceof H160 || item instanceof H256 || item instanceof PublicKey) {
+            return this.emitPushBytes(serialize(item));
+        }
+        if (typeof item === "object" && item && "marshalTo" in item) {
+            return this.emitPushBytes(serialize(item));
+        }
+        throw new Error(`Unsupported push item: ${String(item)}`);
+    }
+    emitPushInt(value) {
+        if (value >= -1n && value <= 16n) {
+            return this.emit((OpCode.PUSHM1 + Number(value) + 1));
+        }
+        const payload = bigintToFixedLE(value);
+        switch (payload.length) {
+            case 1:
+                return this.emit(OpCode.PUSHINT8, payload);
+            case 2:
+                return this.emit(OpCode.PUSHINT16, payload);
+            case 4:
+                return this.emit(OpCode.PUSHINT32, payload);
+            case 8:
+                return this.emit(OpCode.PUSHINT64, payload);
+            case 16:
+                return this.emit(OpCode.PUSHINT128, payload);
+            case 32:
+                return this.emit(OpCode.PUSHINT256, payload);
+            default:
+                throw new Error(`Unsupported integer width: ${payload.length}`);
+        }
+    }
+    emitPushBytes(value) {
+        const length = value.length;
+        if (length < 0x100) {
+            return this.emit(OpCode.PUSHDATA1, concatBytes(Uint8Array.of(length), value));
+        }
+        if (length < 0x10000) {
+            return this.emit(OpCode.PUSHDATA2, concatBytes(Uint8Array.of(length & 0xff, (length >> 8) & 0xff), value));
+        }
+        if (length < 0x100000000) {
+            return this.emit(OpCode.PUSHDATA4, concatBytes(Uint8Array.of(length & 0xff, (length >> 8) & 0xff, (length >> 16) & 0xff, (length >> 24) & 0xff), value));
+        }
+        throw new Error(`push too large bytes: ${length}`);
+    }
+    emitPushArray(items) {
+        if (items.length === 0) {
+            return this.emit(OpCode.NEWARRAY0);
+        }
+        for (const item of [...items].reverse()) {
+            this.emitPush(item);
+        }
+        this.emitPushInt(BigInt(items.length));
+        return this.emit(OpCode.PACK);
+    }
+    emitContractCall(contractHash, method, callFlags = CallFlags.NONE, args = []) {
+        this.emitPushArray(args);
+        this.emitPushInt(BigInt(callFlags));
+        this.emitPush(method);
+        this.emitPush(typeof contractHash === "string" ? new H160(contractHash) : contractHash);
+        return this.emitSyscall("System.Contract.Call");
+    }
+    emitSyscall(syscall, args = []) {
+        for (const arg of [...args].reverse()) {
+            this.emitPush(arg);
+        }
+        this.emit(OpCode.SYSCALL);
+        const code = typeof syscall === "number" ? syscall : syscallCode(syscall);
+        this.script.push(code & 0xff, (code >> 8) & 0xff, (code >> 16) & 0xff, (code >> 24) & 0xff);
+        return this;
+    }
+    toBytes() {
+        return Uint8Array.from(this.script);
+    }
+    toHex() {
+        return bytesToHex(this.toBytes());
+    }
+}

package/dist/core/serializing.d.ts

@@ -0,0 +1,40 @@
+import { BytesLike } from "../internal/bytes.js";
+type Marshaled = {
+    marshalTo(writer: BinaryWriter): void;
+};
+type Unmarshalable<T> = {
+    unmarshalFrom(reader: BinaryReader): T;
+};
+export declare class BinaryWriter {
+    private readonly chunks;
+    write(data: BytesLike): void;
+    writeVarBytes(data: BytesLike): void;
+    writeVarString(value: string): void;
+    writeBool(value: boolean): void;
+    writeUInt8(value: number): void;
+    writeUInt16LE(value: number): void;
+    writeUInt32LE(value: number): void;
+    writeUInt64LE(value: bigint | number): void;
+    writeVarInt(value: bigint | number): void;
+    writeMultiple(items: Marshaled[]): void;
+    toBytes(): Uint8Array;
+}
+export declare class BinaryReader {
+    private readonly data;
+    private index;
+    constructor(data: Uint8Array);
+    remaining(): number;
+    read(length: number): Uint8Array;
+    readVarInt(): bigint;
+    readVarBytes(): Uint8Array;
+    readVarString(): string;
+    readBool(): boolean;
+    readUInt8(): number;
+    readUInt16LE(): number;
+    readUInt32LE(): number;
+    readUInt64LE(): bigint;
+    readMultiple<T>(type: Unmarshalable<T>): T[];
+}
+export declare function serialize(value: Marshaled): Uint8Array;
+export declare function deserialize<T>(data: BytesLike, type: Unmarshalable<T>): T;
+export {};

package/dist/core/serializing.js

@@ -0,0 +1,175 @@
+import { concatBytes, toUint8Array } from "../internal/bytes.js";
+export class BinaryWriter {
+    chunks = [];
+    write(data) {
+        this.chunks.push(toUint8Array(data));
+    }
+    writeVarBytes(data) {
+        const bytes = toUint8Array(data);
+        this.writeVarInt(bytes.length);
+        this.write(bytes);
+    }
+    writeVarString(value) {
+        this.writeVarBytes(new TextEncoder().encode(value));
+    }
+    writeBool(value) {
+        this.writeUInt8(value ? 1 : 0);
+    }
+    writeUInt8(value) {
+        if (!Number.isInteger(value) || value < 0 || value > 0xff) {
+            throw new Error("uint8 must be between 0 and 255");
+        }
+        this.write([value]);
+    }
+    writeUInt16LE(value) {
+        if (!Number.isInteger(value) || value < 0 || value > 0xffff) {
+            throw new Error("uint16 must be between 0 and 65535");
+        }
+        const out = new Uint8Array(2);
+        out[0] = value & 0xff;
+        out[1] = (value >> 8) & 0xff;
+        this.write(out);
+    }
+    writeUInt32LE(value) {
+        if (!Number.isInteger(value) || value < 0 || value > 0xffffffff) {
+            throw new Error("uint32 must be between 0 and 4294967295");
+        }
+        const out = new Uint8Array(4);
+        out[0] = value & 0xff;
+        out[1] = (value >> 8) & 0xff;
+        out[2] = (value >> 16) & 0xff;
+        out[3] = (value >> 24) & 0xff;
+        this.write(out);
+    }
+    writeUInt64LE(value) {
+        const big = BigInt(value);
+        if (big < 0n || big > 0xffffffffffffffffn) {
+            throw new Error("uint64 must be between 0 and 2^64-1");
+        }
+        const out = new Uint8Array(8);
+        let remaining = big;
+        for (let index = 0; index < 8; index += 1) {
+            out[index] = Number(remaining & 0xffn);
+            remaining >>= 8n;
+        }
+        this.write(out);
+    }
+    writeVarInt(value) {
+        const big = BigInt(value);
+        if (big < 0n) {
+            throw new Error("var int cannot be negative");
+        }
+        if (big < 0xfdn) {
+            this.writeUInt8(Number(big));
+            return;
+        }
+        if (big <= 0xffffn) {
+            this.writeUInt8(0xfd);
+            this.writeUInt16LE(Number(big));
+            return;
+        }
+        if (big <= 0xffffffffn) {
+            this.writeUInt8(0xfe);
+            this.writeUInt32LE(Number(big));
+            return;
+        }
+        if (big <= 0xffffffffffffffffn) {
+            this.writeUInt8(0xff);
+            this.writeUInt64LE(big);
+            return;
+        }
+        throw new Error("var int exceeds 8 bytes");
+    }
+    writeMultiple(items) {
+        this.writeVarInt(items.length);
+        for (const item of items) {
+            item.marshalTo(this);
+        }
+    }
+    toBytes() {
+        return concatBytes(...this.chunks);
+    }
+}
+export class BinaryReader {
+    data;
+    index = 0;
+    constructor(data) {
+        this.data = data;
+    }
+    remaining() {
+        return this.data.length - this.index;
+    }
+    read(length) {
+        if (this.index + length > this.data.length) {
+            throw new Error(`unexpected EOF: expected ${length} bytes, ${this.remaining()} available`);
+        }
+        const out = this.data.slice(this.index, this.index + length);
+        this.index += length;
+        return out;
+    }
+    readVarInt() {
+        const tag = this.readUInt8();
+        if (tag < 0xfd) {
+            return BigInt(tag);
+        }
+        if (tag === 0xfd) {
+            return BigInt(this.readUInt16LE());
+        }
+        if (tag === 0xfe) {
+            return BigInt(this.readUInt32LE());
+        }
+        return this.readUInt64LE();
+    }
+    readVarBytes() {
+        return this.read(Number(this.readVarInt()));
+    }
+    readVarString() {
+        return new TextDecoder().decode(this.readVarBytes());
+    }
+    readBool() {
+        const value = this.readUInt8();
+        if (value !== 0 && value !== 1) {
+            throw new Error("serialized bool must be 0 or 1");
+        }
+        return value === 1;
+    }
+    readUInt8() {
+        return this.read(1)[0];
+    }
+    readUInt16LE() {
+        const bytes = this.read(2);
+        return bytes[0] | (bytes[1] << 8);
+    }
+    readUInt32LE() {
+        const bytes = this.read(4);
+        return bytes[0] + bytes[1] * 0x100 + bytes[2] * 0x10000 + bytes[3] * 0x1000000;
+    }
+    readUInt64LE() {
+        const bytes = this.read(8);
+        let result = 0n;
+        for (let index = 7; index >= 0; index -= 1) {
+            result = (result << 8n) | BigInt(bytes[index]);
+        }
+        return result;
+    }
+    readMultiple(type) {
+        const count = Number(this.readVarInt());
+        if (count > this.remaining()) {
+            throw new Error(`readMultiple: count ${count} exceeds remaining ${this.remaining()} bytes`);
+        }
+        const out = [];
+        for (let index = 0; index < count; index += 1) {
+            out.push(type.unmarshalFrom(this));
+        }
+        return out;
+    }
+}
+export function serialize(value) {
+    const writer = new BinaryWriter();
+    value.marshalTo(writer);
+    return writer.toBytes();
+}
+export function deserialize(data, type) {
+    const reader = new BinaryReader(toUint8Array(data));
+    return type.unmarshalFrom(reader);
+}

package/dist/core/tx.d.ts

@@ -0,0 +1,147 @@
+import { H160, H256 } from "./hash.js";
+import { PublicKey } from "./keypair.js";
+import { BinaryReader, BinaryWriter } from "./serializing.js";
+import { Witness, WitnessScope } from "./witness.js";
+import { WitnessRule, type WitnessRuleJson } from "./witness-rule.js";
+export interface SignerJson {
+    account: string;
+    scopes: string;
+    allowedcontracts: string[];
+    allowedgroups: string[];
+    rules: WitnessRuleJson[];
+}
+export interface BaseTxAttributeJson {
+    type: string;
+}
+export interface HighPriorityAttributeJson {
+    type: "HighPriority";
+}
+export interface OracleResponseAttributeJson {
+    type: "OracleResponse";
+    id: string;
+    code: string;
+    result: string;
+}
+export interface NotValidBeforeAttributeJson {
+    type: "NotValidBefore";
+    height: number;
+}
+export interface ConflictsAttributeJson {
+    type: "Conflicts";
+    hash: string;
+}
+export interface NotaryAssistedAttributeJson {
+    type: "NotaryAssisted";
+    nkeys: number;
+}
+export type TxAttributeJson = HighPriorityAttributeJson | OracleResponseAttributeJson | NotValidBeforeAttributeJson | ConflictsAttributeJson | NotaryAssistedAttributeJson;
+export declare class Signer {
+    readonly account: H160;
+    readonly scopes: WitnessScope;
+    readonly allowedContracts: H160[];
+    readonly allowedGroups: PublicKey[];
+    readonly rules: WitnessRule[];
+    constructor({ account, scopes, allowedContracts, allowedGroups, rules, }: {
+        account: H160 | string;
+        scopes: WitnessScope;
+        allowedContracts?: (H160 | string)[];
+        allowedGroups?: (PublicKey | string)[];
+        rules?: WitnessRule[];
+    });
+    toJSON(): SignerJson;
+    marshalTo(writer: BinaryWriter): void;
+    static unmarshalFrom(reader: BinaryReader): Signer;
+}
+export declare enum TxAttributeType {
+    HighPriority = 1,
+    OracleResponse = 17,
+    NotValidBefore = 32,
+    Conflicts = 33,
+    NotaryAssisted = 34
+}
+export declare enum OracleResponseCode {
+    Success = 0,
+    ProtocolNotSupported = 16,
+    ConsensusUnreachable = 18,
+    NotFound = 20,
+    Timeout = 22,
+    Forbidden = 24,
+    ResponseTooLarge = 26,
+    InsufficientFunds = 28,
+    ContentTypeNotSupported = 31,
+    Error = 255
+}
+export declare class TxAttribute {
+    readonly type: TxAttributeType;
+    constructor(type: TxAttributeType);
+    marshalTo(writer: BinaryWriter): void;
+    static unmarshalFrom(reader: BinaryReader): TxAttribute;
+    toJSON(): TxAttributeJson;
+}
+export declare class HighPriorityAttribute extends TxAttribute {
+    constructor();
+    toJSON(): HighPriorityAttributeJson;
+}
+export declare class OracleResponseAttribute extends TxAttribute {
+    readonly id: bigint;
+    readonly code: OracleResponseCode;
+    readonly result: Uint8Array;
+    constructor(id: bigint, code: OracleResponseCode, result: Uint8Array);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): OracleResponseAttributeJson;
+}
+export declare class NotValidBeforeAttribute extends TxAttribute {
+    readonly height: number;
+    constructor(height: number);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): NotValidBeforeAttributeJson;
+}
+export declare class ConflictsAttribute extends TxAttribute {
+    readonly hash: H256;
+    constructor(hash: H256);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): ConflictsAttributeJson;
+}
+export declare class NotaryAssistedAttribute extends TxAttribute {
+    readonly nKeys: number;
+    constructor(nKeys: number);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): NotaryAssistedAttributeJson;
+}
+export declare class Tx {
+    readonly version = 0;
+    nonce: number;
+    systemFee: bigint;
+    networkFee: bigint;
+    validUntilBlock: number;
+    script: Uint8Array;
+    signers: Signer[];
+    attributes: TxAttribute[];
+    witnesses: Witness[];
+    constructor({ nonce, systemFee, networkFee, validUntilBlock, script, signers, witnesses, attributes, }: {
+        nonce: number;
+        systemFee: bigint | number;
+        networkFee: bigint | number;
+        validUntilBlock: number;
+        script: Uint8Array;
+        signers?: Signer[];
+        witnesses?: Witness[];
+        attributes?: TxAttribute[];
+    });
+    getSignData(networkId: number): Uint8Array;
+    marshalUnsignedTo(writer: BinaryWriter): void;
+    marshalTo(writer: BinaryWriter): void;
+    static unmarshalFrom(reader: BinaryReader): Tx;
+    toBytes(): Uint8Array;
+    toJSON(): {
+        version: number;
+        nonce: number;
+        sysfee: string;
+        netfee: string;
+        validuntilblock: number;
+        script: string;
+        signers: SignerJson[];
+        attributes: TxAttributeJson[];
+        witnesses: ReturnType<Witness["toJSON"]>[];
+    };
+}