@keetanetwork/keetanet-client 0.10.2

package/lib/block/index.d.ts

@@ -0,0 +1,181 @@
+import type { GenericAccount } from '../account';
+import Account from '../account';
+import BufferStorage from '../utils/buffer';
+import * as ASN1 from '../utils/asn1';
+import type { JSONSupported, ToJSONSerializableOptions } from '../utils/conversion';
+import * as Operations from './operations';
+export declare enum AdjustMethod {
+    ADD = 0,
+    SUBTRACT = 1,
+    SET = 2
+}
+export declare function assertAdjustMethod(value: any, bigintOkay?: boolean): AdjustMethod;
+/**
+ * Block hash
+ */
+export declare class BlockHash extends BufferStorage {
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockHash;
+    static Set: import("../utils/helper").InstanceSetConstructor<BlockHash, string>;
+    static getAccountOpeningHash(account: GenericAccount): BlockHash;
+    fromData(data: Buffer): BlockHash;
+    get hashFunctionName(): string;
+    constructor(blockhash: ConstructorParameters<typeof BufferStorage>[0]);
+    static toJSONSerializablePrefix: string;
+    static toJSONSerializable(value: BlockHash, _ignore_opts: ToJSONSerializableOptions): string;
+}
+/**
+ * Network ID
+ */
+type NetworkID = bigint;
+/**
+ * Subnet ID
+ */
+type SubnetID = bigint;
+/**
+ * Block signature
+ */
+type BlockSignature = Buffer;
+/**
+ * Representation of the block
+ */
+export interface BlockJSON {
+    version: number;
+    date: string | Date;
+    previous: string | BlockHash;
+    network: string | NetworkID;
+    subnet?: string | SubnetID;
+    account: string | GenericAccount;
+    signer: string | Account;
+    signature: string | BlockSignature;
+    operations: Operations.BlockJSONOperations[] | Operations.BlockOperations[];
+}
+export type BlockJSONIncomplete = Partial<BlockJSON>;
+/**
+ * Output of block suitable to JSON serialization
+ */
+export interface BlockJSONOutput extends JSONSupported<Omit<BlockJSON, 'operations'>> {
+    operations: JSONSupported<Operations.BlockJSONOperations>[];
+    $hash: string;
+    $opening: boolean;
+}
+export type BlockJSONOutputIncomplete = Partial<BlockJSONOutput>;
+/**
+ * Map input to our values
+ */
+interface BlockUnsignedCanonical {
+    version: number;
+    date: Date;
+    previous: BlockHash;
+    account: GenericAccount;
+    signer: Account;
+    operations: Operations.BlockOperations[];
+    network: NetworkID;
+    subnet: SubnetID | undefined;
+    signature: never;
+}
+interface BlockCanonical extends Omit<BlockUnsignedCanonical, 'signature'> {
+    signature: BlockSignature;
+}
+type BlockASN1WithoutSignature = ASN1.ValidateASN1.SchemaMap<[typeof BlockASN1Schema[0], typeof BlockASN1Schema[1], typeof BlockASN1Schema[2], typeof BlockASN1Schema[3], typeof BlockASN1Schema[4], typeof BlockASN1Schema[5], typeof BlockASN1Schema[6], typeof BlockASN1Schema[7]]>;
+/**
+ * Block:  An item which contains a number of operations (transactions) which
+ * originated from an account at a particular instant
+ */
+export declare class Block implements BlockCanonical {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is Block;
+    static Hash: typeof BlockHash;
+    static OperationType: typeof Operations.OperationType;
+    static Operation: {
+        SEND: typeof Operations.BlockOperationSEND;
+        SET_REP: typeof Operations.BlockOperationSET_REP;
+        SET_INFO: typeof Operations.BlockOperationSET_INFO;
+        MODIFY_PERMISSIONS: typeof Operations.BlockOperationMODIFY_PERMISSIONS;
+        CREATE_IDENTIFIER: typeof Operations.BlockOperationCREATE_IDENTIFIER;
+        TOKEN_ADMIN_SUPPLY: typeof Operations.BlockOperationTOKEN_ADMIN_SUPPLY;
+        TOKEN_ADMIN_MODIFY_BALANCE: typeof Operations.BlockOperationTOKEN_ADMIN_MODIFY_BALANCE;
+        RECEIVE: typeof Operations.BlockOperationRECEIVE;
+    };
+    static NO_PREVIOUS: string;
+    static AdjustMethod: typeof AdjustMethod;
+    static Builder: typeof BlockBuilder;
+    readonly version: number;
+    readonly date: Date;
+    readonly previous: BlockHash;
+    readonly account: GenericAccount;
+    readonly signer: Account;
+    readonly operations: BlockCanonical['operations'];
+    readonly network: NetworkID;
+    readonly subnet: SubnetID | undefined;
+    readonly signature: BlockSignature;
+    readonly $signatureValid: boolean;
+    readonly $opening: boolean;
+    static fromUnsignedJSON(input: BlockUnsignedCanonical): Promise<Block>;
+    static isValidJSON(block: BlockJSON | BlockJSONOutput | BlockJSONIncomplete): block is BlockJSON;
+    constructor(input: Buffer | ArrayBuffer | BlockJSON | BlockJSONOutput | Block | string);
+    static getAccountOpeningHash(account: GenericAccount): BlockHash;
+    toBytes(includeSignature?: boolean): ArrayBuffer;
+    protected static getASN1ContainerWithoutSignature(input: BlockUnsignedCanonical | BlockCanonical): BlockASN1WithoutSignature;
+    toJSON(): BlockJSONOutput;
+    /**
+     * Hash of the block minus the signature
+     *
+     * XXX:TODO: Should the hash of the block normally include the
+     *           signature ?  One reason against is that it would
+     *           allow for identical blocks that only differ by
+     *           signature (which isn't signed)
+     */
+    get hash(): BlockHash;
+    static toJSONSerializablePrefix: string;
+    static toJSONSerializable(value: Block, opts: ToJSONSerializableOptions): {
+        [x: string]: any;
+        operations: JSONSupported<Operations.BlockJSONOperations>[];
+        $hash: string;
+        $opening: boolean;
+    };
+}
+export declare class BlockBuilder implements BlockJSONIncomplete {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockBuilder;
+    static OperationType: typeof Operations.OperationType;
+    static AdjustMethod: typeof AdjustMethod;
+    static Operation: {
+        SEND: typeof Operations.BlockOperationSEND;
+        SET_REP: typeof Operations.BlockOperationSET_REP;
+        SET_INFO: typeof Operations.BlockOperationSET_INFO;
+        MODIFY_PERMISSIONS: typeof Operations.BlockOperationMODIFY_PERMISSIONS;
+        CREATE_IDENTIFIER: typeof Operations.BlockOperationCREATE_IDENTIFIER;
+        TOKEN_ADMIN_SUPPLY: typeof Operations.BlockOperationTOKEN_ADMIN_SUPPLY;
+        TOKEN_ADMIN_MODIFY_BALANCE: typeof Operations.BlockOperationTOKEN_ADMIN_MODIFY_BALANCE;
+        RECEIVE: typeof Operations.BlockOperationRECEIVE;
+    };
+    static NO_PREVIOUS: string;
+    constructor(block?: BlockJSONIncomplete | BlockJSON | Block | ArrayBuffer | string);
+    protected get currentBlock(): Block | BlockJSONIncomplete;
+    protected get currentWIP(): BlockJSONIncomplete;
+    protected get currentBlockSealed(): Block;
+    toJSON(): BlockJSONOutput | BlockJSONOutputIncomplete;
+    seal(): Promise<Block>;
+    unseal(): BlockJSONIncomplete;
+    get sealed(): boolean;
+    get block(): Block | undefined;
+    get hash(): BlockHash | undefined;
+    set signer(signer: string | Account | undefined);
+    get signer(): Account | undefined;
+    set account(account: string | GenericAccount | undefined);
+    get account(): GenericAccount | undefined;
+    set previous(blockhash: string | BlockHash | undefined);
+    get previous(): BlockHash | undefined;
+    get $opening(): boolean | undefined;
+    set date(date: Date | string | undefined);
+    get date(): Date | undefined;
+    set version(version: number | undefined);
+    get version(): number | undefined;
+    set network(network: NetworkID | string | undefined);
+    get network(): NetworkID | undefined;
+    set subnet(subnet: SubnetID | string | undefined);
+    get subnet(): SubnetID | undefined;
+    addOperation(operation: Operations.BlockJSONOperations): void;
+    get operations(): Operations.BlockOperations[] | undefined;
+}
+export default Block;

package/lib/block/operations.d.ts

@@ -0,0 +1,407 @@
+import { ValidateASN1 } from '../utils/asn1';
+import type { DeepMutable } from '../utils/helper';
+import type { GenericAccount, IdentifierAddress, TokenAddress, TokenPublicKeyString } from '../account';
+import Account from '../account';
+import type { AcceptedPermissionTypes } from '../permissions';
+import Permissions from '../permissions';
+import type { JSONSupported } from '../utils/conversion';
+import Block, { AdjustMethod } from '.';
+/**
+ * All supported operations
+ */
+export declare enum OperationType {
+    SEND = 0,
+    SET_REP = 1,
+    SET_INFO = 2,
+    MODIFY_PERMISSIONS = 3,
+    CREATE_IDENTIFIER = 4,
+    TOKEN_ADMIN_SUPPLY = 5,
+    TOKEN_ADMIN_MODIFY_BALANCE = 6,
+    RECEIVE = 7
+}
+export type BlockOperationTypes = keyof typeof OperationType;
+/**
+ * Schema for each operation as well as names of each field within the block operations
+ */
+declare const BlockOperationASN1SchemaBase: {
+    readonly SEND: [{
+        readonly name: "to";
+        readonly schema: typeof ValidateASN1.IsOctetString;
+    }, {
+        readonly name: "amount";
+        readonly schema: typeof ValidateASN1.IsInteger;
+    }, {
+        readonly name: "token";
+        readonly schema: typeof ValidateASN1.IsOctetString;
+    }, {
+        readonly name: "external";
+        readonly schema: {
+            readonly optional: {
+                readonly type: "string";
+                readonly kind: "utf8";
+            };
+        };
+    }];
+    readonly RECEIVE: [{
+        readonly name: "amount";
+        readonly schema: typeof ValidateASN1.IsInteger;
+    }, {
+        readonly name: "token";
+        readonly schema: typeof ValidateASN1.IsOctetString;
+    }, {
+        readonly name: "from";
+        readonly schema: typeof ValidateASN1.IsOctetString;
+    }, {
+        readonly name: "exact";
+        readonly schema: typeof ValidateASN1.IsBoolean;
+    }, {
+        readonly name: "forward";
+        readonly schema: {
+            readonly optional: typeof ValidateASN1.IsOctetString;
+        };
+    }];
+    readonly SET_REP: [{
+        readonly name: "to";
+        readonly schema: typeof ValidateASN1.IsOctetString;
+    }];
+    readonly SET_INFO: [{
+        readonly name: "name";
+        readonly schema: {
+            readonly type: "string";
+            readonly kind: "utf8";
+        };
+    }, {
+        readonly name: "description";
+        readonly schema: {
+            readonly type: "string";
+            readonly kind: "utf8";
+        };
+    }, {
+        readonly name: "metadata";
+        readonly schema: {
+            readonly type: "string";
+            readonly kind: "utf8";
+        };
+    }, {
+        readonly name: "defaultPermission";
+        readonly schema: {
+            readonly optional: readonly [typeof ValidateASN1.IsInteger, typeof ValidateASN1.IsInteger];
+        };
+    }];
+    readonly MODIFY_PERMISSIONS: [{
+        readonly name: "principal";
+        readonly schema: typeof ValidateASN1.IsOctetString;
+    }, {
+        readonly name: "method";
+        readonly schema: typeof ValidateASN1.IsInteger;
+    }, {
+        readonly name: "permissions";
+        readonly schema: {
+            readonly choice: [typeof ValidateASN1.IsNull, readonly [typeof ValidateASN1.IsInteger, typeof ValidateASN1.IsInteger]];
+        };
+    }, {
+        readonly name: "target";
+        readonly schema: {
+            readonly optional: typeof ValidateASN1.IsOctetString;
+        };
+    }];
+    readonly CREATE_IDENTIFIER: [{
+        readonly name: "identifier";
+        readonly schema: typeof ValidateASN1.IsOctetString;
+    }];
+    readonly TOKEN_ADMIN_SUPPLY: [{
+        readonly name: "amount";
+        readonly schema: typeof ValidateASN1.IsInteger;
+    }, {
+        readonly name: "method";
+        readonly schema: typeof ValidateASN1.IsInteger;
+    }];
+    readonly TOKEN_ADMIN_MODIFY_BALANCE: [{
+        readonly name: "token";
+        readonly schema: typeof ValidateASN1.IsOctetString;
+    }, {
+        readonly name: "amount";
+        readonly schema: typeof ValidateASN1.IsInteger;
+    }, {
+        readonly name: "method";
+        readonly schema: typeof ValidateASN1.IsInteger;
+    }];
+};
+type ExtractSchemaFromBase<T extends {
+    name: string;
+    schema: ValidateASN1.Schema;
+}[]> = {
+    [K in keyof T]: T[K]['schema'];
+};
+/**
+ * Schema for each operation
+ */
+export declare const BlockOperationASN1Schema: { [T in BlockOperationTypes]: {
+    type: "context";
+    kind: "explicit";
+    value: (typeof OperationType)[T];
+    contains: DeepMutable<ExtractSchemaFromBase<(typeof BlockOperationASN1SchemaBase)[T]>>;
+}; };
+/**
+ * Keys of the operations which we will serialize/deserialize
+ */
+export declare const BlockOperationKeys: BlockOperationKeysType;
+export type BlockOperationASN1SchemaType<T extends BlockOperationTypes = BlockOperationTypes> = typeof BlockOperationASN1Schema[T];
+type BlockOperationKeysType = {
+    [Property in BlockOperationTypes as `${Property}`]: string[];
+};
+interface BlockJSONOperation {
+    type: OperationType;
+}
+interface BlockOperationValidateContext {
+    block: Block;
+    operationIndex: number;
+}
+declare class BlockOperation {
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockOperation;
+    validate(_ignored_context: BlockOperationValidateContext): void;
+    protected computeTo(to: string | GenericAccount, isIdentifier: false): Account;
+    protected computeTo(to: string | GenericAccount, isIdentifier: true): IdentifierAddress;
+    protected computeTo(to: string | GenericAccount, isIdentifier?: undefined): GenericAccount;
+    protected computeAmount(amount: string | bigint): bigint;
+}
+interface BlockJSONOperationSEND extends BlockJSONOperation {
+    type: OperationType.SEND;
+    to: string | GenericAccount;
+    amount: string | bigint;
+    token: TokenPublicKeyString | TokenAddress;
+    external?: string;
+}
+declare class BlockOperationSEND extends BlockOperation implements BlockJSONOperationSEND {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockOperationSEND;
+    type: OperationType.SEND;
+    external: string | undefined;
+    constructor(input: BlockJSONOperationSEND);
+    set to(to: string | GenericAccount);
+    get to(): GenericAccount;
+    set token(token: TokenPublicKeyString | TokenAddress);
+    get token(): TokenAddress;
+    set amount(amount: string | bigint);
+    get amount(): bigint;
+    validate(context: BlockOperationValidateContext): void;
+    toJSON(): JSONSupported<BlockJSONOperationSEND>;
+}
+interface BlockJSONOperationRECEIVE extends BlockJSONOperation {
+    type: OperationType.RECEIVE;
+    amount: string | bigint;
+    token: TokenPublicKeyString | TokenAddress;
+    from: string | GenericAccount;
+    forward?: string | GenericAccount;
+    exact?: boolean;
+}
+declare class BlockOperationRECEIVE extends BlockOperation implements BlockJSONOperationRECEIVE {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockOperationRECEIVE;
+    type: OperationType.RECEIVE;
+    constructor(input: BlockJSONOperationRECEIVE);
+    set from(from: string | GenericAccount);
+    get from(): GenericAccount;
+    set forward(forward: undefined | string | GenericAccount);
+    get forward(): GenericAccount | undefined;
+    set exact(exact: boolean | undefined);
+    get exact(): boolean;
+    set token(token: TokenPublicKeyString | TokenAddress);
+    get token(): TokenAddress;
+    set amount(amount: string | bigint);
+    get amount(): bigint;
+    validate(context: BlockOperationValidateContext): void;
+    toJSON(): JSONSupported<BlockJSONOperationSEND>;
+}
+interface BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE extends BlockJSONOperation {
+    type: OperationType.TOKEN_ADMIN_MODIFY_BALANCE;
+    token: TokenPublicKeyString | TokenAddress;
+    amount: string | bigint;
+    method: AdjustMethod;
+}
+declare class BlockOperationTOKEN_ADMIN_MODIFY_BALANCE extends BlockOperation implements BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockOperationTOKEN_ADMIN_MODIFY_BALANCE;
+    type: OperationType.TOKEN_ADMIN_MODIFY_BALANCE;
+    constructor(input: BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE);
+    set token(token: TokenPublicKeyString | TokenAddress);
+    get token(): TokenAddress;
+    set method(newMethod: AdjustMethod);
+    get method(): AdjustMethod;
+    set amount(amount: string | bigint);
+    get amount(): bigint;
+    validate(context: BlockOperationValidateContext): void;
+    toJSON(): JSONSupported<BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE>;
+}
+/**
+ * SetRep operation
+ */
+interface BlockJSONOperationSET_REP extends BlockJSONOperation {
+    type: OperationType.SET_REP;
+    to: string | GenericAccount;
+}
+declare class BlockOperationSET_REP extends BlockOperation implements BlockJSONOperationSET_REP {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockOperationSET_REP;
+    type: OperationType.SET_REP;
+    constructor(input: BlockJSONOperationSET_REP);
+    set to(to: string | Account);
+    get to(): Account;
+    validate(context: BlockOperationValidateContext): void;
+    toJSON(): JSONSupported<BlockJSONOperationSET_REP>;
+}
+/**
+ * TokenCreate Operation
+ */
+interface BlockJSONOperationCREATE_IDENTIFIER extends BlockJSONOperation {
+    type: OperationType.CREATE_IDENTIFIER;
+    identifier: IdentifierAddress | string;
+}
+declare class BlockOperationCREATE_IDENTIFIER extends BlockOperation implements BlockJSONOperationCREATE_IDENTIFIER {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockOperationCREATE_IDENTIFIER;
+    type: OperationType.CREATE_IDENTIFIER;
+    constructor(input: BlockJSONOperationCREATE_IDENTIFIER);
+    set identifier(identifier: string | IdentifierAddress);
+    get identifier(): IdentifierAddress;
+    validate(context: BlockOperationValidateContext): void;
+    toJSON(): JSONSupported<BlockJSONOperationCREATE_IDENTIFIER>;
+}
+/**
+ * SetInfo operation
+ */
+interface BlockJSONOperationSET_INFO extends BlockJSONOperation {
+    type: OperationType.SET_INFO;
+    name: string;
+    description: string;
+    metadata: string;
+    defaultPermission?: AcceptedPermissionTypes;
+}
+declare class BlockOperationSET_INFO extends BlockOperation implements BlockJSONOperationSET_INFO {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockOperationSET_INFO;
+    type: OperationType.SET_INFO;
+    constructor(input: BlockJSONOperationSET_INFO);
+    set name(name: string);
+    get name(): string;
+    set description(description: string);
+    get description(): string;
+    set metadata(metadata: string);
+    get metadata(): string;
+    set defaultPermission(newPerms: Permissions | undefined);
+    get defaultPermission(): Permissions | undefined;
+    validate(context: BlockOperationValidateContext): void;
+    toJSON(): JSONSupported<BlockJSONOperationSET_INFO>;
+}
+/**
+ * Set Permissions Operation
+ */
+interface BlockJSONOperationMODIFY_PERMISSIONS extends BlockJSONOperation {
+    type: OperationType.MODIFY_PERMISSIONS;
+    principal: string | GenericAccount;
+    method: AdjustMethod;
+    permissions: AcceptedPermissionTypes | null;
+    target?: string | GenericAccount;
+}
+declare class BlockOperationMODIFY_PERMISSIONS extends BlockOperation implements BlockJSONOperationMODIFY_PERMISSIONS {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockOperationMODIFY_PERMISSIONS;
+    type: OperationType.MODIFY_PERMISSIONS;
+    constructor(input: BlockJSONOperationMODIFY_PERMISSIONS);
+    set principal(principal: string | GenericAccount);
+    get principal(): GenericAccount;
+    set permissions(newPerms: Permissions | null);
+    get permissions(): Permissions | null;
+    set target(token: string | GenericAccount | undefined);
+    get target(): GenericAccount | undefined;
+    set method(method: AdjustMethod);
+    get method(): AdjustMethod;
+    validate(context: BlockOperationValidateContext): void;
+    toJSON(): JSONSupported<BlockOperationMODIFY_PERMISSIONS>;
+}
+/**
+ * Token Supply operation
+ */
+interface BlockJSONOperationTOKEN_ADMIN_SUPPLY extends BlockJSONOperation {
+    type: OperationType.TOKEN_ADMIN_SUPPLY;
+    amount: bigint | string;
+    method: Omit<AdjustMethod, AdjustMethod.SET>;
+}
+declare class BlockOperationTOKEN_ADMIN_SUPPLY extends BlockOperation implements BlockJSONOperationTOKEN_ADMIN_SUPPLY {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BlockOperationTOKEN_ADMIN_SUPPLY;
+    type: OperationType.TOKEN_ADMIN_SUPPLY;
+    constructor(input: BlockJSONOperationTOKEN_ADMIN_SUPPLY);
+    set amount(amount: string | bigint);
+    get amount(): bigint;
+    set method(shouldAdd: AdjustMethod);
+    get method(): AdjustMethod;
+    validate(context: BlockOperationValidateContext): void;
+    toJSON(): JSONSupported<BlockJSONOperationTOKEN_ADMIN_SUPPLY>;
+}
+/**
+ * Aggregate set of operations
+ */
+export declare const Operation: {
+    SEND: typeof BlockOperationSEND;
+    SET_REP: typeof BlockOperationSET_REP;
+    SET_INFO: typeof BlockOperationSET_INFO;
+    MODIFY_PERMISSIONS: typeof BlockOperationMODIFY_PERMISSIONS;
+    CREATE_IDENTIFIER: typeof BlockOperationCREATE_IDENTIFIER;
+    TOKEN_ADMIN_SUPPLY: typeof BlockOperationTOKEN_ADMIN_SUPPLY;
+    TOKEN_ADMIN_MODIFY_BALANCE: typeof BlockOperationTOKEN_ADMIN_MODIFY_BALANCE;
+    RECEIVE: typeof BlockOperationRECEIVE;
+};
+export type { BlockOperationSEND, BlockOperationSET_REP, BlockOperationSET_INFO, BlockOperationMODIFY_PERMISSIONS, BlockOperationCREATE_IDENTIFIER, BlockOperationTOKEN_ADMIN_SUPPLY, BlockOperationTOKEN_ADMIN_MODIFY_BALANCE, BlockOperationRECEIVE };
+export type BlockOperations = InstanceType<typeof Operation[keyof typeof OperationType]>;
+export type BlockJSONOperations = ConstructorParameters<typeof Operation[keyof typeof OperationType]>[0];
+export declare function createBlockOperation(input: BlockJSONOperations): BlockOperationSEND | BlockOperationRECEIVE | BlockOperationTOKEN_ADMIN_MODIFY_BALANCE | BlockOperationSET_REP | BlockOperationSET_INFO | BlockOperationMODIFY_PERMISSIONS | BlockOperationCREATE_IDENTIFIER | BlockOperationTOKEN_ADMIN_SUPPLY;
+export declare function isBlockOperation(input: any): input is BlockOperations;
+/**
+ * Export the "operations" mapping as something compatible with being
+ * serialized to JSON
+ */
+export declare function ExportOperationsJSON(operations: BlockOperations[]): JSONSupported<BlockJSONOperations>[];
+export declare function ImportOperationsJSON(operations: BlockOperations[] | BlockJSONOperations[]): BlockOperations[];
+export declare function ExportBlockOperations(operations: BlockOperations[]): ((Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+    contains: [bigint, bigint];
+    value: OperationType.TOKEN_ADMIN_SUPPLY;
+    kind: "explicit";
+}) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+    contains: [Buffer, bigint, bigint];
+    value: OperationType.TOKEN_ADMIN_MODIFY_BALANCE;
+    kind: "explicit";
+}) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+    contains: [Buffer, bigint, Buffer, (Omit<import("../utils/asn1").ASN1String, "kind"> & {
+        kind: "utf8";
+    }) | undefined];
+    value: OperationType.SEND;
+    kind: "explicit";
+}) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+    contains: [Buffer];
+    value: OperationType.SET_REP;
+    kind: "explicit";
+}) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+    contains: [Omit<import("../utils/asn1").ASN1String, "kind"> & {
+        kind: "utf8";
+    }, Omit<import("../utils/asn1").ASN1String, "kind"> & {
+        kind: "utf8";
+    }, Omit<import("../utils/asn1").ASN1String, "kind"> & {
+        kind: "utf8";
+    }, [bigint, bigint] | undefined];
+    value: OperationType.SET_INFO;
+    kind: "explicit";
+}) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+    contains: [Buffer, bigint, [bigint, bigint] | null, Buffer | undefined];
+    value: OperationType.MODIFY_PERMISSIONS;
+    kind: "explicit";
+}) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+    contains: [Buffer];
+    value: OperationType.CREATE_IDENTIFIER;
+    kind: "explicit";
+}) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+    contains: [bigint, Buffer, Buffer, boolean, Buffer | undefined];
+    value: OperationType.RECEIVE;
+    kind: "explicit";
+}))[];
+export declare function ImportOperationsASN1(input: unknown[], network: bigint): BlockOperations[];

package/lib/bootstrap.d.ts

@@ -0,0 +1,27 @@
+import type Node from './node';
+import type { KVStorageProvider } from './kv';
+import type { VoteStaple } from './vote';
+interface BootstrapFullConfig {
+    period: number;
+    timeout?: number;
+    kv: KVStorageProvider | null;
+    callback?: (voteStaple: VoteStaple) => Promise<void>;
+}
+export type BootstrapConfig = Partial<BootstrapFullConfig>;
+type NodeLike = Pick<Node, 'log' | 'config' | 'ledger'> & Partial<Pick<Node, 'switch'>>;
+export declare class BootstrapClient {
+    #private;
+    timeout: number;
+    static isInstance: (obj: any, strict?: boolean) => obj is BootstrapClient;
+    constructor(node: NodeLike, config?: BootstrapConfig);
+    resetKV(): Promise<void>;
+    stats(): Promise<{
+        lastUpdate: Date | undefined;
+        completeCount: number;
+    }>;
+    update(limit?: number): Promise<{
+        complete: boolean;
+    }>;
+    stop(): Promise<void>;
+}
+export default BootstrapClient;

package/lib/error/account.d.ts

@@ -0,0 +1,9 @@
+import KeetaNetError from '.';
+declare const AccountErrorType: "ACCOUNT";
+declare const AccountErrorCodes: readonly ["INVALID_PREFIX", "INVALID_KEYTYPE", "INVALID_KEYTYPE_EXTERNAL", "PASSPHRASE_WEAK", "INVALID_CONSTRUCTION", "NO_IDENTIFIER_SIGN", "NO_IDENTIFIER_VERIFY", "INVALID_IDENTIFIER_CONSTRUCTION", "SEED_INDEX_UNDEFINED", "SEED_INDEX_NEGATIVE", "SEED_INDEX_NOT_INT", "SEED_INDEX_TOO_LARGE", "ENCRYPTION_NOT_SUPPORTED"];
+export type AccountErrorCode = `${typeof AccountErrorType}_${typeof AccountErrorCodes[number]}`;
+export default class KeetaNetAccountError extends KeetaNetError {
+    static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetAccountError;
+    constructor(code: AccountErrorCode, message: string);
+}
+export {};

package/lib/error/block.d.ts

@@ -0,0 +1,9 @@
+import KeetaNetError from '.';
+declare const BlockErrorType: "BLOCK";
+declare const BlockErrorCodes: readonly ["INVALID_TYPE", "NO_MULTIPLE_SET_REP", "IDENTIFIER_NEED_DEFAULT_PERMISSIONS", "CANNOT_SEND_NON_TOKEN", "TOKEN_RECEIVE_DIFFERS", "ONLY_TOKEN_OP", "ONLY_IDENTIFIER_OP", "NO_TOKEN_OP", "NO_IDENTIFIER_OP", "IDENTIFIER_INVALID", "GENERAL_FIELD_INVALID", "PERMISSIONS_INVALID_DEFAULT", "PERMISSIONS_INVALID_ENTITY", "PERMISSIONS_INVALID_PRINCIPAL", "PERMISSIONS_INVALID_TARGET", "INVALID_ACCOUNT_TYPE", "NO_ADMIN_ON_TARGET", "PREVIOUS_SELF", "NO_DELEGATE_ADMIN", "NO_MODIFY_PERMISSION_DUPE", "CANNOT_FORWARD_TO_SELF", "EXACT_TRUE_WHEN_FORWARDING", "EXTERNAL_TOO_LONG", "EXTERNAL_INVALID", "EXTERNAL_MISSING"];
+export type BlockErrorCode = `${typeof BlockErrorType}_${typeof BlockErrorCodes[number]}`;
+export default class KeetaNetBlockError extends KeetaNetError {
+    static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetBlockError;
+    constructor(code: BlockErrorCode, message: string);
+}
+export {};

package/lib/error/client.d.ts

@@ -0,0 +1,9 @@
+import KeetaNetError from '.';
+declare const ClientErrorType: "CLIENT";
+declare const ClientErrorCodes: readonly ["BUILDER_CANNOT_READ_BEFORE_RENDER", "BUILDER_REQUIRES_PRIVATE_KEY", "BUILDER_AMOUNT_IS_ZERO"];
+export type ClientErrorCode = `${typeof ClientErrorType}_${typeof ClientErrorCodes[number]}`;
+export default class KeetaNetClientError extends KeetaNetError {
+    static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetClientError;
+    constructor(code: ClientErrorCode, message: string);
+}
+export {};

package/lib/error/index.d.ts

@@ -0,0 +1,20 @@
+import type { AccountErrorCode } from './account';
+import type { BlockErrorCode } from './block';
+import type { ClientErrorCode } from './client';
+import type { LedgerErrorCode } from './ledger';
+import type { VoteErrorCode } from './vote';
+import type { KVErrorCode } from './kv';
+import type { PermissionsErrorCode } from './permissions';
+export type ErrorCode = BlockErrorCode | LedgerErrorCode | AccountErrorCode | ClientErrorCode | VoteErrorCode | PermissionsErrorCode | KVErrorCode;
+export declare function ExpectErrorCode(code: ErrorCode, test: () => any): Promise<void>;
+interface ValidationOptions {
+    type: string;
+    codes: string[] | Readonly<string[]>;
+}
+export default class KeetaNetError extends Error {
+    static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetError;
+    type: string;
+    code: ErrorCode;
+    constructor(code: ErrorCode, message: string, validation?: ValidationOptions);
+}
+export {};

package/lib/error/kv.d.ts

@@ -0,0 +1,9 @@
+import KeetaNetError from '.';
+declare const KVErrorType: "KV";
+declare const KVErrorCodes: readonly ["TTL_NOT_SUPPORTED"];
+export type KVErrorCode = `${typeof KVErrorType}_${typeof KVErrorCodes[number]}`;
+export default class KeetaNetKVError extends KeetaNetError {
+    static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetKVError;
+    constructor(code: KVErrorCode, message: string);
+}
+export {};