universa-core2 2.0.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,611 @@
+import * as unicrypto from 'unicrypto';
+import { PublicKey, KeyAddress, BossSerializable, PrivateKey, SymmetricKey } from 'unicrypto';
+export * from 'unicrypto';
+
+type RoleDictionary = {
+    [roleName: string]: Role;
+};
+declare abstract class Role {
+    name: string;
+    resolve(roles: RoleDictionary, nestedLevel?: number): Role;
+    availableFor(options: AvailableForOptions): Promise<boolean>;
+    getSimpleAddress(roles: RoleDictionary, ignoreRefs?: boolean): Promise<KeyAddress | null>;
+}
+interface AvailableForOptions {
+    keys?: Array<PublicKey>;
+    addresses?: Array<KeyAddress>;
+    roles?: RoleDictionary;
+}
+
+interface HashIdSerialized {
+    composite3: Uint8Array;
+}
+declare class HashId implements BossSerializable {
+    composite3: Uint8Array;
+    constructor(composite3: Uint8Array);
+    static calculate(bin: Uint8Array): Promise<HashId>;
+    get base64(): string;
+    equals(hashId: HashId): boolean;
+    static className: string;
+    serializeToBOSS(): {
+        composite3: Uint8Array<ArrayBufferLike>;
+    };
+    static deserializeFromBOSS(serialized: HashIdSerialized): HashId;
+    static unpack(bin: Uint8Array): HashId;
+    pack(): Uint8Array<ArrayBufferLike>;
+}
+
+declare enum ReferenceType {
+    TYPE_TRANSACTIONAL = 1,
+    TYPE_EXISTING_DEFINITION = 2,
+    TYPE_EXISTING_STATE = 3
+}
+declare class Reference implements BossSerializable {
+    static className: string;
+    static TYPE_TRANSACTIONAL: ReferenceType;
+    static TYPE_EXISTING_DEFINITION: ReferenceType;
+    static TYPE_EXISTING_STATE: ReferenceType;
+    fields: Array<any>;
+    roles: Array<any>;
+    signedBy: Array<any>;
+    transactionalId: any;
+    required: boolean;
+    name: string;
+    type: ReferenceType;
+    where: any;
+    constructor(name: string, type: ReferenceType, where: any);
+    serializeToBOSS(): {
+        fields: any[];
+        roles: any[];
+        signed_by: any[];
+        transactional_id: any;
+        required: boolean;
+        name: string;
+        type: ReferenceType;
+        where: any;
+    };
+    static deserializeFromBOSS(serialized: any): Reference;
+}
+
+interface RoleLinkSerialized {
+    name: string;
+    target_name: string;
+}
+declare class RoleLink implements Role, BossSerializable {
+    name: string;
+    targetName: string;
+    constructor(name: string, targetName: string);
+    resolve(roles?: RoleDictionary, nestedLevel?: number): Role;
+    getSimpleAddress(roles?: RoleDictionary, ignoreRefs?: boolean): Promise<KeyAddress | null>;
+    availableFor(options: AvailableForOptions): Promise<boolean>;
+    static className: string;
+    serializeToBOSS(): {
+        name: string;
+        target_name: string;
+    };
+    static deserializeFromBOSS(serialized: RoleLinkSerialized): RoleLink;
+}
+
+type Params = {
+    [key: string]: any;
+};
+declare class Permission {
+    name: string;
+    role: Role;
+    params: Params;
+    constructor(role: Role, params: Params, name?: string);
+    static DefaultName: string;
+    static makeLink(name: string, roleName: string): RoleLink;
+    availableFor(options: AvailableForOptions): Promise<boolean>;
+    serializeToBOSS(): {
+        name: string;
+        role: Role;
+    } & Params;
+}
+
+interface State {
+    createdAt: Date;
+    expiresAt: Date;
+    owner: Role;
+    creator: Role;
+    data: any;
+    revision: number;
+    roles: RoleDictionary;
+    parent: HashId | null;
+    origin: HashId | null;
+    branchId?: string | null;
+    references?: Array<Reference>;
+}
+interface Definition {
+    issuer: Role;
+    permissions: {
+        [id: string]: Permission;
+    };
+    createdAt: Date;
+    data: any;
+    references?: Array<Reference>;
+}
+interface UniversaContractSerialized {
+    api_level: number;
+    definition: any;
+    state: any;
+    transactional?: any;
+}
+interface ContractCreateOptions {
+    createdAt?: Date;
+    expiresAt?: Date | string;
+}
+declare class UniversaContract implements BossSerializable {
+    apiLevel: number;
+    definition: Definition;
+    state: State;
+    transactional: any;
+    constructor(apiLevel: number, definition: Definition, state: State, transactional: any);
+    static create(issuer: Role, options?: ContractCreateOptions): UniversaContract;
+    get issuer(): Role;
+    get owner(): Role;
+    set owner(role: Role);
+    get creator(): Role;
+    set creator(role: Role);
+    get parent(): HashId | null;
+    get origin(): HashId | null;
+    addPermission(permission: Permission): void;
+    removePermission(permissionId: string): void;
+    setParent(id: HashId): void;
+    setOrigin(id: HashId): void;
+    setCreatorTo(roleName: string): void;
+    incrementRevision(): void;
+    static className: string;
+    serializeToBOSS(): UniversaContractSerialized;
+    static deserializeFromBOSS(serialized: UniversaContractSerialized): UniversaContract;
+    resetTransactional(): void;
+    createTransactional(id: string | null): void;
+    addReference(ref: Reference): void;
+}
+
+interface CapsuleOptions {
+    new?: Array<HashId>;
+    revoking?: Array<HashId>;
+}
+interface CreateCapsuleOptions {
+    definitionData?: any;
+    stateData?: any;
+    createdAt?: Date;
+    expiresAt?: Date | string;
+    permissions?: Array<Permission>;
+    owner?: Role;
+}
+declare class Capsule {
+    contract: UniversaContract;
+    new: Array<HashId>;
+    revoking: Array<HashId>;
+    constructor(contract: UniversaContract, options?: CapsuleOptions);
+    static unpack(bin: Uint8Array): Capsule;
+    static create(issuer: Role, options?: CreateCapsuleOptions): Capsule;
+    get issuer(): Role;
+    get owner(): Role;
+    set owner(role: Role);
+    get creator(): Role;
+    set creator(role: Role);
+    get parent(): HashId | null;
+    get origin(): HashId | null;
+    get definition(): Definition;
+    get state(): State;
+    get transactional(): any;
+    pack(): Uint8Array<ArrayBufferLike>;
+}
+
+interface ContractOptions {
+    type?: string;
+    version?: number;
+    binary?: Uint8Array;
+}
+interface signedByOptions {
+    address?: KeyAddress;
+    publicKey?: PublicKey;
+}
+declare class Contract {
+    type: string;
+    version: number;
+    signatures: Array<Uint8Array>;
+    data: Uint8Array;
+    capsule: Capsule;
+    binary: Uint8Array | null;
+    constructor(data: Uint8Array, signatures?: Array<Uint8Array>, options?: ContractOptions);
+    get issuer(): Role;
+    get owner(): Role;
+    set owner(role: Role);
+    get creator(): Role;
+    set creator(role: Role);
+    setCreatorTo(roleName: string): void;
+    get parent(): HashId | null;
+    get origin(): HashId | null;
+    get definition(): Definition;
+    get state(): State;
+    get transactional(): any;
+    hashId(): Promise<HashId>;
+    getSignatureKeys(): Promise<PublicKey[]>;
+    isSignedBy(options: signedByOptions): Promise<boolean>;
+    sign(privateKey: PrivateKey): Promise<void>;
+    static create(issuer: Role, options: CreateCapsuleOptions): Contract;
+    packData(): void;
+    pack(): Uint8Array<ArrayBufferLike>;
+    createRevision(createdAt?: Date): Promise<Contract>;
+    static unpack(binary: Uint8Array): Contract;
+    resetTransactional(): void;
+    createTransactional(id: string | null): void;
+    addReference(ref: Reference): void;
+}
+
+interface TransactionPackOptions {
+    subItems?: Array<Uint8Array>;
+    referencedItems?: Array<Uint8Array>;
+    tags?: {
+        [tag: string]: HashId;
+    };
+    keys?: Array<Uint8Array>;
+}
+interface TaggedItem {
+    hashId: HashId;
+    contract: Contract;
+}
+declare class TransactionPack implements BossSerializable {
+    contract: Contract;
+    subItems: {
+        [hashId64: string]: Contract;
+    };
+    referencedItems: {
+        [hashId64: string]: Contract;
+    };
+    taggedItems: {
+        [tag: string]: TaggedItem;
+    };
+    ready: Promise<void>;
+    constructor(contractPacked: Uint8Array, options?: TransactionPackOptions);
+    getItem(hashId: HashId): Promise<Contract>;
+    getTag(tag: string): Promise<TaggedItem>;
+    addTag(tag: string, hashId: HashId): Promise<void>;
+    addSubItem(itemPacked: Uint8Array): Promise<void>;
+    addReferencedItem(itemPacked: Uint8Array): Promise<void>;
+    pack(): Promise<Uint8Array<ArrayBufferLike>>;
+    static unpack(packed: Uint8Array): TransactionPack;
+    static className: string;
+    serializeToBOSS(): {
+        contract: Uint8Array<ArrayBufferLike> | null;
+        subItems: Uint8Array<ArrayBufferLike>[];
+        referencedItems: Uint8Array<ArrayBufferLike>[];
+        tags: {
+            [tag: string]: HashId;
+        };
+    };
+    static deserializeFromBOSS(serialized: any): TransactionPack;
+    sign(key: PrivateKey): Promise<void>;
+}
+
+declare class Compound {
+    tpack: TransactionPack;
+    constructor(tpack: TransactionPack);
+    static unpack(bin: Uint8Array): Compound;
+    pack(): Promise<Uint8Array<ArrayBufferLike>>;
+    private getDefinitionContracts;
+    getTags(): Array<string>;
+    sign(privateKey: PrivateKey): Promise<void>;
+    getTag(tag: string): Promise<TransactionPack | null>;
+    getItem(hashId: HashId): Promise<Contract>;
+}
+
+interface PaymentOptions {
+    isTestnet?: boolean;
+    createdAt?: Date;
+}
+declare class Parcel implements BossSerializable {
+    paymentBin: Uint8Array;
+    payloadBin: Uint8Array;
+    hashId: HashId;
+    payment: TransactionPack;
+    payload: TransactionPack;
+    constructor(payment: Uint8Array, payload: Uint8Array, hashId: HashId);
+    static className: string;
+    serializeToBOSS(): {
+        payment: Uint8Array<ArrayBufferLike>;
+        payload: Uint8Array<ArrayBufferLike>;
+        hashId: HashId;
+    };
+    static deserializeFromBOSS(serialized: any): Parcel;
+    static create(payment: Uint8Array, payload: Uint8Array): Promise<Parcel>;
+    static createPayment(amount: number, upack: TransactionPack, options?: PaymentOptions): Promise<TransactionPack>;
+    pack(): Uint8Array<ArrayBufferLike>;
+    static unpack(bin: Uint8Array): Parcel;
+}
+
+type Primitive = string | number | Date | null | undefined;
+type Dict = {
+    [key: string]: Primitive | Dict;
+};
+interface Cancelable<T> extends Promise<T> {
+    cancel(): Cancelable<T>;
+}
+
+declare class KeyRecord implements BossSerializable {
+    keyPacked: Uint8Array;
+    keyLoader: Promise<PublicKey>;
+    key: PublicKey | null;
+    extra: Dict;
+    constructor(keyPacked: Uint8Array, extra?: Dict, key?: PublicKey);
+    getKey(): Promise<PublicKey>;
+    setExtra(extra: Dict): void;
+    static create(key: PublicKey, extra?: Dict): KeyRecord;
+    static className: string;
+    serializeToBOSS(): {
+        key: {
+            __t: string;
+            packed: Uint8Array<ArrayBufferLike>;
+        };
+    } & Dict;
+    static deserializeFromBOSS(serialized: any): KeyRecord;
+    pack(): Uint8Array<ArrayBufferLike>;
+    static unpack(bin: Uint8Array): KeyRecord;
+}
+
+interface RoleSimpleOptions {
+    keys?: Array<PublicKey>;
+    addresses?: Array<KeyAddress>;
+    keyRecords?: Array<KeyRecord>;
+    anonIds?: Array<any>;
+}
+declare class RoleSimple implements Role, BossSerializable {
+    name: string;
+    keyRecords: Array<KeyRecord>;
+    addresses: Array<KeyAddress>;
+    anonIds: Array<any>;
+    constructor(name: string, options: RoleSimpleOptions);
+    resolve(roles: RoleDictionary, nestedLevel?: number): this;
+    getSimpleAddress(roles?: RoleDictionary, ignoreRefs?: boolean): Promise<KeyAddress | null>;
+    availableFor(options: AvailableForOptions): Promise<boolean>;
+    static className: string;
+    serializeToBOSS(): {
+        name: string;
+        keys: KeyRecord[];
+        addresses: KeyAddress[];
+        anonIds: any[];
+    };
+    static deserializeFromBOSS(serialized: any): RoleSimple;
+}
+
+declare enum MODES {
+    ANY = "ANY",
+    ALL = "ALL",
+    QUORUM = "QUORUM"
+}
+interface RoleListOptions {
+    mode: MODES;
+    roleNames?: Array<string>;
+    roles?: Array<Role>;
+    quorumSize?: number;
+}
+declare class RoleList implements Role, BossSerializable {
+    name: string;
+    mode: MODES;
+    roles: Array<Role>;
+    quorumSize: number;
+    constructor(name: string, options: RoleListOptions);
+    static MODES: typeof MODES;
+    resolve(roles?: RoleDictionary, nestedLevel?: number): RoleList;
+    getSimpleAddress(roles?: RoleDictionary, ignoreRefs?: boolean): Promise<unicrypto.KeyAddress | null>;
+    availableFor(options: AvailableForOptions): Promise<boolean>;
+    static className: string;
+    serializeToBOSS(): {
+        name: string;
+        mode: MODES;
+        roles: Role[];
+        quorumSize: number;
+    };
+    static deserializeFromBOSS(serialized: any): RoleList;
+}
+
+declare class RevokePermission extends Permission implements BossSerializable {
+    static DefaultName: string;
+    static className: string;
+    constructor(role: Role, name?: string);
+    static create(roleName: string, name?: string): RevokePermission;
+    static deserializeFromBOSS(serialized: any): RevokePermission;
+}
+
+declare class ChangeOwnerPermission extends Permission implements BossSerializable {
+    static DefaultName: string;
+    static className: string;
+    constructor(role: Role, name?: string);
+    static create(roleName: string, name?: string): ChangeOwnerPermission;
+    static deserializeFromBOSS(serialized: any): ChangeOwnerPermission;
+}
+
+type ModifyPrimitive = null | string | number | Date;
+interface ModifyDataParams {
+    fields: {
+        [key: string]: Array<ModifyPrimitive>;
+    };
+}
+declare class ModifyDataPermission extends Permission implements BossSerializable {
+    params: ModifyDataParams;
+    static className: string;
+    static DefaultName: string;
+    constructor(role: Role, params: ModifyDataParams, name?: string);
+    static create(roleName: string, params: ModifyDataParams, name?: string): ModifyDataPermission;
+    static deserializeFromBOSS(serialized: any): ModifyDataPermission;
+}
+
+interface ChangeNumberParams {
+    field_name: string;
+    min_value?: string | number;
+    min_step?: string | number;
+    max_value?: string | number;
+    max_step?: string | number;
+}
+declare class ChangeNumberPermission extends Permission implements BossSerializable {
+    params: ChangeNumberParams;
+    static className: string;
+    static DefaultName: string;
+    constructor(role: Role, params: ChangeNumberParams, name?: string);
+    static create(roleName: string, params: ChangeNumberParams, name?: string): ChangeNumberPermission;
+    static deserializeFromBOSS(serialized: any): ChangeNumberPermission;
+}
+
+interface SplitJoinParams {
+    field_name: string;
+    min_value?: string | number;
+    min_unit?: string | number;
+    join_match_fields: Array<string>;
+}
+declare class SplitJoinPermission extends Permission implements BossSerializable {
+    params: SplitJoinParams;
+    static className: string;
+    static DefaultName: string;
+    constructor(role: Role, params: SplitJoinParams, name?: string);
+    static create(roleName: string, params: SplitJoinParams, name?: string): SplitJoinPermission;
+    static deserializeFromBOSS(serialized: any): SplitJoinPermission;
+}
+
+interface NodeInfo {
+    name: string;
+    number: number;
+    domain_urls: Array<string>;
+    direct_urls: Array<string>;
+    key: Uint8Array | string;
+}
+declare class Node {
+    id: string | undefined;
+    key: PublicKey | undefined;
+    name: string;
+    http: string;
+    https: string;
+    ready: Promise<void>;
+    keyBIN: Uint8Array;
+    number: number;
+    domainURLs: Set<string>;
+    directURLs: Set<string>;
+    constructor(info: NodeInfo);
+    getId(): Promise<string | undefined>;
+    getPublicKey(): Promise<PublicKey | undefined>;
+    equals(node: Node): Promise<boolean>;
+    info(): {
+        name: string;
+        number: number;
+        domain_urls: string[];
+        direct_urls: string[];
+        key: string;
+    };
+    getTopology(directConnection?: boolean): Promise<any>;
+}
+
+type NodeDictionary = {
+    [id: string]: Node;
+};
+interface PackedTopology {
+    list: Array<NodeInfo>;
+    updated: number;
+}
+type TopologyInput = PackedTopology | Array<NodeInfo>;
+declare class Topology {
+    nodes: NodeDictionary;
+    updatedAt: Date;
+    constructor(nodes: NodeDictionary, updatedAt: Date);
+    update(directConnection?: boolean): Promise<void>;
+    size(): number;
+    pack(): {
+        list: any[];
+        updated: number;
+    };
+    getRandomNode(): Node;
+    getRandomNodeId(): string;
+    getNode(id: string): Node;
+    static load(input: TopologyInput): Promise<Topology>;
+    static load(input: unknown): Promise<Topology>;
+}
+
+declare class NodeConnection {
+    node: Node;
+    authKey: PrivateKey;
+    nodeURL: string;
+    sessionId: number | undefined;
+    sessionKey: SymmetricKey | undefined;
+    version: number | undefined;
+    nodePublicKey: PublicKey | undefined;
+    constructor(node: Node, authKey: PrivateKey, directConnection?: boolean);
+    connect(): Promise<this>;
+    command(name: string, params?: any, requestOptions?: any): Promise<any>;
+    request(path: string, params?: any, requestOptions?: any): Cancelable<any>;
+    static request(method: string, url: string, options?: any): Cancelable<any>;
+    static xchangeRequest(method: string, url: string, options?: any): Cancelable<any>;
+}
+
+interface NetworkOptions {
+    topologyKey?: string;
+    topology?: Topology;
+    topologyFile?: string;
+    directConnection?: boolean;
+}
+interface ContractState {
+    isApproved: boolean;
+    isTestnet: boolean;
+    states: any;
+}
+interface NetworkApproval {
+    id: Uint8Array;
+    meanTime: Date;
+    stdevSeconds: number;
+    trustLevel: number;
+}
+interface ParcelState {
+    payment: ItemResult;
+    payload: ItemResult;
+}
+interface ItemResult {
+    createdAt: Date | null;
+    extra: any;
+    __type: string;
+    isTestnet: boolean;
+    state: string;
+    haveCopy: boolean;
+    lockedById: any;
+    expiresAt: Date | null;
+    errors: any;
+}
+type ConnectionDict = {
+    [id: string]: NodeConnection;
+};
+declare class Network {
+    options: NetworkOptions;
+    connections: ConnectionDict;
+    topologyKey: string;
+    directConnection: boolean;
+    ready: Promise<void>;
+    authKey: PrivateKey;
+    setReady: any;
+    rejectReady: any;
+    topology: Topology | undefined;
+    timeOffset: number | null;
+    timeUpdatedAt: number | null;
+    private readyState;
+    private connecting;
+    constructor(privateKey: PrivateKey, options?: NetworkOptions);
+    private resetReady;
+    size(): number;
+    getLastTopology(): Promise<Topology>;
+    saveNewTopology(): void;
+    connect(): Promise<this>;
+    private performConnect;
+    nodeConnection(nodeId: string): Promise<NodeConnection>;
+    getRandomConnection(): Promise<NodeConnection>;
+    command(name: string, options?: any, connection?: NodeConnection, requestOptions?: any): Cancelable<any>;
+    getState(id: HashId | Uint8Array | string, connection?: NodeConnection, requestOptions?: any): Cancelable<any>;
+    checkParcel(id: Uint8Array | string): Cancelable<any>;
+    checkContract(id: HashId | Uint8Array | string, trustLevel: number): Promise<NetworkApproval | null>;
+    isApprovedExtended(id: Uint8Array | string, trustLevel: number, onNodeResponse?: (response: any) => void): Promise<ContractState>;
+    isApproved(id: Uint8Array | string, trustLevel: number): Promise<boolean>;
+    now(): Date;
+    loadNetworkTime(): Promise<void>;
+    static getCost(tpack: TransactionPack): Promise<any>;
+    registerParcel(parcel: Parcel): Promise<ParcelState>;
+}
+
+export { Capsule, ChangeNumberPermission, ChangeOwnerPermission, Compound, Contract, type Definition, HashId, KeyRecord, ModifyDataPermission, Network, type NetworkApproval, Node, Parcel, Reference, RevokePermission, type RoleDictionary, RoleLink, RoleList, RoleSimple, SplitJoinPermission, type State, Topology, TransactionPack, UniversaContract };

package/dist/index.mjs

@@ -0,0 +1,80 @@
+import core from './index.cjs';
+
+export const {
+  AES,
+  AESCTRTransformer,
+  AbstractKey,
+  BigInteger,
+  Boss,
+  CRC32,
+  Capsule,
+  ChangeNumberPermission,
+  ChangeOwnerPermission,
+  Compound,
+  Contract,
+  CryptoWorker,
+  DiffieHellman,
+  ExtendedSignature,
+  HMAC,
+  HashId,
+  KeyAddress,
+  KeyInfo,
+  KeyRecord,
+  ModifyDataPermission,
+  Network,
+  Node,
+  Parcel,
+  PrivateKey,
+  PublicKey,
+  Reference,
+  RevokePermission,
+  RoleLink,
+  RoleList,
+  RoleSimple,
+  SHA,
+  SignedRecord,
+  SplitJoinPermission,
+  SymmetricKey,
+  Topology,
+  TransactionPack,
+  UniversaContract,
+  arrayToByteString,
+  bigIntToByteArray,
+  byteArrayToBigInt,
+  byteStringToArray,
+  byteStringToBytes,
+  bytes,
+  bytesToByteString,
+  bytesToHex,
+  bytesToText,
+  concatBytes,
+  crc32,
+  decode58,
+  decode64,
+  decode64Short,
+  defaultPSSConfig,
+  defaultSignatureConfig,
+  dirname,
+  encode58,
+  encode64,
+  encode64Short,
+  guid,
+  hashId,
+  hexToBytes,
+  isBrowser,
+  isNode,
+  isWorker,
+  isWorkerAvailable,
+  keysEqual,
+  pbkdf2,
+  randomAlnums,
+  randomBytes,
+  rsa,
+  setup,
+  shortId,
+  textToBytes,
+  textToHex,
+  unicryptoReady
+} = core;
+
+export default core;