@keetanetwork/keetanet-client 0.14.13 → 0.16.0

package/lib/block/index.d.ts

@@ -2,7 +2,7 @@ import type { GenericAccount, MultisigAddress } from '../account';
 import Account, { AccountKeyAlgorithm } from '../account';
 import { BufferStorage } from '../utils/buffer';
 import * as ASN1 from '../utils/asn1';
-import type { ToJSONSerializable, ToJSONSerializableOptions } from '../utils/conversion';
+import { type ToJSONSerializable, type ToJSONSerializableOptions } from '../utils/conversion';
 import * as Operations from './operations';
 export declare enum BlockPurpose {
     GENERIC = 0,
@@ -63,6 +63,9 @@ export interface BlockV1JSON {
     purpose?: BlockPurpose.GENERIC;
 }
 export type BlockV1JSONIncomplete = Partial<BlockV1JSON>;
+type BlockV1JSONOptionalSigned = Omit<BlockV1JSON, 'signature'> & {
+    signature?: BlockV1JSON['signature'];
+};
 /**
  * Output of block suitable to JSON serialization
  */
@@ -83,12 +86,22 @@ export interface BlockV2JSON {
     signatures: (string | BlockSignature)[];
 }
 export type BlockV2JSONIncomplete = Partial<BlockV2JSON>;
+type BlockV2JSONOptionalSigned = Omit<BlockV2JSON, 'signatures'> & {
+    signatures?: BlockV2JSON['signatures'];
+};
 export type BlockJSONOutput = ReturnType<Block['toJSON']>;
 export type BlockJSONOutputSerialized = ToJSONSerializable<BlockJSONOutput>;
 export type BlockJSONOutputIncomplete = Partial<BlockJSONOutputSerialized>;
 export type BlockJSON = (Omit<BlockV1JSON, 'version'> | Omit<BlockV2JSON, 'version'>) & {
     version: number;
 };
+export type BlockJSONOptionalSigned = ((Omit<BlockV1JSON, 'version' | 'signature'> & {
+    signature?: BlockV1JSON['signature'];
+}) | (Omit<BlockV2JSON, 'version' | 'signatures'> & {
+    signatures?: BlockV2JSON['signatures'];
+})) & {
+    version: number;
+};
 export type BlockJSONIncomplete = Partial<BlockJSON>;
 /**
  * Map input to our values
@@ -127,7 +140,7 @@ interface BlockV2Canonical extends Omit<BlockV2UnsignedCanonical, 'signatures'>
 type OmitLastArrayValue<T> = Required<T> extends [...infer Head, any] ? Head : never;
 type BlockV1ASN1WithoutSignature = ASN1.ValidateASN1.SchemaMap<OmitLastArrayValue<typeof BlockV1ASN1Schema>>;
 type BlockV2ASN1WithoutSignature = ASN1.ValidateASN1.SchemaMap<OmitLastArrayValue<typeof BlockV2ASN1Schema.contains>>;
-type MultisigSignerFieldJSON = [MultisigAddress | string, (MultisigSignerField | Account | string)[]];
+type MultisigSignerFieldJSON = [MultisigAddress | string, (MultisigSignerFieldJSON | Account | string)[]];
 type BlockSignerFieldJSON = Account | string | MultisigSignerFieldJSON;
 type BlockASN1SchemaWithoutSignature = BlockV1ASN1WithoutSignature | {
     type: 'context';
@@ -135,16 +148,14 @@ type BlockASN1SchemaWithoutSignature = BlockV1ASN1WithoutSignature | {
     value: 1;
     contains: BlockV2ASN1WithoutSignature;
 };
-type MultisigSignerField = [MultisigAddress, (MultisigSignerField | Account)[]];
 type BlockSignerField = Account | [MultisigAddress, BlockSignerField[]];
 type BlockSignatureField = [BlockSignature, ...BlockSignature[]];
 /**
  * Block:  An item which contains a number of operations (transactions) which
  * originated from an account at a particular instant
  */
-export declare class Block implements Omit<BlockV2Canonical, 'version'> {
+declare abstract class PossiblyUnsignedBlock<HasSignature extends boolean> implements Omit<BlockV2Canonical, 'version' | 'signatures'> {
     #private;
-    static isInstance: (obj: any, strict?: boolean) => obj is Block;
     static readonly Hash: typeof BlockHash;
     static readonly OperationType: typeof Operations.OperationType;
     static readonly Operation: {
@@ -172,35 +183,176 @@ export declare class Block implements Omit<BlockV2Canonical, 'version'> {
     readonly network: NetworkID;
     readonly subnet: SubnetID | undefined;
     readonly signer: BlockSignerField;
-    readonly signatures: BlockSignatureField;
-    get principal(): Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1> | MultisigAddress;
+    readonly signatures: HasSignature extends true ? BlockSignatureField : null;
+    get principal(): MultisigAddress | Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1>;
+    protected static getSortedRequiredSigners(input: BlockSignerField): Account[];
     readonly $opening: boolean;
-    static fromUnsignedJSON(input: BlockV1UnsignedCanonical | BlockV2UnsignedCanonical): Promise<Block>;
-    static isValidJSON<Version extends 1 | 2>(block: unknown, version?: Version): block is ({
+    protected static isValidJSONSignedOrUnsigned<AssertSignatureField extends boolean, Version extends 1 | 2>(assertSignatureIncluded: AssertSignatureField, block: unknown, version?: Version): block is AssertSignatureField extends true ? ({
         1: BlockV1JSON;
         2: BlockV2JSON;
+    }[Version]) : ({
+        1: BlockV1JSONOptionalSigned;
+        2: BlockV2JSONOptionalSigned;
     }[Version]);
-    constructor(input: Buffer | ArrayBuffer | BlockJSON | BlockJSONOutput | BlockJSONOutputSerialized | Block | string);
+    constructor(input: Buffer | ArrayBuffer | BlockJSON | BlockJSONOptionalSigned | BlockJSONOutput | BlockJSONOutputSerialized | UnsignedBlock | Block | string, hasSignature: HasSignature);
     static getAccountOpeningHash(account: GenericAccount): BlockHash;
-    toBytes(includeSignatures?: boolean, useCached?: boolean): ArrayBuffer;
+    toBytes(includeSignatures?: HasSignature): ArrayBuffer;
     protected static getV1ASN1ContainerWithoutSignature(input: BlockV1UnsignedCanonical | BlockV1Canonical): BlockV1ASN1WithoutSignature;
     protected static getV2ASN1ContainerWithoutSignature(input: BlockV2UnsignedCanonical | BlockV2Canonical): BlockV2ASN1WithoutSignature;
-    protected static getASN1ContainerWithoutSignature(input: BlockV1UnsignedCanonical | BlockV1Canonical | BlockV2UnsignedCanonical | BlockV2Canonical): BlockASN1SchemaWithoutSignature;
+    protected static getASN1ContainerWithoutSignature(input: Omit<BlockV1UnsignedCanonical, 'signature'> | Omit<BlockV2UnsignedCanonical, 'signatures'>): BlockASN1SchemaWithoutSignature;
     toJSON(options?: ToJSONSerializableOptions): {
-        $binary?: string;
-        signature?: string;
-        signatures?: string[];
+        $binary?: string | undefined;
+        signature?: string | undefined;
+        signatures?: string[] | undefined;
         version: 1 | 2;
         idempotent: string | undefined;
-        date: Date;
-        previous: BlockHash;
-        account: GenericAccount;
+        date: string;
+        previous: BlockHashString;
+        account: import("../account").TokenPublicKeyString | import("../account").NetworkPublicKeyString | import("../account").StoragePublicKeyString | import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
         purpose: BlockPurpose;
-        signer: Account | [MultisigAddress, any[]];
-        network: bigint;
-        subnet: bigint | undefined;
-        operations: Operations.ExportedJSONOperation[];
-        $hash: BlockHash;
+        signer: import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString | [import("../account").MultisigPublicKeyString, (import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString | [import("../account").MultisigPublicKeyString, (import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString | [import("../account").MultisigPublicKeyString, (import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString | [import("../account").MultisigPublicKeyString, (import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString | [never, never[]])[]])[]])[]])[]];
+        network: string;
+        subnet: string | undefined;
+        operations: ({
+            type: Operations.OperationType.SEND;
+            to: string;
+            amount: string;
+            token: import("../account").TokenPublicKeyString;
+            external?: string | undefined;
+        } | {
+            type: Operations.OperationType.SET_REP;
+            to: string;
+        } | {
+            type: Operations.OperationType.SET_INFO;
+            name: string;
+            description: string;
+            metadata: string;
+            defaultPermission?: false | [string, number[]] | [string, string] | [number[] | import("../permissions").BaseFlagNames, number[]] | undefined;
+        } | {
+            type: Operations.OperationType.MODIFY_PERMISSIONS;
+            principal: string;
+            method: AdjustMethod;
+            permissions: false | [string, number[]] | [string, string] | [number[] | import("../permissions").BaseFlagNames, number[]] | null;
+            target?: string | undefined;
+        } | {
+            type: Operations.OperationType.CREATE_IDENTIFIER;
+            identifier: string;
+            createArguments?: {
+                type: AccountKeyAlgorithm.MULTISIG;
+                signers: (import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString)[];
+                quorum: string;
+            } | {
+                type: AccountKeyAlgorithm.MULTISIG;
+                signers: (import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString)[];
+                quorum: string;
+            } | undefined;
+        } | {
+            type: Operations.OperationType.TOKEN_ADMIN_SUPPLY;
+            amount: string;
+            method: AdjustMethod.ADD | AdjustMethod.SUBTRACT;
+        } | {
+            type: Operations.OperationType.TOKEN_ADMIN_MODIFY_BALANCE;
+            token: import("../account").TokenPublicKeyString;
+            amount: string;
+            method: AdjustMethod;
+        } | {
+            type: Operations.OperationType.RECEIVE;
+            amount: string;
+            token: import("../account").TokenPublicKeyString;
+            from: string;
+            forward?: string | undefined;
+            exact?: boolean | undefined;
+        } | {
+            type: Operations.OperationType.MANAGE_CERTIFICATE;
+            certificateOrHash: string | (string & {
+                readonly __certificateHash: never;
+            }) | {
+                $binary?: string | undefined;
+                $chain?: undefined;
+                serial: string;
+                notBefore: string;
+                notAfter: string;
+                subject: string;
+                issuer: string;
+                subjectPublicKey: import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
+                baseExtensions: {
+                    basicConstraints?: [ca: boolean, pathLenConstraint?: string | undefined] | undefined;
+                    keyUsage?: {
+                        digitalSignature?: boolean | undefined;
+                        nonRepudiation?: boolean | undefined;
+                        keyEncipherment?: boolean | undefined;
+                        dataEncipherment?: boolean | undefined;
+                        keyAgreement?: boolean | undefined;
+                        keyCertSign?: boolean | undefined;
+                        cRLSign?: boolean | undefined;
+                        encipherOnly?: boolean | undefined;
+                        decipherOnly?: boolean | undefined;
+                    } | undefined;
+                    subjectKeyIdentifier?: string | undefined;
+                    authorityKeyIdentifier?: {
+                        type: "context";
+                        value: 0;
+                        contains: string;
+                    } | undefined;
+                } | undefined;
+                subjectDN: {
+                    name: string;
+                    value: string;
+                }[];
+                issuerDN: {
+                    name: string;
+                    value: string;
+                }[];
+                $hash: string & {
+                    readonly __certificateHash: never;
+                };
+            } | {
+                $binary?: string | undefined;
+                $chain?: undefined;
+                serial: string;
+                notBefore: string;
+                notAfter: string;
+                subject: string;
+                issuer: string;
+                subjectPublicKey: import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
+                baseExtensions: {
+                    basicConstraints?: [ca: boolean, pathLenConstraint?: string | undefined] | undefined;
+                    keyUsage?: {
+                        digitalSignature?: boolean | undefined;
+                        nonRepudiation?: boolean | undefined;
+                        keyEncipherment?: boolean | undefined;
+                        dataEncipherment?: boolean | undefined;
+                        keyAgreement?: boolean | undefined;
+                        keyCertSign?: boolean | undefined;
+                        cRLSign?: boolean | undefined;
+                        encipherOnly?: boolean | undefined;
+                        decipherOnly?: boolean | undefined;
+                    } | undefined;
+                    subjectKeyIdentifier?: string | undefined;
+                    authorityKeyIdentifier?: {
+                        type: "context";
+                        value: 0;
+                        contains: string;
+                    } | undefined;
+                } | undefined;
+                subjectDN: {
+                    name: string;
+                    value: string;
+                }[];
+                issuerDN: {
+                    name: string;
+                    value: string;
+                }[];
+                $hash: string & {
+                    readonly __certificateHash: never;
+                };
+            };
+            intermediateCertificates?: string | {
+                certificates: string[];
+            } | null | undefined;
+            method: Exclude<AdjustMethod, AdjustMethod.SET>;
+        })[];
+        $hash: BlockHashString;
         $opening: boolean;
     };
     /**
@@ -213,6 +365,26 @@ export declare class Block implements Omit<BlockV2Canonical, 'version'> {
      */
     get hash(): BlockHash;
 }
+export declare class UnsignedBlock extends PossiblyUnsignedBlock<false> implements Omit<BlockV2Canonical, 'version' | 'signatures'> {
+    static isInstance: (obj: any, strict?: boolean) => obj is UnsignedBlock;
+    constructor(input: ConstructorParameters<typeof PossiblyUnsignedBlock>[0]);
+    static isValidJSON<Version extends 1 | 2>(block: unknown, version?: Version): block is ({
+        1: Omit<BlockV1JSON, 'signature'>;
+        2: Omit<BlockV2JSON, 'signatures'>;
+    }[Version]);
+    static fromUnsignedJSON(input: BlockV1UnsignedCanonical | BlockV2UnsignedCanonical): Promise<UnsignedBlock>;
+    seal(): Promise<Block>;
+}
+export declare class Block extends PossiblyUnsignedBlock<true> implements Omit<BlockV2Canonical, 'version'> {
+    static isInstance: (obj: any, strict?: boolean) => obj is Block;
+    constructor(input: ConstructorParameters<typeof PossiblyUnsignedBlock>[0]);
+    static isValidJSON<Version extends 1 | 2>(block: unknown, version?: Version): block is ({
+        1: BlockV1JSON;
+        2: BlockV2JSON;
+    }[Version]);
+    static fromUnsignedJSON(input: Omit<BlockV1UnsignedCanonical, 'signature'> | Omit<BlockV2UnsignedCanonical, 'signatures'>): Promise<Block>;
+    getUnsignedBlock(): UnsignedBlock;
+}
 export declare class BlockBuilder {
     #private;
     static isInstance: (obj: any, strict?: boolean) => obj is BlockBuilder;
@@ -235,34 +407,157 @@ export declare class BlockBuilder {
     protected get currentWIP(): BlockJSONIncomplete;
     protected get currentBlockSealed(): Block;
     toJSON(opts?: ToJSONSerializableOptions): {
-        $binary?: string;
-        signature?: string;
-        signatures?: string[];
-        version: 1 | 2;
-        idempotent: string | undefined;
-        date: Date;
-        previous: BlockHash;
-        account: GenericAccount;
-        purpose: BlockPurpose;
-        signer: Account | [MultisigAddress, any[]];
-        network: bigint;
-        subnet: bigint | undefined;
-        operations: Operations.ExportedJSONOperation[];
-        $hash: BlockHash;
-        $opening: boolean;
-    } | {
         version: number | undefined;
         idempotent: string | undefined;
-        date: Date | undefined;
-        previous: BlockHash | undefined;
-        account: GenericAccount | undefined;
-        signer: BlockSignerFieldJSON | undefined;
-        network: bigint | undefined;
-        subnet: bigint | undefined;
-        operations: Operations.BlockOperations[] | undefined;
+        date: string | undefined;
+        previous: BlockHashString | undefined;
+        account: import("../account").TokenPublicKeyString | import("../account").NetworkPublicKeyString | import("../account").StoragePublicKeyString | import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString | undefined;
+        signer: string | [string, (string | [string, (string | [string, (string | [string, (string | [string, never[]])[]])[]])[]])[]] | undefined;
+        network: string | undefined;
+        subnet: string | undefined;
+        operations: ({
+            type: Operations.OperationType.SEND;
+            to: string;
+            amount: string;
+            token: import("../account").TokenPublicKeyString;
+            external?: string | undefined;
+        } | {
+            type: Operations.OperationType.SET_REP;
+            to: string;
+        } | {
+            type: Operations.OperationType.SET_INFO;
+            name: string;
+            description: string;
+            metadata: string;
+            defaultPermission?: false | [string, number[]] | [string, string] | [number[] | import("../permissions").BaseFlagNames, number[]] | undefined;
+        } | {
+            type: Operations.OperationType.MODIFY_PERMISSIONS;
+            principal: string;
+            method: AdjustMethod;
+            permissions: false | [string, number[]] | [string, string] | [number[] | import("../permissions").BaseFlagNames, number[]] | null;
+            target?: string | undefined;
+        } | {
+            type: Operations.OperationType.CREATE_IDENTIFIER;
+            identifier: string;
+            createArguments?: {
+                type: AccountKeyAlgorithm.MULTISIG;
+                signers: (import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString)[];
+                quorum: string;
+            } | {
+                type: AccountKeyAlgorithm.MULTISIG;
+                signers: (import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString)[];
+                quorum: string;
+            } | undefined;
+        } | {
+            type: Operations.OperationType.TOKEN_ADMIN_SUPPLY;
+            amount: string;
+            method: AdjustMethod.ADD | AdjustMethod.SUBTRACT;
+        } | {
+            type: Operations.OperationType.TOKEN_ADMIN_MODIFY_BALANCE;
+            token: import("../account").TokenPublicKeyString;
+            amount: string;
+            method: AdjustMethod;
+        } | {
+            type: Operations.OperationType.RECEIVE;
+            amount: string;
+            token: import("../account").TokenPublicKeyString;
+            from: string;
+            forward?: string | undefined;
+            exact?: boolean | undefined;
+        } | {
+            type: Operations.OperationType.MANAGE_CERTIFICATE;
+            certificateOrHash: string | (string & {
+                readonly __certificateHash: never;
+            }) | {
+                $binary?: string | undefined;
+                $chain?: undefined;
+                serial: string;
+                notBefore: string;
+                notAfter: string;
+                subject: string;
+                issuer: string;
+                subjectPublicKey: import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
+                baseExtensions: {
+                    basicConstraints?: [ca: boolean, pathLenConstraint?: string | undefined] | undefined;
+                    keyUsage?: {
+                        digitalSignature?: boolean | undefined;
+                        nonRepudiation?: boolean | undefined;
+                        keyEncipherment?: boolean | undefined;
+                        dataEncipherment?: boolean | undefined;
+                        keyAgreement?: boolean | undefined;
+                        keyCertSign?: boolean | undefined;
+                        cRLSign?: boolean | undefined;
+                        encipherOnly?: boolean | undefined;
+                        decipherOnly?: boolean | undefined;
+                    } | undefined;
+                    subjectKeyIdentifier?: string | undefined;
+                    authorityKeyIdentifier?: {
+                        type: "context";
+                        value: 0;
+                        contains: string;
+                    } | undefined;
+                } | undefined;
+                subjectDN: {
+                    name: string;
+                    value: string;
+                }[];
+                issuerDN: {
+                    name: string;
+                    value: string;
+                }[];
+                $hash: string & {
+                    readonly __certificateHash: never;
+                };
+            } | {
+                $binary?: string | undefined;
+                $chain?: undefined;
+                serial: string;
+                notBefore: string;
+                notAfter: string;
+                subject: string;
+                issuer: string;
+                subjectPublicKey: import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
+                baseExtensions: {
+                    basicConstraints?: [ca: boolean, pathLenConstraint?: string | undefined] | undefined;
+                    keyUsage?: {
+                        digitalSignature?: boolean | undefined;
+                        nonRepudiation?: boolean | undefined;
+                        keyEncipherment?: boolean | undefined;
+                        dataEncipherment?: boolean | undefined;
+                        keyAgreement?: boolean | undefined;
+                        keyCertSign?: boolean | undefined;
+                        cRLSign?: boolean | undefined;
+                        encipherOnly?: boolean | undefined;
+                        decipherOnly?: boolean | undefined;
+                    } | undefined;
+                    subjectKeyIdentifier?: string | undefined;
+                    authorityKeyIdentifier?: {
+                        type: "context";
+                        value: 0;
+                        contains: string;
+                    } | undefined;
+                } | undefined;
+                subjectDN: {
+                    name: string;
+                    value: string;
+                }[];
+                issuerDN: {
+                    name: string;
+                    value: string;
+                }[];
+                $hash: string & {
+                    readonly __certificateHash: never;
+                };
+            };
+            intermediateCertificates?: string | {
+                certificates: string[];
+            } | null | undefined;
+            method: Exclude<AdjustMethod, AdjustMethod.SET>;
+        })[] | undefined;
         purpose: BlockPurpose;
         $opening: boolean | undefined;
     };
+    getUnsignedBlock(): Promise<UnsignedBlock>;
     seal(): Promise<Block>;
     unseal(): BlockJSONIncomplete;
     get sealed(): boolean;

package/lib/block/operations.d.ts

@@ -6,7 +6,7 @@ import type { AcceptedPermissionTypes } from '../permissions';
 import { Permissions } from '../permissions';
 import type { ToJSONSerializable } from '../utils/conversion';
 import Block, { AdjustMethod } from '.';
-import { Certificate, CertificateBundle, CertificateHash } from '../utils/certificate';
+import { Certificate, CertificateBundle, type CertificateBundleJSONOutput, CertificateHash } from '../utils/certificate';
 import type { MultisigConfig } from '../ledger/types';
 /**
  * All supported operations
@@ -180,7 +180,7 @@ export interface BlockJSONOperation {
     type: OperationType;
 }
 interface BlockOperationValidateContext {
-    block: Block;
+    block: Pick<Block, 'network' | 'account' | 'signer' | 'operations' | 'previous' | 'date'>;
     operationIndex: number;
 }
 declare class BlockOperation {
@@ -211,7 +211,7 @@ declare class BlockOperationSEND extends BlockOperation implements BlockJSONOper
     set amount(amount: string | bigint);
     get amount(): bigint;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): BlockJSONOperationSEND;
+    toJSON(): ToJSONSerializable<BlockJSONOperationSEND>;
 }
 export interface BlockJSONOperationRECEIVE extends BlockJSONOperation {
     type: OperationType.RECEIVE;
@@ -237,7 +237,7 @@ declare class BlockOperationRECEIVE extends BlockOperation implements BlockJSONO
     set amount(amount: string | bigint);
     get amount(): bigint;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): BlockJSONOperationRECEIVE;
+    toJSON(): ToJSONSerializable<BlockJSONOperationRECEIVE>;
 }
 export interface BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE extends BlockJSONOperation {
     type: OperationType.TOKEN_ADMIN_MODIFY_BALANCE;
@@ -257,7 +257,7 @@ declare class BlockOperationTOKEN_ADMIN_MODIFY_BALANCE extends BlockOperation im
     set amount(amount: string | bigint);
     get amount(): bigint;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE;
+    toJSON(): ToJSONSerializable<BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE>;
 }
 /**
  * SetRep operation
@@ -274,7 +274,7 @@ declare class BlockOperationSET_REP extends BlockOperation implements BlockJSONO
     set to(to: string | Account);
     get to(): Account;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): BlockJSONOperationSET_REP;
+    toJSON(): ToJSONSerializable<BlockJSONOperationSET_REP>;
 }
 /**
  * TokenCreate Operation
@@ -300,7 +300,7 @@ declare class BlockOperationCREATE_IDENTIFIER extends BlockOperation implements
     set createArguments(input: IdentifierCreateArguments | ToJSONSerializable<IdentifierCreateArguments> | undefined);
     get createArguments(): IdentifierCreateArguments | undefined;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): BlockJSONOperationCREATE_IDENTIFIER;
+    toJSON(): ToJSONSerializable<BlockJSONOperationCREATE_IDENTIFIER>;
 }
 /**
  * SetInfo operation
@@ -326,7 +326,7 @@ declare class BlockOperationSET_INFO extends BlockOperation implements BlockJSON
     set defaultPermission(newPerms: Permissions | undefined);
     get defaultPermission(): Permissions | undefined;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): BlockJSONOperationSET_INFO;
+    toJSON(): ToJSONSerializable<BlockJSONOperationSET_INFO>;
 }
 /**
  * Set Permissions Operation
@@ -352,7 +352,7 @@ declare class BlockOperationMODIFY_PERMISSIONS extends BlockOperation implements
     set method(method: AdjustMethod);
     get method(): AdjustMethod;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): BlockJSONOperationMODIFY_PERMISSIONS;
+    toJSON(): ToJSONSerializable<BlockJSONOperationMODIFY_PERMISSIONS>;
 }
 /**
  * Token Supply operation
@@ -372,21 +372,17 @@ declare class BlockOperationTOKEN_ADMIN_SUPPLY extends BlockOperation implements
     set method(shouldAdd: BlockJSONOperationTOKEN_ADMIN_SUPPLY['method']);
     get method(): BlockJSONOperationTOKEN_ADMIN_SUPPLY['method'];
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): BlockJSONOperationTOKEN_ADMIN_SUPPLY;
+    toJSON(): ToJSONSerializable<BlockJSONOperationTOKEN_ADMIN_SUPPLY>;
 }
 /**
  * X.509 Certificate operations
  */
 export interface BlockJSONOperationMANAGE_CERTIFICATE extends BlockJSONOperation {
     type: OperationType.MANAGE_CERTIFICATE;
-    certificateOrHash: string | Certificate | Buffer | CertificateHash;
-    intermediateCertificates?: string | CertificateBundle | Buffer | null;
+    certificateOrHash: string | CertificateHash | ConstructorParameters<typeof Certificate>[0];
+    intermediateCertificates?: string | CertificateBundle | CertificateBundleJSONOutput | null;
     method: Exclude<AdjustMethod, AdjustMethod.SET>;
 }
-export interface BlockJSONOperationMANAGE_CERTIFICATESerializable extends Omit<BlockJSONOperationMANAGE_CERTIFICATE, 'certificateOrHash' | 'intermediateCertificates'> {
-    certificateOrHash: string | Buffer;
-    intermediateCertificates?: string | Buffer | null;
-}
 declare class BlockOperationMANAGE_CERTIFICATE extends BlockOperation implements BlockJSONOperationMANAGE_CERTIFICATE {
     #private;
     type: OperationType.MANAGE_CERTIFICATE;
@@ -398,7 +394,7 @@ declare class BlockOperationMANAGE_CERTIFICATE extends BlockOperation implements
     set method(shouldAdd: Exclude<AdjustMethod, AdjustMethod.SET>);
     get method(): Exclude<AdjustMethod, AdjustMethod.SET>;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): BlockJSONOperationMANAGE_CERTIFICATESerializable;
+    toJSON(): ToJSONSerializable<BlockJSONOperationMANAGE_CERTIFICATE>;
 }
 /**
  * Aggregate set of operations
@@ -419,14 +415,11 @@ export type BlockOperations = InstanceType<typeof Operation[keyof typeof Operati
 export type BlockJSONOperations = ConstructorParameters<typeof Operation[keyof typeof OperationType]>[0];
 export declare function createBlockOperation(input: BlockJSONOperations | ToJSONSerializable<BlockJSONOperations>): BlockOperationSEND | BlockOperationSET_REP | BlockOperationSET_INFO | BlockOperationMODIFY_PERMISSIONS | BlockOperationCREATE_IDENTIFIER | BlockOperationTOKEN_ADMIN_SUPPLY | BlockOperationTOKEN_ADMIN_MODIFY_BALANCE | BlockOperationRECEIVE | BlockOperationMANAGE_CERTIFICATE;
 export declare function isBlockOperation(input: any): input is BlockOperations;
-export type ExportedJSONOperation = {
-    [K in keyof typeof Operation]: ToJSONSerializable<ReturnType<InstanceType<typeof Operation[K]>['toJSON']>>;
-}[keyof typeof Operation];
 /**
  * Export the "operations" mapping as something compatible with being
  * serialized to JSON
  */
-export declare function ExportOperationsJSON(operations: BlockOperations[]): ExportedJSONOperation[];
+export declare function ExportOperationsJSON(operations: BlockOperations[]): ToJSONSerializable<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];

package/lib/error/block.d.ts

@@ -1,6 +1,6 @@
 import { KeetaNetErrorBase } from './base';
-export declare const BlockErrorCodes: readonly ["AMOUNT_BELOW_ZERO", "CANNOT_FORWARD_TO_SELF", "CANNOT_SEND_NON_TOKEN", "CERTIFICATE_SUBJECT_MISMATCH", "EXACT_TRUE_WHEN_FORWARDING", "EXTERNAL_INVALID", "EXTERNAL_MISSING", "EXTERNAL_TOO_LONG", "GENERAL_FIELD_INVALID", "IDENTIFIER_INVALID", "IDENTIFIER_NEED_DEFAULT_PERMISSIONS", "INTERMEDIATE_CERTIFICATES_ONLY_ADD", "INVALID_ACCOUNT_TYPE", "INVALID_CERTIFICATE_VALUE", "INVALID_CREATE_IDENTIFIER_ARGS", "INVALID_IDEMPOTENT_FORMAT", "INVALID_IDEMPOTENT_LENGTH", "INVALID_MULTISIG_QUORUM", "INVALID_MULTISIG_SIGNER_COUNT", "INVALID_MULTISIG_SIGNER_DEPTH", "INVALID_MULTISIG_SIGNER_DUPLICATE", "INVALID_PURPOSE_VALIDATION", "INVALID_SIGNATURE", "INVALID_SIGNER", "INVALID_TYPE", "INVALID_VERSION", "NO_ADMIN_ON_TARGET", "NO_DELEGATE_ADMIN", "NO_DUPLICATE_CERTIFICATE_OPERATION", "NO_IDENTIFIER_OP", "NO_MODIFY_PERMISSION_DUPE", "NO_MULTIPLE_SET_REP", "NO_MULTISIG_OP", "NO_TOKEN_OP", "ONLY_IDENTIFIER_OP", "ONLY_TOKEN_OP", "PERMISSIONS_INVALID_DEFAULT", "PERMISSIONS_INVALID_ENTITY", "PERMISSIONS_INVALID_PRINCIPAL", "PERMISSIONS_INVALID_TARGET", "PREVIOUS_SELF", "SUPPLY_INVALID", "TOKEN_RECEIVE_DIFFERS"];
-export declare const FullBlockErrorCodes: ("BLOCK_AMOUNT_BELOW_ZERO" | "BLOCK_CANNOT_FORWARD_TO_SELF" | "BLOCK_CANNOT_SEND_NON_TOKEN" | "BLOCK_CERTIFICATE_SUBJECT_MISMATCH" | "BLOCK_EXACT_TRUE_WHEN_FORWARDING" | "BLOCK_EXTERNAL_INVALID" | "BLOCK_EXTERNAL_MISSING" | "BLOCK_EXTERNAL_TOO_LONG" | "BLOCK_GENERAL_FIELD_INVALID" | "BLOCK_IDENTIFIER_INVALID" | "BLOCK_IDENTIFIER_NEED_DEFAULT_PERMISSIONS" | "BLOCK_INTERMEDIATE_CERTIFICATES_ONLY_ADD" | "BLOCK_INVALID_ACCOUNT_TYPE" | "BLOCK_INVALID_CERTIFICATE_VALUE" | "BLOCK_INVALID_CREATE_IDENTIFIER_ARGS" | "BLOCK_INVALID_IDEMPOTENT_FORMAT" | "BLOCK_INVALID_IDEMPOTENT_LENGTH" | "BLOCK_INVALID_MULTISIG_QUORUM" | "BLOCK_INVALID_MULTISIG_SIGNER_COUNT" | "BLOCK_INVALID_MULTISIG_SIGNER_DEPTH" | "BLOCK_INVALID_MULTISIG_SIGNER_DUPLICATE" | "BLOCK_INVALID_PURPOSE_VALIDATION" | "BLOCK_INVALID_SIGNATURE" | "BLOCK_INVALID_SIGNER" | "BLOCK_INVALID_TYPE" | "BLOCK_INVALID_VERSION" | "BLOCK_NO_ADMIN_ON_TARGET" | "BLOCK_NO_DELEGATE_ADMIN" | "BLOCK_NO_DUPLICATE_CERTIFICATE_OPERATION" | "BLOCK_NO_IDENTIFIER_OP" | "BLOCK_NO_MODIFY_PERMISSION_DUPE" | "BLOCK_NO_MULTIPLE_SET_REP" | "BLOCK_NO_MULTISIG_OP" | "BLOCK_NO_TOKEN_OP" | "BLOCK_ONLY_IDENTIFIER_OP" | "BLOCK_ONLY_TOKEN_OP" | "BLOCK_PERMISSIONS_INVALID_DEFAULT" | "BLOCK_PERMISSIONS_INVALID_ENTITY" | "BLOCK_PERMISSIONS_INVALID_PRINCIPAL" | "BLOCK_PERMISSIONS_INVALID_TARGET" | "BLOCK_PREVIOUS_SELF" | "BLOCK_SUPPLY_INVALID" | "BLOCK_TOKEN_RECEIVE_DIFFERS")[];
+export declare const BlockErrorCodes: readonly ["AMOUNT_BELOW_ZERO", "CANNOT_FORWARD_TO_SELF", "CANNOT_SEND_NON_TOKEN", "CERTIFICATE_SUBJECT_MISMATCH", "EXACT_TRUE_WHEN_FORWARDING", "EXTERNAL_INVALID", "EXTERNAL_MISSING", "EXTERNAL_TOO_LONG", "GENERAL_FIELD_INVALID", "IDENTIFIER_INVALID", "IDENTIFIER_NEED_DEFAULT_PERMISSIONS", "INTERMEDIATE_CERTIFICATES_ONLY_ADD", "INVALID_ACCOUNT_TYPE", "INVALID_CERTIFICATE_VALUE", "INVALID_CREATE_IDENTIFIER_ARGS", "INVALID_IDEMPOTENT_FORMAT", "INVALID_IDEMPOTENT_LENGTH", "INVALID_MULTISIG_QUORUM", "INVALID_MULTISIG_SIGNER_COUNT", "INVALID_MULTISIG_SIGNER_DEPTH", "INVALID_MULTISIG_SIGNER_DUPLICATE", "INVALID_PURPOSE_VALIDATION", "INVALID_SIGNATURE", "INVALID_SIGNER", "INVALID_TYPE", "INVALID_VERSION", "NO_ADMIN_ON_TARGET", "NO_DELEGATE_ADMIN", "NO_DUPLICATE_CERTIFICATE_OPERATION", "NO_IDENTIFIER_OP", "NO_MODIFY_PERMISSION_DUPE", "NO_MULTIPLE_SET_REP", "NO_MULTISIG_OP", "NO_TOKEN_OP", "ONLY_IDENTIFIER_OP", "ONLY_TOKEN_OP", "PERMISSIONS_INVALID_DEFAULT", "PERMISSIONS_INVALID_ENTITY", "PERMISSIONS_INVALID_PRINCIPAL", "PERMISSIONS_INVALID_TARGET", "PREVIOUS_SELF", "SUPPLY_INVALID", "TOKEN_RECEIVE_DIFFERS", "SIGNATURE_REQUIRED", "SIGNATURE_PARAMETER_DIFFERS"];
+export declare const FullBlockErrorCodes: ("BLOCK_AMOUNT_BELOW_ZERO" | "BLOCK_CANNOT_FORWARD_TO_SELF" | "BLOCK_CANNOT_SEND_NON_TOKEN" | "BLOCK_CERTIFICATE_SUBJECT_MISMATCH" | "BLOCK_EXACT_TRUE_WHEN_FORWARDING" | "BLOCK_EXTERNAL_INVALID" | "BLOCK_EXTERNAL_MISSING" | "BLOCK_EXTERNAL_TOO_LONG" | "BLOCK_GENERAL_FIELD_INVALID" | "BLOCK_IDENTIFIER_INVALID" | "BLOCK_IDENTIFIER_NEED_DEFAULT_PERMISSIONS" | "BLOCK_INTERMEDIATE_CERTIFICATES_ONLY_ADD" | "BLOCK_INVALID_ACCOUNT_TYPE" | "BLOCK_INVALID_CERTIFICATE_VALUE" | "BLOCK_INVALID_CREATE_IDENTIFIER_ARGS" | "BLOCK_INVALID_IDEMPOTENT_FORMAT" | "BLOCK_INVALID_IDEMPOTENT_LENGTH" | "BLOCK_INVALID_MULTISIG_QUORUM" | "BLOCK_INVALID_MULTISIG_SIGNER_COUNT" | "BLOCK_INVALID_MULTISIG_SIGNER_DEPTH" | "BLOCK_INVALID_MULTISIG_SIGNER_DUPLICATE" | "BLOCK_INVALID_PURPOSE_VALIDATION" | "BLOCK_INVALID_SIGNATURE" | "BLOCK_INVALID_SIGNER" | "BLOCK_INVALID_TYPE" | "BLOCK_INVALID_VERSION" | "BLOCK_NO_ADMIN_ON_TARGET" | "BLOCK_NO_DELEGATE_ADMIN" | "BLOCK_NO_DUPLICATE_CERTIFICATE_OPERATION" | "BLOCK_NO_IDENTIFIER_OP" | "BLOCK_NO_MODIFY_PERMISSION_DUPE" | "BLOCK_NO_MULTIPLE_SET_REP" | "BLOCK_NO_MULTISIG_OP" | "BLOCK_NO_TOKEN_OP" | "BLOCK_ONLY_IDENTIFIER_OP" | "BLOCK_ONLY_TOKEN_OP" | "BLOCK_PERMISSIONS_INVALID_DEFAULT" | "BLOCK_PERMISSIONS_INVALID_ENTITY" | "BLOCK_PERMISSIONS_INVALID_PRINCIPAL" | "BLOCK_PERMISSIONS_INVALID_TARGET" | "BLOCK_PREVIOUS_SELF" | "BLOCK_SUPPLY_INVALID" | "BLOCK_TOKEN_RECEIVE_DIFFERS" | "BLOCK_SIGNATURE_REQUIRED" | "BLOCK_SIGNATURE_PARAMETER_DIFFERS")[];
 export type BlockErrorCode = typeof FullBlockErrorCodes[number];
 export default class KeetaNetBlockError extends KeetaNetErrorBase<BlockErrorCode> {
     static readonly isInstance: (obj: any, strict?: boolean) => obj is KeetaNetBlockError;