@r3e/neo-js-sdk 0.3.0

package/dist/core/tx.js

@@ -0,0 +1,252 @@
+import { createHash } from "node:crypto";
+import { bytesToBase64, encodeUInt32LE } from "../internal/bytes.js";
+import { H160, H256 } from "./hash.js";
+import { PublicKey } from "./keypair.js";
+import { BinaryWriter, serialize } from "./serializing.js";
+import { Witness, WitnessScope, witnessScopeName } from "./witness.js";
+import { WitnessRule } from "./witness-rule.js";
+function sha256(data) {
+    return createHash("sha256").update(data).digest();
+}
+export class Signer {
+    account;
+    scopes;
+    allowedContracts;
+    allowedGroups;
+    rules;
+    constructor({ account, scopes, allowedContracts = [], allowedGroups = [], rules = [], }) {
+        this.account = typeof account === "string" ? new H160(account) : account;
+        this.scopes = scopes;
+        this.allowedContracts = allowedContracts.map((contract) => typeof contract === "string" ? new H160(contract) : contract);
+        this.allowedGroups = allowedGroups.map((group) => (typeof group === "string" ? new PublicKey(group) : group));
+        this.rules = rules;
+    }
+    toJSON() {
+        return {
+            account: this.account.toString(),
+            scopes: witnessScopeName(this.scopes),
+            allowedcontracts: this.allowedContracts.map((contract) => contract.toString()),
+            allowedgroups: this.allowedGroups.map((group) => group.toString()),
+            rules: this.rules.map((rule) => rule.toJSON()),
+        };
+    }
+    marshalTo(writer) {
+        this.account.marshalTo(writer);
+        writer.writeUInt8(this.scopes);
+        if (this.scopes & WitnessScope.CustomContracts) {
+            writer.writeMultiple(this.allowedContracts);
+        }
+        if (this.scopes & WitnessScope.CustomGroups) {
+            writer.writeMultiple(this.allowedGroups);
+        }
+        if (this.scopes & WitnessScope.WitnessRules) {
+            writer.writeMultiple(this.rules);
+        }
+    }
+    static unmarshalFrom(reader) {
+        const account = H160.unmarshalFrom(reader);
+        const scopes = reader.readUInt8();
+        const allowedContracts = scopes & WitnessScope.CustomContracts ? reader.readMultiple(H160) : [];
+        const allowedGroups = scopes & WitnessScope.CustomGroups ? reader.readMultiple(PublicKey) : [];
+        const rules = scopes & WitnessScope.WitnessRules ? reader.readMultiple(WitnessRule) : [];
+        return new Signer({ account, scopes, allowedContracts, allowedGroups, rules });
+    }
+}
+export var TxAttributeType;
+(function (TxAttributeType) {
+    TxAttributeType[TxAttributeType["HighPriority"] = 1] = "HighPriority";
+    TxAttributeType[TxAttributeType["OracleResponse"] = 17] = "OracleResponse";
+    TxAttributeType[TxAttributeType["NotValidBefore"] = 32] = "NotValidBefore";
+    TxAttributeType[TxAttributeType["Conflicts"] = 33] = "Conflicts";
+    TxAttributeType[TxAttributeType["NotaryAssisted"] = 34] = "NotaryAssisted";
+})(TxAttributeType || (TxAttributeType = {}));
+export var OracleResponseCode;
+(function (OracleResponseCode) {
+    OracleResponseCode[OracleResponseCode["Success"] = 0] = "Success";
+    OracleResponseCode[OracleResponseCode["ProtocolNotSupported"] = 16] = "ProtocolNotSupported";
+    OracleResponseCode[OracleResponseCode["ConsensusUnreachable"] = 18] = "ConsensusUnreachable";
+    OracleResponseCode[OracleResponseCode["NotFound"] = 20] = "NotFound";
+    OracleResponseCode[OracleResponseCode["Timeout"] = 22] = "Timeout";
+    OracleResponseCode[OracleResponseCode["Forbidden"] = 24] = "Forbidden";
+    OracleResponseCode[OracleResponseCode["ResponseTooLarge"] = 26] = "ResponseTooLarge";
+    OracleResponseCode[OracleResponseCode["InsufficientFunds"] = 28] = "InsufficientFunds";
+    OracleResponseCode[OracleResponseCode["ContentTypeNotSupported"] = 31] = "ContentTypeNotSupported";
+    OracleResponseCode[OracleResponseCode["Error"] = 255] = "Error";
+})(OracleResponseCode || (OracleResponseCode = {}));
+export class TxAttribute {
+    type;
+    constructor(type) {
+        this.type = type;
+    }
+    marshalTo(writer) {
+        writer.writeUInt8(this.type);
+    }
+    static unmarshalFrom(reader) {
+        const type = reader.readUInt8();
+        switch (type) {
+            case TxAttributeType.HighPriority:
+                return new HighPriorityAttribute();
+            case TxAttributeType.OracleResponse:
+                return new OracleResponseAttribute(reader.readUInt64LE(), reader.readUInt8(), reader.readVarBytes());
+            case TxAttributeType.NotValidBefore:
+                return new NotValidBeforeAttribute(reader.readUInt32LE());
+            case TxAttributeType.Conflicts:
+                return new ConflictsAttribute(H256.unmarshalFrom(reader));
+            case TxAttributeType.NotaryAssisted:
+                return new NotaryAssistedAttribute(reader.readUInt8());
+            default:
+                throw new Error(`unexpected TxAttributeType: ${type}`);
+        }
+    }
+    toJSON() {
+        return { type: TxAttributeType[this.type] };
+    }
+}
+export class HighPriorityAttribute extends TxAttribute {
+    constructor() {
+        super(TxAttributeType.HighPriority);
+    }
+    toJSON() {
+        return { type: "HighPriority" };
+    }
+}
+export class OracleResponseAttribute extends TxAttribute {
+    id;
+    code;
+    result;
+    constructor(id, code, result) {
+        super(TxAttributeType.OracleResponse);
+        this.id = id;
+        this.code = code;
+        this.result = result;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        writer.writeUInt64LE(this.id);
+        writer.writeUInt8(this.code);
+        writer.writeVarBytes(this.result);
+    }
+    toJSON() {
+        return {
+            type: "OracleResponse",
+            id: this.id.toString(),
+            code: OracleResponseCode[this.code],
+            result: bytesToBase64(this.result),
+        };
+    }
+}
+export class NotValidBeforeAttribute extends TxAttribute {
+    height;
+    constructor(height) {
+        super(TxAttributeType.NotValidBefore);
+        this.height = height;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        writer.writeUInt32LE(this.height);
+    }
+    toJSON() {
+        return { type: "NotValidBefore", height: this.height };
+    }
+}
+export class ConflictsAttribute extends TxAttribute {
+    hash;
+    constructor(hash) {
+        super(TxAttributeType.Conflicts);
+        this.hash = hash;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        this.hash.marshalTo(writer);
+    }
+    toJSON() {
+        return { type: "Conflicts", hash: this.hash.toString() };
+    }
+}
+export class NotaryAssistedAttribute extends TxAttribute {
+    nKeys;
+    constructor(nKeys) {
+        super(TxAttributeType.NotaryAssisted);
+        this.nKeys = nKeys;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        writer.writeUInt8(this.nKeys);
+    }
+    toJSON() {
+        return { type: "NotaryAssisted", nkeys: this.nKeys };
+    }
+}
+export class Tx {
+    version = 0;
+    nonce;
+    systemFee;
+    networkFee;
+    validUntilBlock;
+    script;
+    signers;
+    attributes;
+    witnesses;
+    constructor({ nonce, systemFee, networkFee, validUntilBlock, script, signers = [], witnesses = [], attributes = [], }) {
+        this.nonce = nonce;
+        this.systemFee = BigInt(systemFee);
+        this.networkFee = BigInt(networkFee);
+        this.validUntilBlock = validUntilBlock;
+        this.script = script;
+        this.signers = signers;
+        this.attributes = attributes;
+        this.witnesses = witnesses;
+    }
+    getSignData(networkId) {
+        const writer = new BinaryWriter();
+        this.marshalUnsignedTo(writer);
+        const digest = sha256(writer.toBytes());
+        return new Uint8Array([...encodeUInt32LE(networkId), ...digest]);
+    }
+    marshalUnsignedTo(writer) {
+        writer.writeUInt8(this.version);
+        writer.writeUInt32LE(this.nonce);
+        writer.writeUInt64LE(this.systemFee);
+        writer.writeUInt64LE(this.networkFee);
+        writer.writeUInt32LE(this.validUntilBlock);
+        writer.writeMultiple(this.signers);
+        writer.writeMultiple(this.attributes);
+        writer.writeVarBytes(this.script);
+    }
+    marshalTo(writer) {
+        this.marshalUnsignedTo(writer);
+        writer.writeMultiple(this.witnesses);
+    }
+    static unmarshalFrom(reader) {
+        const version = reader.readUInt8();
+        if (version !== 0) {
+            throw new Error(`unexpected tx version: ${version}`);
+        }
+        return new Tx({
+            nonce: reader.readUInt32LE(),
+            systemFee: reader.readUInt64LE(),
+            networkFee: reader.readUInt64LE(),
+            validUntilBlock: reader.readUInt32LE(),
+            signers: reader.readMultiple(Signer),
+            attributes: reader.readMultiple(TxAttribute),
+            script: reader.readVarBytes(),
+            witnesses: reader.readMultiple(Witness),
+        });
+    }
+    toBytes() {
+        return serialize(this);
+    }
+    toJSON() {
+        return {
+            version: this.version,
+            nonce: this.nonce,
+            sysfee: this.systemFee.toString(),
+            netfee: this.networkFee.toString(),
+            validuntilblock: this.validUntilBlock,
+            script: bytesToBase64(this.script),
+            signers: this.signers.map((signer) => signer.toJSON()),
+            attributes: this.attributes.map((attribute) => attribute.toJSON()),
+            witnesses: this.witnesses.map((witness) => witness.toJSON()),
+        };
+    }
+}

package/dist/core/witness-rule.d.ts

@@ -0,0 +1,128 @@
+import { H160 } from "./hash.js";
+import { PublicKey } from "./keypair.js";
+import { BinaryReader, BinaryWriter } from "./serializing.js";
+export interface BaseWitnessConditionJson {
+    type: string;
+}
+export interface BooleanConditionJson {
+    type: "Boolean";
+    expression: boolean;
+}
+export interface NotConditionJson {
+    type: "Not";
+    expression: WitnessConditionJson;
+}
+export interface AndConditionJson {
+    type: "And";
+    expressions: WitnessConditionJson[];
+}
+export interface OrConditionJson {
+    type: "Or";
+    expressions: WitnessConditionJson[];
+}
+export interface ScriptHashConditionJson {
+    type: "ScriptHash";
+    hash: string;
+}
+export interface GroupConditionJson {
+    type: "Group";
+    group: string;
+}
+export interface CalledByEntryConditionJson {
+    type: "CalledByEntry";
+}
+export interface CalledByContractConditionJson {
+    type: "CalledByContract";
+    hash: string;
+}
+export interface CalledByGroupConditionJson {
+    type: "CalledByGroup";
+    group: string;
+}
+export type WitnessConditionJson = BooleanConditionJson | NotConditionJson | AndConditionJson | OrConditionJson | ScriptHashConditionJson | GroupConditionJson | CalledByEntryConditionJson | CalledByContractConditionJson | CalledByGroupConditionJson;
+export interface WitnessRuleJson {
+    action: "Deny" | "Allow";
+    conditions: WitnessConditionJson[];
+}
+export declare enum WitnessRuleAction {
+    Deny = 0,
+    Allow = 1
+}
+export declare enum WitnessConditionType {
+    Boolean = 0,
+    Not = 1,
+    And = 2,
+    Or = 3,
+    ScriptHash = 24,
+    Group = 25,
+    CalledByEntry = 32,
+    CalledByContract = 40,
+    CalledByGroup = 41
+}
+export declare abstract class WitnessCondition {
+    readonly type: WitnessConditionType;
+    protected constructor(type: WitnessConditionType);
+    marshalTo(writer: BinaryWriter): void;
+    static unmarshalFrom(reader: BinaryReader): WitnessCondition;
+    toJSON(): WitnessConditionJson;
+}
+export declare class BooleanCondition extends WitnessCondition {
+    readonly expression: boolean;
+    constructor(expression: boolean);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): BooleanConditionJson;
+}
+export declare class NotCondition extends WitnessCondition {
+    readonly expression: WitnessCondition;
+    constructor(expression: WitnessCondition);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): NotConditionJson;
+}
+export declare class AndCondition extends WitnessCondition {
+    readonly expressions: WitnessCondition[];
+    constructor(expressions: WitnessCondition[]);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): AndConditionJson;
+}
+export declare class OrCondition extends WitnessCondition {
+    readonly expressions: WitnessCondition[];
+    constructor(expressions: WitnessCondition[]);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): OrConditionJson;
+}
+export declare class ScriptHashCondition extends WitnessCondition {
+    readonly hash: H160;
+    constructor(hash: H160);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): ScriptHashConditionJson;
+}
+export declare class GroupCondition extends WitnessCondition {
+    readonly group: PublicKey;
+    constructor(group: PublicKey);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): GroupConditionJson;
+}
+export declare class CalledByEntryCondition extends WitnessCondition {
+    constructor();
+    toJSON(): CalledByEntryConditionJson;
+}
+export declare class CalledByContractCondition extends WitnessCondition {
+    readonly hash: H160;
+    constructor(hash: H160);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): CalledByContractConditionJson;
+}
+export declare class CalledByGroupCondition extends WitnessCondition {
+    readonly group: PublicKey;
+    constructor(group: PublicKey);
+    marshalTo(writer: BinaryWriter): void;
+    toJSON(): CalledByGroupConditionJson;
+}
+export declare class WitnessRule {
+    readonly action: WitnessRuleAction;
+    readonly conditions: WitnessCondition[];
+    constructor(action: WitnessRuleAction, conditions: WitnessCondition[]);
+    marshalTo(writer: BinaryWriter): void;
+    static unmarshalFrom(reader: BinaryReader): WitnessRule;
+    toJSON(): WitnessRuleJson;
+}

package/dist/core/witness-rule.js

@@ -0,0 +1,201 @@
+import { H160 } from "./hash.js";
+import { PublicKey } from "./keypair.js";
+export var WitnessRuleAction;
+(function (WitnessRuleAction) {
+    WitnessRuleAction[WitnessRuleAction["Deny"] = 0] = "Deny";
+    WitnessRuleAction[WitnessRuleAction["Allow"] = 1] = "Allow";
+})(WitnessRuleAction || (WitnessRuleAction = {}));
+export var WitnessConditionType;
+(function (WitnessConditionType) {
+    WitnessConditionType[WitnessConditionType["Boolean"] = 0] = "Boolean";
+    WitnessConditionType[WitnessConditionType["Not"] = 1] = "Not";
+    WitnessConditionType[WitnessConditionType["And"] = 2] = "And";
+    WitnessConditionType[WitnessConditionType["Or"] = 3] = "Or";
+    WitnessConditionType[WitnessConditionType["ScriptHash"] = 24] = "ScriptHash";
+    WitnessConditionType[WitnessConditionType["Group"] = 25] = "Group";
+    WitnessConditionType[WitnessConditionType["CalledByEntry"] = 32] = "CalledByEntry";
+    WitnessConditionType[WitnessConditionType["CalledByContract"] = 40] = "CalledByContract";
+    WitnessConditionType[WitnessConditionType["CalledByGroup"] = 41] = "CalledByGroup";
+})(WitnessConditionType || (WitnessConditionType = {}));
+export class WitnessCondition {
+    type;
+    constructor(type) {
+        this.type = type;
+    }
+    marshalTo(writer) {
+        writer.writeUInt8(this.type);
+    }
+    static unmarshalFrom(reader) {
+        const type = reader.readUInt8();
+        switch (type) {
+            case WitnessConditionType.Boolean:
+                return new BooleanCondition(reader.readBool());
+            case WitnessConditionType.Not:
+                return new NotCondition(WitnessCondition.unmarshalFrom(reader));
+            case WitnessConditionType.And:
+                return new AndCondition(reader.readMultiple(WitnessCondition));
+            case WitnessConditionType.Or:
+                return new OrCondition(reader.readMultiple(WitnessCondition));
+            case WitnessConditionType.ScriptHash:
+                return new ScriptHashCondition(H160.unmarshalFrom(reader));
+            case WitnessConditionType.Group:
+                return new GroupCondition(PublicKey.unmarshalFrom(reader));
+            case WitnessConditionType.CalledByEntry:
+                return new CalledByEntryCondition();
+            case WitnessConditionType.CalledByContract:
+                return new CalledByContractCondition(H160.unmarshalFrom(reader));
+            case WitnessConditionType.CalledByGroup:
+                return new CalledByGroupCondition(PublicKey.unmarshalFrom(reader));
+            default:
+                throw new Error(`unexpected WitnessConditionType: ${type}`);
+        }
+    }
+    toJSON() {
+        return { type: WitnessConditionType[this.type] };
+    }
+}
+export class BooleanCondition extends WitnessCondition {
+    expression;
+    constructor(expression) {
+        super(WitnessConditionType.Boolean);
+        this.expression = expression;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        writer.writeBool(this.expression);
+    }
+    toJSON() {
+        return { type: "Boolean", expression: this.expression };
+    }
+}
+export class NotCondition extends WitnessCondition {
+    expression;
+    constructor(expression) {
+        super(WitnessConditionType.Not);
+        this.expression = expression;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        this.expression.marshalTo(writer);
+    }
+    toJSON() {
+        return { type: "Not", expression: this.expression.toJSON() };
+    }
+}
+export class AndCondition extends WitnessCondition {
+    expressions;
+    constructor(expressions) {
+        super(WitnessConditionType.And);
+        this.expressions = expressions;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        writer.writeMultiple(this.expressions);
+    }
+    toJSON() {
+        return { type: "And", expressions: this.expressions.map((expression) => expression.toJSON()) };
+    }
+}
+export class OrCondition extends WitnessCondition {
+    expressions;
+    constructor(expressions) {
+        super(WitnessConditionType.Or);
+        this.expressions = expressions;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        writer.writeMultiple(this.expressions);
+    }
+    toJSON() {
+        return { type: "Or", expressions: this.expressions.map((expression) => expression.toJSON()) };
+    }
+}
+export class ScriptHashCondition extends WitnessCondition {
+    hash;
+    constructor(hash) {
+        super(WitnessConditionType.ScriptHash);
+        this.hash = hash;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        this.hash.marshalTo(writer);
+    }
+    toJSON() {
+        return { type: "ScriptHash", hash: this.hash.toString() };
+    }
+}
+export class GroupCondition extends WitnessCondition {
+    group;
+    constructor(group) {
+        super(WitnessConditionType.Group);
+        this.group = group;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        this.group.marshalTo(writer);
+    }
+    toJSON() {
+        return { type: "Group", group: this.group.toString() };
+    }
+}
+export class CalledByEntryCondition extends WitnessCondition {
+    constructor() {
+        super(WitnessConditionType.CalledByEntry);
+    }
+    toJSON() {
+        return { type: "CalledByEntry" };
+    }
+}
+export class CalledByContractCondition extends WitnessCondition {
+    hash;
+    constructor(hash) {
+        super(WitnessConditionType.CalledByContract);
+        this.hash = hash;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        this.hash.marshalTo(writer);
+    }
+    toJSON() {
+        return { type: "CalledByContract", hash: this.hash.toString() };
+    }
+}
+export class CalledByGroupCondition extends WitnessCondition {
+    group;
+    constructor(group) {
+        super(WitnessConditionType.CalledByGroup);
+        this.group = group;
+    }
+    marshalTo(writer) {
+        super.marshalTo(writer);
+        this.group.marshalTo(writer);
+    }
+    toJSON() {
+        return { type: "CalledByGroup", group: this.group.toString() };
+    }
+}
+export class WitnessRule {
+    action;
+    conditions;
+    constructor(action, conditions) {
+        this.action = action;
+        this.conditions = conditions;
+    }
+    marshalTo(writer) {
+        writer.writeUInt8(this.action);
+        writer.writeMultiple(this.conditions);
+    }
+    static unmarshalFrom(reader) {
+        const action = reader.readUInt8();
+        if (!Object.values(WitnessRuleAction).includes(action)) {
+            throw new Error(`unexpected WitnessRuleAction: ${action}`);
+        }
+        return new WitnessRule(action, reader.readMultiple(WitnessCondition));
+    }
+    toJSON() {
+        return {
+            action: this.action === WitnessRuleAction.Allow ? "Allow" : "Deny",
+            conditions: this.conditions.map((condition) => condition.toJSON())
+        };
+    }
+}

package/dist/core/witness.d.ts

@@ -0,0 +1,24 @@
+import { BinaryReader, BinaryWriter } from "./serializing.js";
+export declare enum WitnessScope {
+    None = 0,
+    CalledByEntry = 1,
+    CustomContracts = 16,
+    CustomGroups = 32,
+    WitnessRules = 64,
+    Global = 128
+}
+export declare function witnessScopeName(scope: WitnessScope): string;
+export declare class Witness {
+    invocation: Uint8Array;
+    verification: Uint8Array;
+    constructor(invocation: Uint8Array, verification: Uint8Array);
+    get invocationScript(): Uint8Array;
+    get verificationScript(): Uint8Array;
+    marshalTo(writer: BinaryWriter): void;
+    static unmarshalFrom(reader: BinaryReader): Witness;
+    toJSON(): {
+        invocation: string;
+        verification: string;
+    };
+    equals(other: Witness): boolean;
+}

package/dist/core/witness.js

@@ -0,0 +1,62 @@
+import { bytesToBase64, equalBytes } from "../internal/bytes.js";
+export var WitnessScope;
+(function (WitnessScope) {
+    WitnessScope[WitnessScope["None"] = 0] = "None";
+    WitnessScope[WitnessScope["CalledByEntry"] = 1] = "CalledByEntry";
+    WitnessScope[WitnessScope["CustomContracts"] = 16] = "CustomContracts";
+    WitnessScope[WitnessScope["CustomGroups"] = 32] = "CustomGroups";
+    WitnessScope[WitnessScope["WitnessRules"] = 64] = "WitnessRules";
+    WitnessScope[WitnessScope["Global"] = 128] = "Global";
+})(WitnessScope || (WitnessScope = {}));
+export function witnessScopeName(scope) {
+    if (scope === WitnessScope.None) {
+        return "None";
+    }
+    const flags = [];
+    if (scope & WitnessScope.CalledByEntry) {
+        flags.push("CalledByEntry");
+    }
+    if (scope & WitnessScope.CustomContracts) {
+        flags.push("CustomContracts");
+    }
+    if (scope & WitnessScope.CustomGroups) {
+        flags.push("CustomGroups");
+    }
+    if (scope & WitnessScope.WitnessRules) {
+        flags.push("WitnessRules");
+    }
+    if (scope & WitnessScope.Global) {
+        flags.push("Global");
+    }
+    return flags.join(",");
+}
+export class Witness {
+    invocation;
+    verification;
+    constructor(invocation, verification) {
+        this.invocation = invocation;
+        this.verification = verification;
+    }
+    get invocationScript() {
+        return this.invocation;
+    }
+    get verificationScript() {
+        return this.verification;
+    }
+    marshalTo(writer) {
+        writer.writeVarBytes(this.invocation);
+        writer.writeVarBytes(this.verification);
+    }
+    static unmarshalFrom(reader) {
+        return new Witness(reader.readVarBytes(), reader.readVarBytes());
+    }
+    toJSON() {
+        return {
+            invocation: bytesToBase64(this.invocation),
+            verification: bytesToBase64(this.verification),
+        };
+    }
+    equals(other) {
+        return equalBytes(this.invocation, other.invocation) && equalBytes(this.verification, other.verification);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { ADDRESS_VERSION, CRYPTOLIB_CONTRACT_HASH, GAS_CONTRACT_HASH, LEDGER_CONTRACT_HASH, MAIN_NETWORK_ID, NEO_CONTRACT_HASH, NOTARY_CONTRACT_HASH, ORACLE_CONTRACT_HASH, POLICY_CONTRACT_HASH, ROLE_MANAGEMENT_CONTRACT_HASH, STDLIB_CONTRACT_HASH, TEST_NETWORK_ID, addressVersion, cryptolibContractHash, gasContractHash, ledgerContractHash, mainNetworkId, neoContractHash, notaryContractHash, oracleContractHash, policyContractHash, roleManagementContractHash, stdlibContractHash, testNetworkId } from "./constants.js";
+export { base64ToBytes, bytesToBase64, bytesToHex, hexToBytes, reverseBytes, utf8ToBytes } from "./internal/bytes.js";
+export { H160, H256 } from "./core/hash.js";
+export { BinaryReader, BinaryWriter, deserialize, serialize } from "./core/serializing.js";
+export { Block, Header, TrimmedBlock } from "./core/block.js";
+export { PrivateKey, PublicKey } from "./core/keypair.js";
+export { CallFlags, ScriptBuilder, syscallCode } from "./core/script.js";
+export { OpCode } from "./core/opcode.js";
+export { Witness, WitnessScope, witnessScopeName } from "./core/witness.js";
+export { AndCondition, type AndConditionJson, type BaseWitnessConditionJson, type BooleanConditionJson, BooleanCondition, CalledByContractCondition, type CalledByContractConditionJson, CalledByEntryCondition, type CalledByEntryConditionJson, CalledByGroupCondition, type CalledByGroupConditionJson, GroupCondition, type GroupConditionJson, NotCondition, type NotConditionJson, OrCondition, type OrConditionJson, ScriptHashCondition, type ScriptHashConditionJson, WitnessCondition, type WitnessConditionJson, WitnessConditionType, WitnessRule, type WitnessRuleJson, WitnessRuleAction } from "./core/witness-rule.js";
+export { type BaseTxAttributeJson, type ConflictsAttributeJson, ConflictsAttribute, type HighPriorityAttributeJson, HighPriorityAttribute, type NotaryAssistedAttributeJson, NotValidBeforeAttribute, type NotValidBeforeAttributeJson, NotaryAssistedAttribute, type OracleResponseAttributeJson, OracleResponseAttribute, OracleResponseCode, Signer, type SignerJson, Tx, TxAttribute, type TxAttributeJson, TxAttributeType } from "./core/tx.js";
+export { InvokeParameters, JsonRpc, JsonRpcError, RpcClient, RpcCode, mainnetEndpoints, testnetEndpoints } from "./rpcclient/index.js";
+export { buildStackParser, parseInvokeStack, parseStackItemArray, parseStackItemBoolean, parseStackItemBytes, parseStackItemInteger, parseStackItemMap, parseStackItemStruct, parseStackItemUtf8 } from "./rpcclient/parse.js";
+export type { ApplicationLogExecution, ApplicationLogInvocation, CalculateNetworkFeeInput, CancelTransactionResult, CancelTransactionInput, CloseWalletResult, DumpPrivKeyInput, DumpPrivKeyResult, FindStatesInput, FindStatesResult, FindStorageEntry, FindStorageInput, FindStorageResult, GetApplicationLogInput, GetApplicationLogResult, GetBlockHashInput, GetBlockHeaderInput, GetBlockHeaderCountResult, GetBlockHeaderVerboseResult, GetBlockInput, GetBlockVerboseResult, GetCandidatesResult, GetConnectionCountResult, GetContractStateInput, GetContractStateManifestAbiResult, GetContractStateManifestEventResult, GetContractStateManifestGroupResult, GetContractStateManifestMethodResult, GetContractStateManifestParameterResult, GetContractStateManifestPermissionResult, GetContractStateManifestResult, GetContractStateNefMethodTokenResult, GetContractStateNefResult, GetContractStateResult, GetNativeContractsResult, GetNep11BalancesInput, GetNep11BalancesResult, GetNep11PropertiesInput, GetNep11PropertiesResult, GetNep11PropertyValueResult, GetNep11TransfersInput, GetNep11TransfersResult, GetNep17BalancesResult, GetNep17BalancesInput, GetNep17TransfersInput, GetNep17TransfersResult, GetNewAddressResult, GetPeersResult, GetProofInput, GetProofResult, GetRawMemPoolResult, GetRawMemPoolVerboseResult, GetRawTransactionInput, GetRawTransactionResult, GetStateInput, GetStateHeightResult, GetStateResult, GetStateRootInput, GetStateRootResult, GetStorageInput, GetStorageResult, GetTransactionHeightInput, GetUnclaimedGasInput, GetUnclaimedGasResult, GetUnspentsInput, GetUnspentsResult, GetVersionHardforkResult, GetVersionProtocolResult, GetVersionResult, GetVersionRpcSettingsResult, GetWalletBalanceInput, GetWalletUnclaimedGasResult, ImportPrivKeyInput, ImportPrivKeyResult, InvokeContractVerifyResult, InvokeContractVerifyInput, InvokeDiagnosticsInvocationTree, InvokeDiagnosticsResult, InvokeDiagnosticsStorageChange, InvokeFunctionInput, InvokeParametersLike, InvokeResult, InvokeScriptInput, ListAddressResult, ListPluginsResult, Nep11Balance, Nep11TokenBalance, Nep11TransferEvent, Nep17Balance, Nep17TransferEvent, NetworkFeeResult, NodePeer, OpenWalletResult, OpenWalletInput, PendingSignatureContextItem, PendingSignatureResult, RelayTransactionResult, RpcBinaryPayload, RpcAccountResult, RpcAnyStackItemJson, RpcArrayStackItemJson, RpcBaseStackItemJson, RpcBooleanStackItemJson, RpcBufferStackItemJson, RpcByteStringStackItemJson, RpcIntegerStackItemJson, RpcInteropInterfaceStackItemJson, RpcMapStackEntryJson, RpcMapStackItemJson, RpcNotification, RpcPlugin, RpcPointerStackItemJson, RpcSignerJson, RpcSignerInput, RpcStackItemJson, RpcStructStackItemJson, RpcValidatorResult, RpcWitnessJson, SendFromInput, SendManyInput, SendManyTransferInput, SendRawTransactionResult, SendRawTransactionInput, SendToAddressInput, SubmitBlockResult, SubmitBlockInput, TerminateSessionResult, TraverseIteratorInput, TransactionJsonResult, TraverseIteratorResult, UnspentBalance, UnspentTransaction, ValidateAddressInput, ValidateAddressResult, VerifyProofInput, WalletBalanceResult } from "./rpcclient/types.js";
+export { Account, Contract, Parameter, ScryptParams, Wallet, decryptSecp256r1Key, encryptSecp256r1Key } from "./wallet/index.js";
+export { hash160, hexstring2str, num2hexstring, reverseHex, str2hexstring } from "./utils.js";