universa-core2 2.0.0-alpha.1

package/dist/index.cjs

@@ -0,0 +1,2140 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Capsule: () => Capsule,
+  ChangeNumberPermission: () => ChangeNumberPermission,
+  ChangeOwnerPermission: () => ChangeOwnerPermission,
+  Compound: () => Compound,
+  Contract: () => Contract,
+  HashId: () => HashId,
+  KeyRecord: () => KeyRecord,
+  ModifyDataPermission: () => ModifyDataPermission,
+  Network: () => Network,
+  Node: () => Node,
+  Parcel: () => Parcel,
+  Reference: () => Reference,
+  RevokePermission: () => RevokePermission,
+  RoleLink: () => RoleLink,
+  RoleList: () => RoleList,
+  RoleSimple: () => RoleSimple,
+  SplitJoinPermission: () => SplitJoinPermission,
+  Topology: () => Topology,
+  TransactionPack: () => TransactionPack,
+  UniversaContract: () => UniversaContract
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("unicrypto"), module.exports);
+
+// src/models/universa_contract.ts
+var import_unicrypto2 = require("unicrypto");
+
+// src/boss.ts
+var import_unicrypto = require("unicrypto");
+var BossSingleton = class _BossSingleton {
+  constructor() {
+  }
+  static getInstance() {
+    if (!_BossSingleton.instance) {
+      _BossSingleton.instance = new _BossSingleton();
+    }
+    return _BossSingleton.instance;
+  }
+  register(alias, clz) {
+    return import_unicrypto.Boss.register(alias, clz);
+  }
+  dump(data) {
+    return import_unicrypto.Boss.dump(data);
+  }
+  load(packed) {
+    return import_unicrypto.Boss.load(packed);
+  }
+};
+var boss_default = BossSingleton;
+
+// src/models/roles/role_link.ts
+var boss = boss_default.getInstance();
+var RoleLink = class _RoleLink {
+  constructor(name, targetName) {
+    this.name = name;
+    this.targetName = targetName;
+  }
+  resolve(roles = {}, nestedLevel = 0) {
+    if (nestedLevel >= 100) throw new Error(`Role "${this.name}" is circular`);
+    const target = roles[this.targetName];
+    if (!target) throw new Error(`Target role "${this.targetName}" is not found`);
+    return target.resolve(roles, nestedLevel + 1);
+  }
+  async getSimpleAddress(roles = {}, ignoreRefs = true) {
+    const target = this.resolve(roles);
+    return target.getSimpleAddress(roles, ignoreRefs);
+  }
+  async availableFor(options) {
+    const finalTarget = this.resolve(options.roles);
+    return finalTarget.availableFor(options);
+  }
+  static {
+    // BOSS serialization definitions
+    this.className = "RoleLink";
+  }
+  serializeToBOSS() {
+    return {
+      "name": this.name,
+      "target_name": this.targetName
+    };
+  }
+  static deserializeFromBOSS(serialized) {
+    return new _RoleLink(serialized.name, serialized["target_name"]);
+  }
+};
+boss.register("RoleLink", RoleLink);
+
+// src/models/reference.ts
+var boss2 = boss_default.getInstance();
+var Reference = class _Reference {
+  constructor(name, type, where) {
+    this.fields = [];
+    this.roles = [];
+    this.signedBy = [];
+    this.transactionalId = "";
+    this.required = true;
+    this.name = name;
+    this.type = type;
+    this.where = where;
+  }
+  static {
+    this.className = "Reference";
+  }
+  static {
+    this.TYPE_TRANSACTIONAL = 1 /* TYPE_TRANSACTIONAL */;
+  }
+  static {
+    this.TYPE_EXISTING_DEFINITION = 2 /* TYPE_EXISTING_DEFINITION */;
+  }
+  static {
+    this.TYPE_EXISTING_STATE = 3 /* TYPE_EXISTING_STATE */;
+  }
+  serializeToBOSS() {
+    return {
+      "fields": this.fields,
+      "roles": this.roles,
+      "signed_by": this.signedBy,
+      "transactional_id": this.transactionalId,
+      "required": this.required,
+      "name": this.name,
+      "type": this.type,
+      "where": this.where
+    };
+  }
+  static deserializeFromBOSS(serialized) {
+    const ref = new _Reference(
+      serialized["name"],
+      serialized["type"],
+      serialized["where"]
+    );
+    ref.required = serialized.required;
+    ref.transactionalId = serialized["transactional_id"];
+    return ref;
+  }
+};
+boss2.register("Reference", Reference);
+
+// src/models/permissions/permission.ts
+var Permission = class _Permission {
+  constructor(role, params, name = _Permission.DefaultName) {
+    this.name = name;
+    this.role = role;
+    this.params = params;
+  }
+  static makeLink(name, roleName) {
+    return new RoleLink(`@${name}`, roleName);
+  }
+  availableFor(options) {
+    return this.role.availableFor(options);
+  }
+  serializeToBOSS() {
+    return Object.assign({
+      "name": this.name,
+      "role": this.role
+    }, this.params);
+  }
+};
+
+// src/models/permissions/revoke_permission.ts
+var boss3 = boss_default.getInstance();
+var RevokePermission = class _RevokePermission extends Permission {
+  static {
+    this.DefaultName = "revoke";
+  }
+  static {
+    this.className = "RevokePermission";
+  }
+  constructor(role, name = _RevokePermission.DefaultName) {
+    super(role, {}, name);
+  }
+  static create(roleName, name = _RevokePermission.DefaultName) {
+    return new _RevokePermission(this.makeLink(name, roleName), name);
+  }
+  static deserializeFromBOSS(serialized) {
+    return new _RevokePermission(serialized.role, serialized.name);
+  }
+};
+boss3.register("RevokePermission", RevokePermission);
+
+// src/models/universa_contract.ts
+var boss4 = boss_default.getInstance();
+var DEFAULT_EXPIRES_AT = 5;
+var DEFAULT_API_LEVEL = 4;
+function uniqueShortId(existing) {
+  const maxIterations = 1e5;
+  let found = false;
+  let id = "";
+  let i = 0;
+  while (i < maxIterations && !found) {
+    id = (0, import_unicrypto2.shortId)();
+    if (existing.indexOf(id) !== -1) found = true;
+    i++;
+  }
+  return id;
+}
+var UniversaContract = class _UniversaContract {
+  constructor(apiLevel, definition, state, transactional) {
+    this.apiLevel = apiLevel;
+    this.definition = definition;
+    this.state = state;
+    this.transactional = transactional;
+  }
+  static create(issuer, options) {
+    const opts = options || {};
+    const expiresAtOpt = opts.expiresAt;
+    const createdAt = opts.createdAt || /* @__PURE__ */ new Date();
+    let expiresAt = new Date(createdAt.getTime());
+    if (!expiresAtOpt) {
+      expiresAt.setFullYear(expiresAt.getFullYear() + DEFAULT_EXPIRES_AT);
+    } else if (typeof expiresAtOpt === "string") {
+      const tpe = expiresAtOpt.slice(-1);
+      const amount = parseInt(expiresAtOpt.slice(0, expiresAtOpt.length - 1));
+      if (tpe === "d") expiresAt.setDate(expiresAt.getDate() + amount);
+      if (tpe === "m") expiresAt.setMonth(expiresAt.getMonth() + amount);
+      if (tpe === "y") expiresAt.setFullYear(expiresAt.getFullYear() + amount);
+    } else {
+      expiresAt = expiresAtOpt;
+    }
+    const revokePermission = RevokePermission.create("owner");
+    const revokeId = (0, import_unicrypto2.shortId)();
+    const definition = {
+      createdAt,
+      issuer,
+      permissions: { [revokeId]: revokePermission },
+      data: {},
+      references: []
+    };
+    const state = {
+      createdAt,
+      creator: new RoleLink("creator", "issuer"),
+      revision: 1,
+      owner: new RoleLink("owner", "issuer"),
+      expiresAt,
+      data: {},
+      parent: null,
+      origin: null,
+      branchId: null,
+      roles: {},
+      references: []
+    };
+    return new _UniversaContract(DEFAULT_API_LEVEL, definition, state, null);
+  }
+  get issuer() {
+    return this.definition.issuer;
+  }
+  get owner() {
+    return this.state.owner;
+  }
+  set owner(role) {
+    this.state.owner = role;
+  }
+  get creator() {
+    return this.state.creator;
+  }
+  set creator(role) {
+    this.state.creator = role;
+  }
+  get parent() {
+    return this.state.parent;
+  }
+  get origin() {
+    return this.state.origin;
+  }
+  addPermission(permission) {
+    const id = uniqueShortId(Object.keys(this.definition.permissions));
+    this.definition.permissions[id] = permission;
+  }
+  removePermission(permissionId) {
+    delete this.definition.permissions[permissionId];
+  }
+  setParent(id) {
+    this.state.parent = id;
+  }
+  setOrigin(id) {
+    this.state.origin = id;
+  }
+  setCreatorTo(roleName) {
+    this.state.creator = new RoleLink("creator", roleName);
+  }
+  incrementRevision() {
+    this.state.revision += 1;
+  }
+  static {
+    this.className = "UniversaContract";
+  }
+  serializeToBOSS() {
+    const d = this.definition;
+    const s = this.state;
+    const definitionSerialized = {
+      "issuer": d.issuer,
+      "permissions": d.permissions,
+      "created_at": d.createdAt,
+      "data": d.data,
+      "references": d.references
+    };
+    const stateSerialized = {
+      "created_at": s.createdAt,
+      "expires_at": s.expiresAt,
+      "owner": s.owner,
+      "created_by": s.creator,
+      "data": s.data,
+      "revision": s.revision,
+      "roles": s.roles,
+      "parent": s.parent,
+      "origin": s.origin,
+      "branch_id": s.branchId,
+      "references": s.references
+    };
+    const serialized = {
+      api_level: this.apiLevel,
+      definition: definitionSerialized,
+      state: stateSerialized
+    };
+    if (this.transactional || this.transactional === null)
+      serialized.transactional = this.transactional;
+    return serialized;
+  }
+  static deserializeFromBOSS(serialized) {
+    const apiLevel = serialized["api_level"];
+    const rawDefinition = serialized.definition;
+    const rawState = serialized.state;
+    let stateRoles = rawState.roles || {};
+    if (stateRoles instanceof Array) stateRoles = {};
+    const definition = {
+      issuer: rawDefinition.issuer,
+      permissions: rawDefinition.permissions,
+      createdAt: rawDefinition["created_at"],
+      data: rawDefinition.data,
+      references: rawDefinition.references || []
+    };
+    const state = {
+      createdAt: rawState["created_at"],
+      expiresAt: rawState["expires_at"],
+      owner: rawState.owner,
+      creator: rawState["created_by"],
+      data: rawState.data,
+      revision: rawState.revision,
+      roles: stateRoles,
+      parent: rawState.parent,
+      origin: rawState.origin,
+      branchId: rawState["branch_id"],
+      references: rawState.references || []
+    };
+    return new _UniversaContract(apiLevel, definition, state, serialized.transactional);
+  }
+  resetTransactional() {
+    this.transactional = null;
+  }
+  createTransactional(id) {
+    this.transactional = { id };
+  }
+  addReference(ref) {
+    if (ref.type === Reference.TYPE_TRANSACTIONAL && !this.transactional)
+      throw new Error("Can't add transactional reference: transaction is empty");
+    if (ref.type === Reference.TYPE_TRANSACTIONAL) {
+      this.transactional.references = this.transactional.references || [];
+      this.transactional.references.push(ref);
+    }
+    if (ref.type === Reference.TYPE_EXISTING_DEFINITION) {
+      this.definition.references = this.definition.references || [];
+      this.definition.references.push(ref);
+    }
+    if (ref.type === Reference.TYPE_EXISTING_STATE) {
+      this.state.references = this.state.references || [];
+      this.state.references.push(ref);
+    }
+  }
+};
+boss4.register("UniversaContract", UniversaContract);
+
+// src/models/capsule.ts
+var boss5 = boss_default.getInstance();
+var Capsule = class _Capsule {
+  constructor(contract, options) {
+    this.new = [];
+    this.revoking = [];
+    this.contract = contract;
+    if (options) {
+      this.new = options.new || [];
+      this.revoking = options.revoking || [];
+    }
+  }
+  static unpack(bin) {
+    const raw = boss5.load(bin);
+    return new _Capsule(raw.contract, { new: raw.new, revoking: raw.revoking });
+  }
+  static create(issuer, options) {
+    const opts = options || {};
+    const contract = UniversaContract.create(issuer, {
+      createdAt: opts.createdAt,
+      expiresAt: opts.expiresAt
+    });
+    if (opts.definitionData) contract.definition.data = opts.definitionData;
+    if (opts.stateData) contract.state.data = opts.stateData;
+    if (opts.permissions)
+      opts.permissions.forEach((p) => contract.addPermission(p));
+    if (opts.owner) contract.owner = opts.owner;
+    return new _Capsule(contract);
+  }
+  get issuer() {
+    return this.contract.issuer;
+  }
+  get owner() {
+    return this.contract.owner;
+  }
+  set owner(role) {
+    this.contract.owner = role;
+  }
+  get creator() {
+    return this.contract.creator;
+  }
+  set creator(role) {
+    this.contract.creator = role;
+  }
+  get parent() {
+    return this.contract.parent;
+  }
+  get origin() {
+    return this.contract.origin;
+  }
+  get definition() {
+    return this.contract.definition;
+  }
+  get state() {
+    return this.contract.state;
+  }
+  get transactional() {
+    return this.contract.transactional;
+  }
+  pack() {
+    return boss5.dump({
+      contract: this.contract,
+      new: this.new,
+      revoking: this.revoking
+    });
+  }
+};
+
+// src/models/contract.ts
+var import_unicrypto4 = require("unicrypto");
+
+// src/models/hash_id.ts
+var import_unicrypto3 = require("unicrypto");
+var boss6 = boss_default.getInstance();
+var HashId = class _HashId {
+  constructor(composite3) {
+    this.composite3 = composite3;
+  }
+  static async calculate(bin) {
+    return new _HashId(await (0, import_unicrypto3.hashId)(bin));
+  }
+  get base64() {
+    return (0, import_unicrypto3.encode64)(this.composite3);
+  }
+  equals(hashId2) {
+    return this.base64 === hashId2.base64;
+  }
+  static {
+    this.className = "HashId";
+  }
+  serializeToBOSS() {
+    return { composite3: this.composite3 };
+  }
+  static deserializeFromBOSS(serialized) {
+    return new _HashId(serialized.composite3);
+  }
+  static unpack(bin) {
+    return boss6.load(bin);
+  }
+  pack() {
+    return boss6.dump(this);
+  }
+};
+boss6.register("HashId", HashId);
+
+// src/models/contract.ts
+var boss7 = boss_default.getInstance();
+var Contract = class _Contract {
+  constructor(data, signatures, options) {
+    this.binary = null;
+    this.type = "unicapsule";
+    this.version = 4;
+    this.data = data;
+    this.capsule = Capsule.unpack(data);
+    this.signatures = signatures || [];
+    if (options) {
+      this.type = options.type || this.type;
+      this.version = options.version || this.version;
+      this.binary = options.binary || this.binary;
+    }
+  }
+  get issuer() {
+    return this.capsule.issuer;
+  }
+  get owner() {
+    return this.capsule.owner;
+  }
+  set owner(role) {
+    this.capsule.owner = role;
+  }
+  get creator() {
+    return this.capsule.creator;
+  }
+  set creator(role) {
+    this.capsule.creator = role;
+  }
+  setCreatorTo(roleName) {
+    this.capsule.contract.setCreatorTo(roleName);
+  }
+  get parent() {
+    return this.capsule.parent;
+  }
+  get origin() {
+    return this.capsule.origin;
+  }
+  get definition() {
+    return this.capsule.definition;
+  }
+  get state() {
+    return this.capsule.state;
+  }
+  get transactional() {
+    return this.capsule.transactional;
+  }
+  hashId() {
+    if (this.binary) return HashId.calculate(this.binary);
+    else throw new Error("contract is not packed yet");
+  }
+  async getSignatureKeys() {
+    const keys = [];
+    const signaturesTotal = this.signatures.length;
+    let i = 0;
+    const query = this.signatures.map(async (signature) => {
+      const { exts } = boss7.load(signature);
+      const targetSignature = boss7.load(exts);
+      return await import_unicrypto4.PublicKey.unpack(targetSignature["pub_key"]);
+    });
+    return await Promise.all(query);
+  }
+  async isSignedBy(options) {
+    const { publicKey, address } = options;
+    let signed = false;
+    let i = 0;
+    const signaturesTotal = this.signatures.length;
+    const data = this.data;
+    const self = this;
+    if (publicKey == null && address == null) throw new Error("No address or key was given");
+    async function verify(index) {
+      if (index >= signaturesTotal) return false;
+      const signature = self.signatures[index];
+      let pub = publicKey;
+      if (pub != null) {
+        const verified = await pub.verifyExtended(signature, data);
+        if (verified) return true;
+      } else {
+        const { exts } = boss7.load(signature);
+        const targetSignature = boss7.load(exts);
+        const unpackedKey = await import_unicrypto4.PublicKey.unpack(targetSignature["pub_key"]);
+        if (address?.isMatchingKey(unpackedKey)) return true;
+      }
+      return await verify(index + 1);
+    }
+    return await verify(0);
+  }
+  async sign(privateKey) {
+    const isSigned = await this.isSignedBy({ publicKey: privateKey.publicKey });
+    if (isSigned) return;
+    const signature = await privateKey.signExtended(this.data);
+    this.signatures.push(signature);
+  }
+  static create(issuer, options) {
+    const capsule = Capsule.create(issuer, options);
+    return new _Contract(capsule.pack());
+  }
+  packData() {
+    this.data = this.capsule.pack();
+    this.signatures = [];
+  }
+  pack() {
+    const packed = boss7.dump({
+      data: this.data,
+      signatures: this.signatures,
+      type: this.type,
+      version: this.version
+    });
+    this.binary = packed;
+    return packed;
+  }
+  async createRevision(createdAt) {
+    const parentId = await this.hashId();
+    if (!parentId || !this.binary)
+      throw new Error("Can't create revision of draft contract");
+    const newRevision = _Contract.unpack(this.binary);
+    const capsule = newRevision.capsule;
+    const unicontract = capsule.contract;
+    unicontract.incrementRevision();
+    if (!unicontract.origin) unicontract.setOrigin(parentId);
+    unicontract.setParent(parentId);
+    unicontract.state.createdAt = createdAt || /* @__PURE__ */ new Date();
+    capsule.new = [];
+    capsule.revoking = [parentId];
+    return newRevision;
+  }
+  static unpack(binary) {
+    const raw = boss7.load(binary);
+    return new _Contract(raw.data, raw.signatures, {
+      type: raw.type,
+      version: raw.version,
+      binary
+    });
+  }
+  resetTransactional() {
+    this.capsule.contract.resetTransactional();
+  }
+  createTransactional(id) {
+    this.capsule.contract.createTransactional(id);
+  }
+  addReference(ref) {
+    this.capsule.contract.addReference(ref);
+  }
+};
+
+// src/models/compound.ts
+var import_unicrypto5 = require("unicrypto");
+
+// src/models/transaction_pack.ts
+var boss8 = boss_default.getInstance();
+var TAG_PREFIX_RESERVED = "universa:";
+var TransactionPack = class _TransactionPack {
+  constructor(contractPacked, options) {
+    this.subItems = {};
+    this.referencedItems = {};
+    this.taggedItems = {};
+    const self = this;
+    const opts = options || {};
+    const subItemsPacked = opts.subItems || [];
+    const referencedItemsPacked = opts.referencedItems || [];
+    const tags = opts.tags || {};
+    this.contract = Contract.unpack(contractPacked);
+    this.ready = new Promise((resolve, reject) => {
+      const subLoaders = subItemsPacked.map(async (item) => {
+        const contract = Contract.unpack(item);
+        const hashId2 = await contract.hashId();
+        self.subItems[hashId2.base64] = contract;
+      });
+      const refLoaders = referencedItemsPacked.map(async (item) => {
+        const contract = Contract.unpack(item);
+        const hashId2 = await contract.hashId();
+        self.referencedItems[hashId2.base64] = contract;
+      });
+      const tagLoaders = [];
+      async function loadTag(tag) {
+        const hashId2 = tags[tag];
+        const hashId64 = hashId2.base64;
+        const contractId = await self.contract.hashId();
+        if (contractId.base64 === hashId64) self.taggedItems[tag] = {
+          contract: self.contract,
+          hashId: hashId2
+        };
+        const item = self.subItems[hashId64] || self.referencedItems[hashId64];
+        if (item) self.taggedItems[tag] = { hashId: hashId2, contract: item };
+      }
+      for (let tag in tags) tagLoaders.push(loadTag(tag));
+      const loaders = subLoaders.concat(refLoaders).concat(tagLoaders);
+      Promise.all(loaders).then(() => resolve());
+    });
+  }
+  async getItem(hashId2) {
+    await this.ready;
+    const hashId64 = hashId2.base64;
+    const contractId = await this.contract.hashId();
+    if (contractId.base64 === hashId64) return this.contract;
+    return this.subItems[hashId64] || this.referencedItems[hashId64];
+  }
+  async getTag(tag) {
+    await this.ready;
+    return this.taggedItems[tag];
+  }
+  async addTag(tag, hashId2) {
+    if (tag.startsWith(TAG_PREFIX_RESERVED))
+      throw new Error("tag can't start with reserved words");
+    await this.ready;
+    const contract = await this.getItem(hashId2);
+    if (!contract) throw new Error("Can't add tag for non-existing item");
+    this.taggedItems[tag] = {
+      hashId: hashId2,
+      contract
+    };
+  }
+  async addSubItem(itemPacked) {
+    const item = Contract.unpack(itemPacked);
+    const hashId2 = await item.hashId();
+    this.subItems[hashId2.base64] = item;
+  }
+  async addReferencedItem(itemPacked) {
+    const item = Contract.unpack(itemPacked);
+    const hashId2 = await item.hashId();
+    this.referencedItems[hashId2.base64] = item;
+  }
+  async pack() {
+    await this.ready;
+    return boss8.dump(this);
+  }
+  static unpack(packed) {
+    return boss8.load(packed);
+  }
+  static {
+    this.className = "TransactionPack";
+  }
+  serializeToBOSS() {
+    const subItems = [];
+    const referencedItems = [];
+    const tags = {};
+    for (let hashId64 in this.subItems) {
+      subItems.push(this.subItems[hashId64].binary);
+    }
+    for (let hashId64 in this.referencedItems) {
+      referencedItems.push(this.referencedItems[hashId64].binary);
+    }
+    for (let tag in this.taggedItems) {
+      tags[tag] = this.taggedItems[tag].hashId;
+    }
+    return {
+      contract: this.contract.binary,
+      subItems,
+      referencedItems,
+      tags
+    };
+  }
+  static deserializeFromBOSS(serialized) {
+    return new _TransactionPack(serialized.contract, {
+      subItems: serialized.subItems || [],
+      referencedItems: serialized.referencedItems || [],
+      tags: serialized.tags || {}
+    });
+  }
+  async sign(key) {
+    await this.contract.sign(key);
+    this.contract.pack();
+  }
+};
+boss8.register("TransactionPack", TransactionPack);
+
+// src/models/compound.ts
+var Compound = class _Compound {
+  constructor(tpack) {
+    this.tpack = tpack;
+  }
+  static unpack(bin) {
+    return new _Compound(TransactionPack.unpack(bin));
+  }
+  pack() {
+    return this.tpack.pack();
+  }
+  getDefinitionContracts() {
+    return this.tpack.contract.definition.data.contracts;
+  }
+  // create(expiresAt: Date) {
+  //   const contract =
+  // }
+  getTags() {
+    return Object.keys(this.getDefinitionContracts() || {});
+  }
+  sign(privateKey) {
+    return this.tpack.sign(privateKey);
+  }
+  async getTag(tag) {
+    const contracts = this.getDefinitionContracts() || {};
+    const contractInfo = contracts[tag];
+    if (!contractInfo) return null;
+    const mainId = new HashId((0, import_unicrypto5.decode64)(contractInfo.id));
+    const mainContract = await this.tpack.getItem(mainId);
+    const tpack = new TransactionPack(mainContract.binary);
+    const newItemIds = mainContract.capsule.new;
+    const revokingItemIds = mainContract.capsule.revoking;
+    const subItemIds = newItemIds.concat(revokingItemIds);
+    for (let i = 0; i < subItemIds.length; i++) {
+      let id = subItemIds[i];
+      let contract = await this.tpack.getItem(id);
+      await tpack.addSubItem(contract.binary);
+    }
+    const refs = contractInfo.refs || [];
+    for (let i = 0; i < refs.length; i++) {
+      let id = new HashId((0, import_unicrypto5.decode64)(refs[i]));
+      let contract = await this.tpack.getItem(id);
+      await tpack.addReferencedItem(contract.binary);
+    }
+    const tags = contractInfo.tags || {};
+    for (let tag2 in tags) {
+      let id = new HashId((0, import_unicrypto5.decode64)(tags[tag2]));
+      await tpack.addTag(tag2, id);
+    }
+    return tpack;
+  }
+  getItem(hashId2) {
+    return this.tpack.getItem(hashId2);
+  }
+};
+
+// src/models/parcel.ts
+var boss9 = boss_default.getInstance();
+var Parcel = class _Parcel {
+  constructor(payment, payload, hashId2) {
+    this.paymentBin = payment;
+    this.payloadBin = payload;
+    this.payment = boss9.load(payment);
+    this.payload = boss9.load(payload);
+    this.hashId = hashId2;
+  }
+  static {
+    this.className = "Parcel";
+  }
+  serializeToBOSS() {
+    return {
+      payment: this.paymentBin,
+      payload: this.payloadBin,
+      hashId: this.hashId
+    };
+  }
+  static deserializeFromBOSS(serialized) {
+    return new _Parcel(serialized.payment, serialized.payload, serialized.hashId);
+  }
+  static async create(payment, payload) {
+    const paymentId = (await HashId.calculate(payment)).composite3;
+    const payloadId = (await HashId.calculate(payload)).composite3;
+    const composite = new Uint8Array(paymentId.length + payloadId.length);
+    composite.set(paymentId);
+    composite.set(payloadId, paymentId.length);
+    const id = await HashId.calculate(composite);
+    return new _Parcel(payment, payload, id);
+  }
+  static async createPayment(amount, upack, options = {}) {
+    let key = "transaction_units";
+    if (options.isTestnet) key = "test_transaction_units";
+    const uOld = upack.contract;
+    if (!uOld.binary)
+      throw new Error("Can't create payment with draft u pack");
+    const balance = uOld.state.data[key];
+    if (amount > balance) throw new Error("not enough U");
+    const balanceNew = balance - amount;
+    const uNew = await uOld.createRevision(options.createdAt);
+    uNew.state.data[key] = balanceNew;
+    uNew.capsule.contract.setCreatorTo("owner");
+    uNew.packData();
+    return new TransactionPack(uNew.pack(), { subItems: [uOld.binary] });
+  }
+  pack() {
+    return boss9.dump(this);
+  }
+  static unpack(bin) {
+    return boss9.load(bin);
+  }
+};
+boss9.register("Parcel", Parcel);
+
+// src/models/key_record.ts
+var import_unicrypto6 = require("unicrypto");
+
+// src/utils.ts
+var fs = require("fs");
+async function retry(fn, options) {
+  const opts = options || {};
+  let attempts = 5;
+  if (typeof opts.attempts === "number") attempts = opts.attempts;
+  const interval = opts.interval || 1e3;
+  const exponential = opts.exponential || false;
+  const onError = opts.onError;
+  try {
+    const val = await fn();
+    return val;
+  } catch (error) {
+    if (error instanceof Canceled) throw error;
+    if (onError) onError(error);
+    if (attempts) {
+      await new Promise((r) => setTimeout(r, interval));
+      return retry(fn, {
+        attempts: attempts - 1,
+        interval: exponential ? interval * 2 : interval,
+        exponential,
+        onError
+      });
+    } else throw new Error("Maximum attempts reached");
+  }
+}
+function abortable(responsePromise, request) {
+  return cancelable(responsePromise, () => {
+    const activeRequest = typeof request === "function" ? request() : request;
+    if (typeof activeRequest?.cancel === "function") activeRequest.cancel();
+    else if (typeof activeRequest?.abort === "function") activeRequest.abort();
+  });
+}
+var Canceled = class _Canceled extends Error {
+  constructor(reason = "") {
+    super(reason);
+    Object.setPrototypeOf(this, _Canceled.prototype);
+  }
+};
+function cancelable(promise, onCancel) {
+  let cancel = null;
+  let cancelable2;
+  cancelable2 = new Promise((resolve, reject) => {
+    cancel = () => {
+      try {
+        if (onCancel) onCancel();
+      } catch (e) {
+        reject(e);
+      }
+      reject(new Canceled());
+      return cancelable2;
+    };
+    promise.then(resolve, reject);
+  });
+  if (cancel) cancelable2.cancel = cancel;
+  return cancelable2;
+}
+function readJSON(path) {
+  return new Promise((resolve, reject) => {
+    fs.readFile(path, (err, data) => {
+      if (err) reject(err);
+      else resolve(JSON.parse(data));
+    });
+  });
+}
+function isSuperset(set, subset) {
+  for (var elem of Array.from(subset.values())) {
+    if (!set.has(elem)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createAddressSet(keys = [], addresses = []) {
+  const addrs = /* @__PURE__ */ new Set();
+  keys.forEach((key) => {
+    addrs.add(key.shortAddress.base58);
+    addrs.add(key.longAddress.base58);
+  });
+  addresses.forEach((addr) => addrs.add(addr.base58));
+  return addrs;
+}
+function omitBOSS(serialized, fields) {
+  if (typeof serialized !== "object" || !serialized) return serialized;
+  const cleaned = Object.assign({}, serialized);
+  delete cleaned["__t"];
+  delete cleaned["__type"];
+  fields.forEach((field) => delete cleaned[field]);
+  return cleaned;
+}
+
+// src/models/key_record.ts
+var boss10 = boss_default.getInstance();
+var KeyRecord = class _KeyRecord {
+  constructor(keyPacked, extra, key) {
+    this.key = null;
+    this.extra = {};
+    this.keyPacked = keyPacked;
+    if (key) {
+      this.key = key;
+      this.keyLoader = new Promise((resolve) => resolve(key));
+    } else this.keyLoader = import_unicrypto6.PublicKey.unpack(keyPacked);
+    if (extra) this.extra = extra;
+  }
+  async getKey() {
+    if (this.key) return this.key;
+    return await this.keyLoader;
+  }
+  setExtra(extra) {
+    this.extra = extra;
+  }
+  static create(key, extra = {}) {
+    return new _KeyRecord(key.packed, extra, key);
+  }
+  static {
+    this.className = "KeyRecord";
+  }
+  serializeToBOSS() {
+    const key = {
+      "__t": "RSAPublicKey",
+      "packed": this.keyPacked
+    };
+    return Object.assign({ key }, this.extra);
+  }
+  static deserializeFromBOSS(serialized) {
+    return new _KeyRecord(serialized.key.packed, omitBOSS(serialized, ["key"]));
+  }
+  pack() {
+    return boss10.dump(this);
+  }
+  static unpack(bin) {
+    return boss10.load(bin);
+  }
+};
+boss10.register("KeyRecord", KeyRecord);
+
+// src/models/roles/role_simple.ts
+var boss11 = boss_default.getInstance();
+var RoleSimple = class _RoleSimple {
+  constructor(name, options) {
+    this.keyRecords = [];
+    this.addresses = [];
+    this.anonIds = [];
+    this.name = name;
+    if (options.addresses) this.addresses = options.addresses;
+    if (options.keyRecords) this.keyRecords = options.keyRecords;
+    if (options.anonIds) this.anonIds = options.anonIds;
+    if (options.keys)
+      this.keyRecords = options.keys.map((key) => KeyRecord.create(key));
+  }
+  resolve(roles, nestedLevel = 0) {
+    return this;
+  }
+  async getSimpleAddress(roles = {}, ignoreRefs = true) {
+    if (this.keyRecords.length + this.addresses.length > 1) return null;
+    if (this.keyRecords.length === 1) {
+      const key = await this.keyRecords[0].getKey();
+      return key.shortAddress;
+    } else {
+      return this.addresses[0];
+    }
+  }
+  async availableFor(options) {
+    const keyLoaders = this.keyRecords.map((record) => record.getKey());
+    const roleKeys = await Promise.all(keyLoaders);
+    const roleAddresses = createAddressSet(roleKeys, this.addresses);
+    const providedAddresses = createAddressSet(options.keys, options.addresses);
+    return isSuperset(providedAddresses, roleAddresses);
+  }
+  static {
+    this.className = "RoleSimple";
+  }
+  serializeToBOSS() {
+    return {
+      name: this.name,
+      keys: this.keyRecords,
+      addresses: this.addresses,
+      anonIds: this.anonIds
+    };
+  }
+  static deserializeFromBOSS(serialized) {
+    const records = serialized.keys || [];
+    const addresses = serialized.addresses || [];
+    return new _RoleSimple(serialized.name, {
+      keyRecords: records,
+      addresses,
+      anonIds: serialized.anonIds || []
+    });
+  }
+};
+boss11.register("SimpleRole", RoleSimple);
+
+// src/models/roles/role_list.ts
+var boss12 = boss_default.getInstance();
+var MODES = /* @__PURE__ */ ((MODES2) => {
+  MODES2["ANY"] = "ANY";
+  MODES2["ALL"] = "ALL";
+  MODES2["QUORUM"] = "QUORUM";
+  return MODES2;
+})(MODES || {});
+var RoleList = class _RoleList {
+  constructor(name, options) {
+    this.roles = [];
+    this.quorumSize = 1;
+    const { mode, roleNames, roles, quorumSize } = options;
+    if (!roleNames && !roles)
+      throw new Error("Array of role names or roles must be provided");
+    this.name = name;
+    this.mode = mode;
+    const createLink = (roleName) => new RoleLink(`__${name}-${roleName}`, roleName);
+    if (roles) this.roles = roles;
+    if (roleNames) this.roles = roleNames.map(createLink);
+    if (quorumSize) this.quorumSize = quorumSize;
+  }
+  static {
+    this.MODES = MODES;
+  }
+  resolve(roles = {}, nestedLevel = 0) {
+    if (nestedLevel >= 100) throw new Error(`Role "${this.name}" is circular`);
+    return new _RoleList(this.name, {
+      mode: this.mode,
+      roles: this.roles.map((role) => role.resolve(roles, nestedLevel + 1)),
+      quorumSize: this.quorumSize
+    });
+  }
+  async getSimpleAddress(roles = {}, ignoreRefs = true) {
+    if (this.roles.length === 1 && (this.mode !== "QUORUM" /* QUORUM */ || this.quorumSize === 1))
+      return this.roles[0].getSimpleAddress(roles);
+    else
+      return null;
+  }
+  async availableFor(options) {
+    const finalTarget = this.resolve(options.roles);
+    const totalRoles = finalTarget.roles.length;
+    async function atLeastNPositive(N) {
+      let counter = 0;
+      let i = 0;
+      while (counter < N && i < totalRoles) {
+        const vote = await finalTarget.roles[i].availableFor(options);
+        if (vote) counter++;
+        i++;
+      }
+      return counter >= N;
+    }
+    switch (this.mode) {
+      case "ANY" /* ANY */:
+        return await atLeastNPositive(1);
+      case "QUORUM" /* QUORUM */:
+        return await atLeastNPositive(this.quorumSize);
+      case "ALL" /* ALL */:
+        return await atLeastNPositive(totalRoles);
+    }
+  }
+  static {
+    this.className = "RoleList";
+  }
+  serializeToBOSS() {
+    return {
+      "name": this.name,
+      "mode": this.mode,
+      "roles": this.roles,
+      "quorumSize": this.quorumSize
+    };
+  }
+  static deserializeFromBOSS(serialized) {
+    return new _RoleList(serialized.name, {
+      mode: serialized.mode,
+      roles: serialized.roles,
+      quorumSize: serialized.quorumSize
+    });
+  }
+};
+boss12.register("RoleList", RoleList);
+
+// src/models/permissions/change_owner_permission.ts
+var boss13 = boss_default.getInstance();
+var ChangeOwnerPermission = class _ChangeOwnerPermission extends Permission {
+  static {
+    this.DefaultName = "change_owner";
+  }
+  static {
+    this.className = "ChangeOwnerPermission";
+  }
+  constructor(role, name = _ChangeOwnerPermission.DefaultName) {
+    super(role, {}, name);
+  }
+  static create(roleName, name = _ChangeOwnerPermission.DefaultName) {
+    return new _ChangeOwnerPermission(this.makeLink(name, roleName), name);
+  }
+  static deserializeFromBOSS(serialized) {
+    return new _ChangeOwnerPermission(serialized.role, serialized.name);
+  }
+};
+boss13.register("ChangeOwnerPermission", ChangeOwnerPermission);
+
+// src/models/permissions/modify_data_permission.ts
+var boss14 = boss_default.getInstance();
+var ModifyDataPermission = class _ModifyDataPermission extends Permission {
+  static {
+    this.className = "ModifyDataPermission";
+  }
+  static {
+    this.DefaultName = "modify_data";
+  }
+  constructor(role, params, name = _ModifyDataPermission.DefaultName) {
+    super(role, params, name);
+    this.params = params;
+  }
+  static create(roleName, params, name = _ModifyDataPermission.DefaultName) {
+    return new _ModifyDataPermission(this.makeLink(name, roleName), params, name);
+  }
+  static deserializeFromBOSS(serialized) {
+    const params = omitBOSS(serialized, ["role", "name"]);
+    return new _ModifyDataPermission(serialized.role, params, serialized.name);
+  }
+};
+boss14.register("ModifyDataPermission", ModifyDataPermission);
+
+// src/models/permissions/change_number_permission.ts
+var boss15 = boss_default.getInstance();
+var ChangeNumberPermission = class _ChangeNumberPermission extends Permission {
+  static {
+    this.className = "ChangeNumberPermission";
+  }
+  static {
+    this.DefaultName = "decrement_permission";
+  }
+  constructor(role, params, name = _ChangeNumberPermission.DefaultName) {
+    super(role, params, name);
+    this.params = params;
+  }
+  static create(roleName, params, name = _ChangeNumberPermission.DefaultName) {
+    return new _ChangeNumberPermission(this.makeLink(name, roleName), params, name);
+  }
+  static deserializeFromBOSS(serialized) {
+    const params = omitBOSS(serialized, ["role", "name"]);
+    return new _ChangeNumberPermission(serialized.role, params, serialized.name);
+  }
+};
+boss15.register("ChangeNumberPermission", ChangeNumberPermission);
+
+// src/models/permissions/split_join_permission.ts
+var boss16 = boss_default.getInstance();
+var SplitJoinPermission = class _SplitJoinPermission extends Permission {
+  static {
+    this.className = "SplitJoinPermission";
+  }
+  static {
+    this.DefaultName = "split_join";
+  }
+  constructor(role, params, name = _SplitJoinPermission.DefaultName) {
+    super(role, params, name);
+    this.params = params;
+  }
+  static create(roleName, params, name = _SplitJoinPermission.DefaultName) {
+    return new _SplitJoinPermission(this.makeLink(name, roleName), params, name);
+  }
+  static deserializeFromBOSS(serialized) {
+    const params = omitBOSS(serialized, ["role", "name"]);
+    return new _SplitJoinPermission(serialized.role, params, serialized.name);
+  }
+};
+boss16.register("SplitJoinPermission", SplitJoinPermission);
+
+// src/network/node_connection.ts
+var import_unicrypto7 = require("unicrypto");
+var boss17 = boss_default.getInstance();
+var CONNECTION_TIMEOUT = 5e3;
+var CLIENT_VERSION = 3;
+var NodeConnection = class _NodeConnection {
+  constructor(node, authKey, directConnection) {
+    this.node = node;
+    this.authKey = authKey;
+    this.nodeURL = node.https;
+    if (directConnection) this.nodeURL = node.http;
+  }
+  async connect() {
+    const clientNonce = (0, import_unicrypto7.randomBytes)(47);
+    const signatureOpts = { pssHash: "sha512" };
+    console.log(`setting up protected connection to ${this.nodeURL}`);
+    const clientKey = await this.authKey.publicKey.pack();
+    const connectionData = await this.request("connect", {
+      client_key: clientKey,
+      client_version: CLIENT_VERSION
+    }, { timeout: CONNECTION_TIMEOUT });
+    this.sessionId = connectionData["session_id"];
+    const serverVersion = connectionData["server_version"] || 1;
+    this.version = Math.min(serverVersion, CLIENT_VERSION);
+    const authData = boss17.dump({
+      client_nonce: clientNonce,
+      server_nonce: connectionData["server_nonce"],
+      client_version: CLIENT_VERSION,
+      server_version: serverVersion
+    });
+    const token = await this.request("get_token", {
+      data: authData,
+      signature: await this.authKey.sign(authData, signatureOpts),
+      session_id: this.sessionId
+    });
+    const tokenData = token.data;
+    const nodeKey = await this.node.getPublicKey();
+    if (!nodeKey) throw new Error("Node key is undefined");
+    const isVerified = await nodeKey.verify(
+      tokenData,
+      token.signature,
+      signatureOpts
+    );
+    if (!isVerified) throw new Error("bad node signature");
+    const params = boss17.load(tokenData);
+    if ((0, import_unicrypto7.encode64)(clientNonce) !== (0, import_unicrypto7.encode64)(params["client_nonce"]))
+      throw new Error("nonce mismatch, authentication failed");
+    const decryptedTokenBin = await this.authKey.decrypt(params["encrypted_token"]);
+    const decryptedToken = boss17.load(decryptedTokenBin);
+    this.sessionKey = new import_unicrypto7.SymmetricKey({ keyBytes: decryptedToken.sk });
+    const response = await this.command("hello");
+    if (response.status !== "OK")
+      throw new Error(`wrong status ${response.status}, authentication failed`);
+    console.log(`connected, system says: ${response.message}`);
+    return this;
+  }
+  async command(name, params = {}, requestOptions = {}) {
+    if (!this.sessionKey || !this.version) throw new Error("not in session");
+    const version = this.version;
+    const sk = this.sessionKey;
+    const data = boss17.dump({ command: name, params });
+    let encryptedParams;
+    if (version >= 2) encryptedParams = await sk.etaEncrypt(data);
+    else encryptedParams = await sk.encrypt(data);
+    const req = this.request("command", {
+      command: "command",
+      params: encryptedParams,
+      session_id: this.sessionId
+    }, requestOptions);
+    return abortable(new Promise((resolve, reject) => {
+      req.then(async (response) => {
+        let decrypted;
+        if (version >= 2) decrypted = await sk.etaDecrypt(response.result);
+        else decrypted = await sk.decrypt(response.result);
+        const result = boss17.load(decrypted);
+        if (result.error) reject(result.error);
+        else resolve(result.result);
+      }).catch(reject);
+    }), req);
+  }
+  request(path, params = {}, requestOptions = {}) {
+    const url = `${this.nodeURL}/${path}`;
+    const data = { requestData64: (0, import_unicrypto7.encode64)(boss17.dump(params)) };
+    return _NodeConnection.request("POST", url, { data, ...requestOptions });
+  }
+  static request(method, url, options = {}) {
+    const controller = new AbortController();
+    let timeout;
+    const promise = new Promise((resolve, reject) => {
+      let headers = options.headers || {};
+      if (method === "POST") headers = Object.assign({}, headers, {
+        "Content-Type": "application/json"
+      });
+      let opts = {
+        method,
+        headers,
+        signal: controller.signal
+      };
+      if (method === "POST") opts.body = JSON.stringify(options.data);
+      const fetch = globalThis.fetch;
+      if (typeof fetch !== "function") {
+        reject(new Error("Fetch API is not available in this environment"));
+        return;
+      }
+      fetch(url, opts).then((res) => {
+        if (!res.ok) {
+          throw new Error(`HTTP ${res.status}${res.statusText ? ` ${res.statusText}` : ""}`);
+        }
+        return res.blob();
+      }).then(function(blob) {
+        return blob.arrayBuffer();
+      }).then(function(ab) {
+        const response = new Uint8Array(ab);
+        const answer = boss17.load(response);
+        if (answer && answer.result === "ok") resolve(answer.response);
+        else reject(answer);
+      }).catch((err) => reject(err)).finally(() => {
+        if (timeout !== void 0) clearTimeout(timeout);
+      });
+      if (options.timeout) {
+        timeout = setTimeout(() => {
+          controller.abort();
+          reject(new Error("Connection timed out"));
+        }, options.timeout);
+      }
+    });
+    return abortable(promise, controller);
+  }
+  static xchangeRequest(method, url, options = {}) {
+    const controller = new AbortController();
+    let timeout;
+    const promise = new Promise((resolve, reject) => {
+      let headers = options.headers || {};
+      if (method === "POST") headers = Object.assign({}, headers, {
+        "Content-Type": "application/json"
+      });
+      let opts = {
+        method,
+        headers,
+        signal: controller.signal
+      };
+      if (method === "POST") opts.body = JSON.stringify(options.data);
+      const fetch = globalThis.fetch;
+      if (typeof fetch !== "function") {
+        reject(new Error("Fetch API is not available in this environment"));
+        return;
+      }
+      fetch(url, opts).then((res) => {
+        if (!res.ok) {
+          throw new Error(`HTTP ${res.status}${res.statusText ? ` ${res.statusText}` : ""}`);
+        }
+        return res.json();
+      }).then(resolve).catch((err) => reject(err)).finally(() => {
+        if (timeout !== void 0) clearTimeout(timeout);
+      });
+      if (options.timeout) {
+        timeout = setTimeout(() => {
+          controller.abort();
+          reject(new Error("Connection timed out"));
+        }, options.timeout);
+      }
+    });
+    return abortable(promise, controller);
+  }
+};
+
+// src/network/node.ts
+var import_unicrypto8 = require("unicrypto");
+var boss18 = boss_default.getInstance();
+function rewriteProtocol(value, protocol) {
+  const url = new URL(value);
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    throw new Error(`unsupported node URL protocol: ${url.protocol}`);
+  const oldPort = url.port;
+  url.protocol = protocol;
+  if (protocol === "https:" && oldPort === "8080") url.port = "443";
+  if (protocol === "http:" && oldPort === "443") url.port = "8080";
+  return url.toString().replace(/\/$/, "");
+}
+function validateNodeURL(value, nodeName, field) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      throw new Error(`unsupported protocol ${url.protocol}`);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`invalid node ${nodeName}: invalid ${field} URL ${value} (${reason})`);
+  }
+}
+var forceHTTPS = (url) => rewriteProtocol(url, "https:");
+var forceHTTP = (url) => rewriteProtocol(url, "http:");
+var GET_TOPOLOGY_TIMEOUT = 1e3;
+function difference(setA, setB) {
+  let _difference = new Set(setA);
+  setB.forEach((elem) => _difference.delete(elem));
+  return _difference;
+}
+function isEqual(setA, setB) {
+  if (setA.size !== setB.size) return false;
+  const diff = difference(setA, setB);
+  return diff.size === 0;
+}
+var Node = class {
+  constructor(info) {
+    if (!info || typeof info !== "object") throw new Error("invalid node: expected an object");
+    if (typeof info.name !== "string" || info.name.length === 0)
+      throw new Error("invalid node: name must be a non-empty string");
+    if (!Number.isInteger(info.number) || info.number < 0)
+      throw new Error(`invalid node ${info.name}: number must be a non-negative integer`);
+    if (!Array.isArray(info.domain_urls) || info.domain_urls.length === 0 || info.domain_urls.some((url) => typeof url !== "string" || url.length === 0))
+      throw new Error(`invalid node ${info.name}: domain_urls must be a non-empty string array`);
+    if (!Array.isArray(info.direct_urls) || info.direct_urls.some((url) => typeof url !== "string" || url.length === 0))
+      throw new Error(`invalid node ${info.name}: direct_urls must be a string array`);
+    if (!(typeof info.key === "string" && info.key.length > 0) && !(info.key instanceof Uint8Array))
+      throw new Error(`invalid node ${info.name}: key must be base64 or Uint8Array`);
+    info.domain_urls.forEach((url) => validateNodeURL(url, info.name, "domain_urls"));
+    info.direct_urls.forEach((url) => validateNodeURL(url, info.name, "direct_urls"));
+    this.name = info.name;
+    this.number = info.number;
+    this.domainURLs = new Set(info.domain_urls);
+    this.directURLs = new Set(info.direct_urls);
+    let keyBIN = info.key;
+    if (typeof keyBIN === "string") keyBIN = (0, import_unicrypto8.decode64)(keyBIN);
+    this.keyBIN = keyBIN;
+    const self = this;
+    this.ready = import_unicrypto8.PublicKey.unpack(this.keyBIN).then((key) => {
+      self.key = key;
+      self.id = (0, import_unicrypto8.encode64)(key.fingerprint);
+    });
+    const domainURL = this.domainURLs.values().next().value;
+    if (this.directURLs.size)
+      this.http = this.directURLs.values().next().value;
+    else
+      this.http = forceHTTP(domainURL);
+    this.https = forceHTTPS(domainURL);
+  }
+  async getId() {
+    await this.ready;
+    return this.id;
+  }
+  async getPublicKey() {
+    await this.ready;
+    return this.key;
+  }
+  async equals(node) {
+    await this.ready;
+    if (node.name !== this.name) return false;
+    if (node.number !== this.number) return false;
+    if (await node.getId() !== await this.getId()) return false;
+    if (!isEqual(this.domainURLs, node.domainURLs)) return false;
+    if (!isEqual(this.directURLs, node.directURLs)) return false;
+    return true;
+  }
+  info() {
+    return {
+      name: this.name,
+      number: this.number,
+      domain_urls: Array.from(this.domainURLs),
+      direct_urls: Array.from(this.directURLs),
+      key: (0, import_unicrypto8.encode64)(this.keyBIN)
+    };
+  }
+  async getTopology(directConnection) {
+    await this.ready;
+    let url = this.https;
+    if (directConnection) url = this.http;
+    const resp = await NodeConnection.request("GET", `${url}/topology`, {
+      timeout: GET_TOPOLOGY_TIMEOUT
+    });
+    const { signature, packed_data: packed } = resp;
+    if (!this.key) throw new Error("node initialization failed (key is undefined)");
+    const isVerified = await this.key.verifyExtended(signature, packed);
+    if (!isVerified) throw new Error("node signature mismatch");
+    return boss18.load(packed);
+  }
+};
+
+// src/network/topology.ts
+var randomIndex = (arrayLength) => ~~(arrayLength * Math.random());
+var Topology = class _Topology {
+  constructor(nodes, updatedAt) {
+    this.nodes = nodes;
+    this.updatedAt = updatedAt;
+  }
+  async update(directConnection) {
+    const trustLevel = 0.4;
+    const self = this;
+    const confirmed = {};
+    const failed = {};
+    ;
+    const stats = {};
+    async function addStats(nodes) {
+      const queue = nodes.map(async (node) => {
+        const nodeId = await node.getId();
+        if (!nodeId) return;
+        if (!stats[nodeId]) stats[nodeId] = [];
+        let found = false;
+        const queue2 = stats[nodeId].map(async (stat, i) => {
+          if (await stat.node.equals(node)) {
+            found = true;
+            stats[nodeId][i].count++;
+          }
+        });
+        return Promise.all(queue2).then(() => {
+          if (!found) stats[nodeId].push({ count: 1, node });
+        });
+      });
+      return Promise.all(queue);
+    }
+    function buildFinal(trustLevel2) {
+      const nodes = {};
+      const confirmedCount = Object.keys(confirmed).length;
+      for (var id2 in stats) {
+        const list = stats[id2];
+        let trusted;
+        if (trustLevel2 !== 0)
+          trusted = list.find((n) => confirmedCount > 0 && n.count / confirmedCount >= trustLevel2);
+        else {
+          const maximum = Math.max.apply(null, list.map((n) => n.count));
+          trusted = list.find((n) => n.count === maximum);
+        }
+        if (trusted) nodes[id2] = trusted.node;
+      }
+      return nodes;
+    }
+    function colloquium(trustLevel2, nodesToAsk) {
+      return new Promise((resolve, reject) => {
+        let Nt = Math.ceil(self.size() * trustLevel2);
+        if (Nt < 1) Nt = 1;
+        let resultFound = false;
+        const source = nodesToAsk || self.nodes;
+        const ids = Object.keys(source);
+        function success() {
+          if (resultFound) return;
+          resultFound = true;
+          resolve({ failed, confirmed });
+        }
+        function failure(err) {
+          if (resultFound) return;
+          resultFound = true;
+          reject(err);
+        }
+        function processNext() {
+          if (resultFound) return;
+          const id2 = ids.pop();
+          id2 && processNode(id2);
+        }
+        async function processNode(id2) {
+          if (resultFound) return;
+          try {
+            const response = await source[id2].getTopology(directConnection);
+            await processResponse(id2, response);
+          } catch (err) {
+            failed[id2] = true;
+            if (ids.length > 0) processNext();
+            else failure(new Error("confirmed responses < 40%"));
+          }
+        }
+        async function processResponse(id2, resp) {
+          if (resultFound) return;
+          const responseNodes = resp.nodes;
+          const responseTopology = await _Topology.load({
+            list: responseNodes,
+            updated: Math.floor(Date.now() / 1e3)
+          });
+          await addStats(Object.values(responseTopology.nodes));
+          confirmed[id2] = resp;
+          delete failed[id2];
+          if (Object.keys(confirmed).length >= Nt) success();
+        }
+        for (var i = 0; i < Nt; i++) {
+          const idToProcess = ids.pop();
+          idToProcess && processNode(idToProcess);
+        }
+      });
+    }
+    try {
+      await colloquium(0.4);
+    } catch (err) {
+      const tempResult = buildFinal(0);
+      for (var id in tempResult) if (!failed[id]) delete tempResult[id];
+      await colloquium(0.4, tempResult);
+    }
+    this.nodes = buildFinal(0.9);
+    this.updatedAt = /* @__PURE__ */ new Date();
+  }
+  size() {
+    return Object.keys(this.nodes).length;
+  }
+  pack() {
+    const list = [];
+    for (var id in this.nodes) list.push(this.nodes[id].info());
+    const updatedSec = (this.updatedAt.getTime() / 1e3).toString();
+    return {
+      list,
+      updated: parseInt(updatedSec)
+    };
+  }
+  getRandomNode() {
+    return this.getNode(this.getRandomNodeId());
+  }
+  getRandomNodeId() {
+    const ids = Object.keys(this.nodes);
+    return ids[randomIndex(ids.length)];
+  }
+  getNode(id) {
+    return this.nodes[id];
+  }
+  static async load(input) {
+    const packed = input;
+    const isRawList = Array.isArray(packed);
+    if (!isRawList && (!packed || typeof packed !== "object" || !Array.isArray(packed.list)))
+      throw new Error("invalid topology: expected a node array or an object with a list array");
+    const list = isRawList ? packed : packed.list;
+    if (list.length === 0) throw new Error("invalid topology: node list is empty");
+    let updatedAt;
+    if (isRawList) {
+      updatedAt = /* @__PURE__ */ new Date();
+    } else {
+      if (typeof packed.updated !== "number" || !Number.isFinite(packed.updated) || packed.updated < 0)
+        throw new Error("invalid topology: updated must be a non-negative Unix timestamp");
+      updatedAt = new Date(packed.updated * 1e3);
+    }
+    const nodes = {};
+    const loaded = await Promise.all(list.map(async (info) => {
+      const node = new Node(info);
+      const nodeId = await node.getId();
+      if (!nodeId) throw new Error("invalid node");
+      return { node, nodeId };
+    }));
+    const names = /* @__PURE__ */ new Set();
+    const numbers = /* @__PURE__ */ new Set();
+    for (const { node, nodeId } of loaded) {
+      if (nodes[nodeId]) throw new Error(`invalid topology: duplicate node key (${node.name})`);
+      if (names.has(node.name)) throw new Error(`invalid topology: duplicate node name ${node.name}`);
+      if (numbers.has(node.number)) throw new Error(`invalid topology: duplicate node number ${node.number}`);
+      nodes[nodeId] = node;
+      names.add(node.name);
+      numbers.add(node.number);
+    }
+    return new _Topology(nodes, updatedAt);
+  }
+};
+
+// src/network/estimator.ts
+var Estimator = class {
+  #sx;
+  #sx2;
+  #n;
+  constructor() {
+    this.#sx = 0;
+    this.#sx2 = 0;
+    this.#n = 0;
+  }
+  /**
+   * Current number of samples
+   */
+  get count() {
+    return this.#n;
+  }
+  /**
+   * current mean value
+   */
+  get mean() {
+    return this.#sx / this.#n;
+  }
+  /**
+   * Current Sample Variance estimation, e.g. 𝛔²(n-1)
+   */
+  get s2() {
+    const n = this.#n;
+    const m = this.mean;
+    return (this.#sx2 - n * m * m) / (n - 1);
+  }
+  /**
+   * Estimated standard deviation, √𝛔² (square root of sample variance estimation)
+   */
+  get stdev() {
+    return Math.sqrt(this.s2);
+  }
+  /**
+   * Add next sample to series.
+   *
+   * @param x value to add.
+   */
+  addSample(x) {
+    this.#sx += x;
+    this.#sx2 += x * x;
+    this.#n++;
+  }
+  /**
+   * clear current series so it can restart calulation
+   */
+  clear() {
+    this.#sx = this.#sx2 = this.#n = 0;
+  }
+  toString() {
+    return `(${this.mean} \xB1 ${this.stdev.toPrecision(3)})`;
+  }
+};
+
+// src/network/index.ts
+var import_unicrypto9 = require("unicrypto");
+var boss19 = boss_default.getInstance();
+var CHECK_CONTRACT_TIMEOUT = 2e3;
+function createHashId(id) {
+  return {
+    __type: "HashId",
+    composite3: id
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var Network = class {
+  constructor(privateKey, options) {
+    this.options = options || {};
+    this.connections = {};
+    this.topologyKey = this.options.topologyKey || "__universa_topology";
+    this.directConnection = this.options.directConnection || false;
+    this.readyState = "pending";
+    this.connecting = null;
+    this.resetReady();
+    this.authKey = privateKey;
+    this.timeOffset = null;
+    this.timeUpdatedAt = null;
+  }
+  resetReady() {
+    this.readyState = "pending";
+    this.ready = new Promise((resolve, reject) => {
+      this.setReady = resolve;
+      this.rejectReady = reject;
+    });
+    this.ready.catch(() => void 0);
+  }
+  size() {
+    if (this.topology) return this.topology.size();
+    throw new Error("You need to connect before accessing size");
+  }
+  async getLastTopology() {
+    if (typeof window !== "undefined") {
+      const bin = localStorage.getItem(this.topologyKey);
+      if (bin) {
+        return Topology.load(boss19.load((0, import_unicrypto9.decode64)(bin)));
+      }
+    }
+    if (this.options.topology) return this.options.topology;
+    if (this.options.topologyFile) {
+      const packed = await readJSON(this.options.topologyFile);
+      return Topology.load(packed);
+    }
+    throw new Error(
+      "No default topology is bundled in this alpha; provide options.topology or options.topologyFile"
+    );
+  }
+  saveNewTopology() {
+    if (typeof window === "undefined") return;
+    if (!this.topology) throw new Error("Can't save undefined topology");
+    const packed = this.topology.pack();
+    localStorage.setItem(this.topologyKey, (0, import_unicrypto9.encode64)(boss19.dump(packed)));
+  }
+  connect() {
+    if (this.connecting) return this.connecting;
+    if (this.readyState !== "pending") this.resetReady();
+    this.connecting = this.performConnect();
+    return this.connecting;
+  }
+  async performConnect() {
+    try {
+      this.topology = await this.getLastTopology();
+      await this.topology.update(this.directConnection);
+      this.saveNewTopology();
+      if (this.timeOffset === null) {
+        try {
+          await this.loadNetworkTime();
+        } catch (err) {
+        }
+      }
+      this.readyState = "fulfilled";
+      this.setReady();
+      return this;
+    } catch (err) {
+      this.readyState = "rejected";
+      this.rejectReady(err);
+      throw err;
+    } finally {
+      this.connecting = null;
+    }
+  }
+  async nodeConnection(nodeId) {
+    if (!this.topology)
+      throw new Error("can't establish connection without topology");
+    const node = this.topology.getNode(nodeId);
+    if (this.connections[nodeId]) return this.connections[nodeId];
+    await this.ready;
+    const connection = new NodeConnection(node, this.authKey, this.directConnection);
+    await connection.connect();
+    this.connections[nodeId] = connection;
+    return connection;
+  }
+  async getRandomConnection() {
+    await this.ready;
+    if (!this.topology)
+      throw new Error("can't establish connection without topology");
+    return this.nodeConnection(this.topology.getRandomNodeId());
+  }
+  command(name, options, connection, requestOptions) {
+    let req, conn;
+    const run = async () => {
+      conn = connection || await this.getRandomConnection();
+      try {
+        req = conn.command(name, options, requestOptions);
+        return await req;
+      } catch (error) {
+        if (!connection) {
+          const nodeId = await conn.node.getId();
+          if (nodeId) delete this.connections[nodeId];
+        }
+        throw error;
+      }
+    };
+    return abortable(retry(run, {
+      attempts: 5,
+      interval: 1e3,
+      onError: (e) => console.log(e, ` send command again`)
+    }), () => req);
+  }
+  getState(id, connection, requestOptions) {
+    let itemId;
+    if (typeof id === "string") itemId = (0, import_unicrypto9.decode64)(id);
+    else if (id.constructor.name === "HashId") itemId = id.composite3;
+    else itemId = id;
+    const hashId2 = createHashId(itemId);
+    return this.command("getState", { itemId: hashId2 }, connection, requestOptions || {});
+  }
+  checkParcel(id) {
+    let itemId;
+    if (typeof id === "string") itemId = (0, import_unicrypto9.decode64)(id);
+    else itemId = id;
+    const hashId2 = createHashId(itemId);
+    return this.command("getParcelProcessingState", { parcelId: hashId2 });
+  }
+  checkContract(id, trustLevel) {
+    const self = this;
+    let itemId;
+    if (typeof id === "string") itemId = (0, import_unicrypto9.decode64)(id);
+    else if (id.constructor.name === "HashId") itemId = id.composite3;
+    else itemId = id;
+    return new Promise((resolve, reject) => {
+      let tLevel = trustLevel;
+      if (tLevel > 0.9) tLevel = 0.9;
+      const size = self.size();
+      if (!size) throw new Error("missing topology");
+      let Nt = Math.ceil(size * tLevel);
+      if (Nt < 1) Nt = 1;
+      const N10 = Math.floor(size * 0.1) + 1;
+      const Nn = Math.max(Nt + 1, N10);
+      let resultFound = false;
+      let createdAtList = [];
+      let positive = 0;
+      let negative = 0;
+      let states = {};
+      let isTestnet;
+      const requests = [];
+      if (!self.topology) throw new Error("missing topology");
+      const ids = Object.keys(self.topology.nodes);
+      const isPending = (state) => state.indexOf("PENDING") === 0 || state.indexOf("LOCKED") === 0;
+      function success(status) {
+        if (resultFound) return;
+        resultFound = true;
+        if (!status) return resolve(null);
+        const createdAtMs = createdAtList.map((d) => d.getTime());
+        const meanT = createdAtMs.reduce((p, n) => p + n) / createdAtMs.length;
+        const meanTime = new Date(meanT);
+        const estimator = new Estimator();
+        createdAtMs.forEach((c) => estimator.addSample(c / 1e3));
+        const result = {
+          id: itemId,
+          meanTime,
+          stdevSeconds: estimator.stdev,
+          trustLevel: Nn / size
+        };
+        resolve(result);
+      }
+      function failure(err) {
+        if (resultFound) return;
+        resultFound = true;
+        reject(err);
+      }
+      function processNext() {
+        if (!resultFound && ids.length > 0) {
+          const id2 = ids.pop();
+          id2 && processNode(id2);
+        } else failure(new Error("not enough responses to find consensus"));
+      }
+      function processVote(itemResult, nodeId) {
+        if (resultFound) return;
+        const { state } = itemResult;
+        if (isPending(state)) return ids.unshift(nodeId);
+        if (!states[state]) states[state] = 1;
+        else states[state] += 1;
+        if (state === "APPROVED") {
+          positive++;
+          if (itemResult.createdAt) createdAtList.push(itemResult.createdAt);
+          if (positive >= Nt) return success(true);
+        } else {
+          negative++;
+          if (negative >= N10) return success(false);
+        }
+        if (positive + negative >= Nt) processNext();
+      }
+      async function processNode(nodeId) {
+        if (resultFound) return;
+        try {
+          const conn = await self.nodeConnection(nodeId);
+          if (resultFound) return;
+          const req = self.getState(id, conn, {
+            timeout: CHECK_CONTRACT_TIMEOUT
+          });
+          requests.push(req);
+          const response = await req;
+          const { itemResult } = response;
+          isTestnet = itemResult.isTestnet;
+          processVote(itemResult, nodeId);
+        } catch (err) {
+          console.log("On check contract: ", err);
+          if (ids.length > 0) processNext();
+          else failure(new Error("not enough responses"));
+        }
+      }
+      for (let i = 0; i < Nt; i++) processNext();
+    });
+  }
+  isApprovedExtended(id, trustLevel, onNodeResponse) {
+    const self = this;
+    return new Promise((resolve, reject) => {
+      let tLevel = trustLevel;
+      if (tLevel > 0.9) tLevel = 0.9;
+      const size = self.size();
+      if (!size) throw new Error("missing topology");
+      let Nt = Math.ceil(size * tLevel);
+      if (Nt < 1) Nt = 1;
+      const N10 = Math.floor(size * 0.1) + 1;
+      const Nn = Math.max(Nt + 1, N10);
+      let resultFound = false;
+      let positive = 0;
+      let negative = 0;
+      let states = {};
+      let isTestnet;
+      const requests = [];
+      if (!self.topology) throw new Error("missing topology");
+      const ids = Object.keys(self.topology.nodes);
+      const isPending = (state) => state.indexOf("PENDING") === 0 || state.indexOf("LOCKED") === 0;
+      function success(status) {
+        if (resultFound) return;
+        resultFound = true;
+        resolve({
+          isApproved: status,
+          isTestnet,
+          states
+        });
+      }
+      function failure(err) {
+        if (resultFound) return;
+        resultFound = true;
+        reject(err);
+      }
+      function processNext() {
+        if (!resultFound && ids.length > 0) {
+          const id2 = ids.pop();
+          id2 && processNode(id2);
+        } else failure(new Error("not enough responses to find consensus"));
+      }
+      function processVote(state, nodeId) {
+        if (resultFound) return;
+        if (isPending(state)) return ids.unshift(nodeId);
+        if (!states[state]) states[state] = 1;
+        else states[state] += 1;
+        if (state === "APPROVED") {
+          positive++;
+          if (positive >= Nt) return success(true);
+        } else {
+          negative++;
+          if (negative >= N10) return success(false);
+        }
+        if (positive + negative >= Nt) processNext();
+      }
+      async function processNode(nodeId) {
+        if (resultFound) return;
+        try {
+          const conn = await self.nodeConnection(nodeId);
+          if (resultFound) return;
+          const req = self.getState(id, conn, {
+            timeout: CHECK_CONTRACT_TIMEOUT
+          });
+          requests.push(req);
+          const response = await req;
+          const { itemResult } = response;
+          if (onNodeResponse) onNodeResponse({ nodeId, itemResult });
+          isTestnet = itemResult.isTestnet;
+          processVote(itemResult.state, nodeId);
+        } catch (err) {
+          console.log("On check contract: ", err);
+          if (ids.length > 0) processNext();
+          else failure(new Error("not enough responses"));
+        }
+      }
+      for (let i = 0; i < Nt; i++) processNext();
+    });
+  }
+  isApproved(id, trustLevel) {
+    return this.isApprovedExtended(id, trustLevel).then((result) => result.isApproved);
+  }
+  now() {
+    if (this.timeOffset === null)
+      throw new Error("you should load network time before");
+    const localTime = Date.now();
+    return new Date(localTime + this.timeOffset);
+  }
+  async loadNetworkTime() {
+    const url = "https://xchange.mainnetwork.io/api/v1/utc";
+    const response = await NodeConnection.xchangeRequest("GET", url, { timeout: 3e3 });
+    const uTime = response.currentEpochSecond * 1e3;
+    const localTime = Date.now();
+    this.timeOffset = uTime - localTime;
+    this.timeUpdatedAt = localTime;
+  }
+  static async getCost(tpack) {
+    const url = "https://xchange.mainnetwork.io/api/v1/contracts/cost";
+    const binary = await tpack.pack();
+    const data = { packedContract: (0, import_unicrypto9.encode64)(binary) };
+    return NodeConnection.xchangeRequest("POST", url, { data });
+  }
+  async registerParcel(parcel) {
+    const self = this;
+    const packedItem = boss19.dump(parcel);
+    const connection = await this.getRandomConnection();
+    const paymentId = await parcel.payment.contract.hashId();
+    const payloadId = await parcel.payload.contract.hashId();
+    if (!paymentId || !payloadId) throw new Error("payment or payload wasn't saved!");
+    let response, error;
+    try {
+      response = await this.command(
+        "approveParcel",
+        { packedItem },
+        connection,
+        { timeout: 3e3 }
+      );
+    } catch (err) {
+      error = err;
+      return this.registerParcel(parcel);
+    }
+    const paymentState = await finalState(paymentId);
+    const payloadState = await finalState(payloadId);
+    return {
+      payment: paymentState,
+      payload: payloadState
+    };
+    async function finalState(id) {
+      async function check(response3) {
+        const { itemResult } = response3;
+        const { state } = itemResult;
+        if (!state.startsWith("PENDING")) return itemResult;
+        await sleep(100);
+        return await finalState(id);
+      }
+      const response2 = await self.getState(id, connection);
+      return await check(response2);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Capsule,
+  ChangeNumberPermission,
+  ChangeOwnerPermission,
+  Compound,
+  Contract,
+  HashId,
+  KeyRecord,
+  ModifyDataPermission,
+  Network,
+  Node,
+  Parcel,
+  Reference,
+  RevokePermission,
+  RoleLink,
+  RoleList,
+  RoleSimple,
+  SplitJoinPermission,
+  Topology,
+  TransactionPack,
+  UniversaContract,
+  ...require("unicrypto")
+});
+//# sourceMappingURL=index.cjs.map