@keetanetwork/keetanet-client 0.10.4 → 0.12.0

package/lib/account.d.ts

@@ -16,7 +16,8 @@ export declare enum AccountKeyAlgorithm {
     NETWORK = 2,
     TOKEN = 3,
     STORAGE = 4,
-    ECDSA_SECP256R1 = 6
+    ECDSA_SECP256R1 = 6,// NIST P-256
+    MULTISIG = 7
 }
 /**
  * Type for ASN.1 encoded public keys -- this is equivalent to {@link ValidateASN1.SchemaMap<typeof publicKeyASN1Schema>}
@@ -32,7 +33,55 @@ type publicKeyASN1 = [
         value: Buffer;
     }
 ];
-declare const identifierKeyTypes: readonly [AccountKeyAlgorithm.NETWORK, AccountKeyAlgorithm.TOKEN, AccountKeyAlgorithm.STORAGE];
+/**
+ * Key pair types which we can process
+ */
+type KeyPairTypes = ECDSAKeyPair | ECDSASECP256K1KeyPair | ECDSASECP256R1KeyPair | ED25519KeyPair | IdentifierKeyPair | ExternalKeyPair;
+/**
+ * Generic interface to an account.  An account may be backed by a private key
+ * (in which case it can sign data), a seed+index (which is used to generate
+ * a private key), or a public key (which can only verify blocks).
+ */
+type PublicKeyStringPrefixed<X extends string> = `${AccountPrefix}${X}${string}`;
+export type Secp256K1PublicKeyString = PublicKeyStringPrefixed<'aa' | 'ab' | 'ac' | 'ad'>;
+export type Secp256R1PublicKeyString = PublicKeyStringPrefixed<'ay' | 'az' | 'a2' | 'a3'>;
+export type ED25519PublicKeyString = PublicKeyStringPrefixed<'ae' | 'af' | 'ag' | 'ah'>;
+export type NetworkPublicKeyString = PublicKeyStringPrefixed<'ai' | 'aj' | 'ak' | 'al'>;
+export type TokenPublicKeyString = PublicKeyStringPrefixed<'am' | 'an' | 'ao' | 'ap'>;
+export type StoragePublicKeyString = PublicKeyStringPrefixed<'aq' | 'ar' | 'as' | 'at'>;
+export type MultisigPublicKeyString = PublicKeyStringPrefixed<'a4' | 'a5' | 'a6' | 'a7'>;
+export interface PublicKeyStringMapping {
+    [AccountKeyAlgorithm.ECDSA_SECP256K1]: Secp256K1PublicKeyString;
+    [AccountKeyAlgorithm.ECDSA_SECP256R1]: Secp256R1PublicKeyString;
+    [AccountKeyAlgorithm.ED25519]: ED25519PublicKeyString;
+    [AccountKeyAlgorithm.TOKEN]: TokenPublicKeyString;
+    [AccountKeyAlgorithm.NETWORK]: NetworkPublicKeyString;
+    [AccountKeyAlgorithm.STORAGE]: StoragePublicKeyString;
+    [AccountKeyAlgorithm.MULTISIG]: MultisigPublicKeyString;
+}
+export type IdentifierPublicKeyString = PublicKeyStringMapping[IdentifierKeyAlgorithm];
+export type AccountPublicKeyString = Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
+type AccountKeyAlgorithmHex = {
+    [AccountKeyAlgorithm.ECDSA_SECP256K1]: '0x00';
+    [AccountKeyAlgorithm.ED25519]: '0x01';
+    [AccountKeyAlgorithm.TOKEN]: '0x02';
+    [AccountKeyAlgorithm.NETWORK]: '0x03';
+    [AccountKeyAlgorithm.STORAGE]: '0x04';
+    [AccountKeyAlgorithm.ECDSA_SECP256R1]: '0x06';
+    [AccountKeyAlgorithm.MULTISIG]: '0x07';
+};
+/**
+ * A hex-encoded public key and type, where the type is the first byte
+ * and the public key is the rest of the string.
+ */
+export type PublicKeyAndTypeStringHex<Algo extends typeof AccountKeyAlgorithm[keyof typeof AccountKeyAlgorithm] = AccountKeyAlgorithm> = `${AccountKeyAlgorithmHex[Algo]}${string}`;
+type AccountKeyAlgorithmHexReverse = {
+    [Hex in AccountKeyAlgorithmHex[keyof AccountKeyAlgorithmHex]]: Extract<keyof AccountKeyAlgorithmHex, {
+        [K in keyof AccountKeyAlgorithmHex]: AccountKeyAlgorithmHex[K] extends Hex ? K : never;
+    }[keyof AccountKeyAlgorithmHex]>;
+};
+type AccountKeyAlgorithmHexToType<T extends PublicKeyAndTypeStringHex> = T extends `0x${infer AlgorithmHex1}${infer AlgorithmHex2}${string}` ? `0x${AlgorithmHex1}${AlgorithmHex2}` extends keyof AccountKeyAlgorithmHexReverse ? AccountKeyAlgorithmHexReverse[`0x${AlgorithmHex1}${AlgorithmHex2}`] : never : never;
+declare const identifierKeyTypes: readonly [AccountKeyAlgorithm.NETWORK, AccountKeyAlgorithm.TOKEN, AccountKeyAlgorithm.STORAGE, AccountKeyAlgorithm.MULTISIG];
 export type IdentifierKeyAlgorithm = typeof identifierKeyTypes[any];
 /**
  * Things we can use to construct a key from
@@ -324,31 +373,11 @@ declare class IdentifierKeyPair extends KeyInterface {
     decrypt(..._ignored_parameters: Parameters<decryptFunctionType>): ReturnType<decryptFunctionType>;
 }
 /**
- * Key pair types which we can process
- */
-type KeyPairTypes = ECDSAKeyPair | ECDSASECP256K1KeyPair | ECDSASECP256R1KeyPair | ED25519KeyPair | IdentifierKeyPair | ExternalKeyPair;
-/**
- * Generic interface to an account.  An account may be backed by a private key
- * (in which case it can sign data), a seed+index (which is used to generate
- * a private key), or a public key (which can only verify blocks).
+ * Account class, which is used to represent a key pair or an identifier
+ * account (which have no private key) such as tokens.
+ *
+ * @template T - The type of the key algorithm used for this account.
  */
-type PublicKeyStringPrefixed<X extends string> = `${AccountPrefix}${X}${string}`;
-export type Secp256K1PublicKeyString = PublicKeyStringPrefixed<'aa' | 'ab' | 'ac' | 'ad'>;
-export type Secp256R1PublicKeyString = PublicKeyStringPrefixed<'ay' | 'az' | 'a2' | 'a3'>;
-export type ED25519PublicKeyString = PublicKeyStringPrefixed<'ae' | 'af' | 'ag' | 'ah'>;
-export type NetworkPublicKeyString = PublicKeyStringPrefixed<'ai' | 'aj' | 'ak' | 'al'>;
-export type TokenPublicKeyString = PublicKeyStringPrefixed<'am' | 'an' | 'ao' | 'ap'>;
-export type StoragePublicKeyString = PublicKeyStringPrefixed<'aq' | 'ar' | 'as' | 'at'>;
-export interface PublicKeyStringMapping {
-    [AccountKeyAlgorithm.ECDSA_SECP256K1]: Secp256K1PublicKeyString;
-    [AccountKeyAlgorithm.ECDSA_SECP256R1]: Secp256R1PublicKeyString;
-    [AccountKeyAlgorithm.ED25519]: ED25519PublicKeyString;
-    [AccountKeyAlgorithm.TOKEN]: TokenPublicKeyString;
-    [AccountKeyAlgorithm.NETWORK]: NetworkPublicKeyString;
-    [AccountKeyAlgorithm.STORAGE]: StoragePublicKeyString;
-}
-export type IdentifierPublicKeyString = PublicKeyStringMapping[IdentifierKeyAlgorithm];
-export type AccountPublicKeyString = Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
 export declare class Account<T extends AccountKeyAlgorithm = Exclude<AccountKeyAlgorithm, IdentifierKeyAlgorithm>> {
     #private;
     static AccountKeyAlgorithm: typeof AccountKeyAlgorithm;
@@ -360,6 +389,7 @@ export declare class Account<T extends AccountKeyAlgorithm = Exclude<AccountKeyA
     static fromPublicKeyString(key: TokenPublicKeyString): Account<AccountKeyAlgorithm.TOKEN>;
     static fromPublicKeyString(key: NetworkPublicKeyString): Account<AccountKeyAlgorithm.NETWORK>;
     static fromPublicKeyString(key: StoragePublicKeyString): Account<AccountKeyAlgorithm.STORAGE>;
+    static fromPublicKeyString(key: MultisigPublicKeyString): Account<AccountKeyAlgorithm.MULTISIG>;
     static fromPublicKeyString(key: Secp256K1PublicKeyString): Account<AccountKeyAlgorithm.ECDSA_SECP256K1>;
     static fromPublicKeyString(key: Secp256R1PublicKeyString): Account<AccountKeyAlgorithm.ECDSA_SECP256R1>;
     static fromPublicKeyString(key: ED25519PublicKeyString): Account<AccountKeyAlgorithm.ED25519>;
@@ -402,6 +432,10 @@ export declare class Account<T extends AccountKeyAlgorithm = Exclude<AccountKeyA
      * Construct an account from a storage identifier public key
      */
     static fromStoragePublicKey(key: InputKeyTypes): Account<AccountKeyAlgorithm.STORAGE>;
+    /**
+     * Construct an account from a multisig identifier public key
+     */
+    static fromMultisigPublicKey(key: InputKeyTypes): Account<AccountKeyAlgorithm.MULTISIG>;
     /**
      * Construct an account from an ED25519 public key.
      */
@@ -410,6 +444,8 @@ export declare class Account<T extends AccountKeyAlgorithm = Exclude<AccountKeyA
      * Construct an Account from an KeyType and Public Key buffer
      */
     static fromPublicKeyAndType(keyData: Buffer): GenericAccount;
+    static fromPublicKeyAndType<T extends AccountKeyAlgorithm>(keyData: PublicKeyAndTypeStringHex<T>): Account<T>;
+    static fromPublicKeyAndType(keyData: string): GenericAccount;
     /**
      * Construct a new account from a public key encoded in DER-encoded ASN.1
      */
@@ -453,6 +489,7 @@ export declare class Account<T extends AccountKeyAlgorithm = Exclude<AccountKeyA
     static toAccount(): undefined;
     static toAccount(acct: null): null;
     static toAccount(acct: undefined): undefined;
+    static toAccount<X extends PublicKeyAndTypeStringHex>(acct: X): Account<AccountKeyAlgorithmHexToType<X>>;
     static toAccount<toAlgo extends AccountKeyAlgorithm>(acct: string | Account<toAlgo>): Account<toAlgo>;
     static toAccount<toAlgo extends AccountKeyAlgorithm>(acct: string | Account<toAlgo> | null): Account<toAlgo> | null;
     static toAccount<toAlgo extends AccountKeyAlgorithm>(acct: string | Account<toAlgo> | undefined): Account<toAlgo> | undefined;
@@ -468,7 +505,7 @@ export declare class Account<T extends AccountKeyAlgorithm = Exclude<AccountKeyA
     static toPublicKeyString(acct: string | Account<AccountKeyAlgorithm> | undefined | null): string | undefined | null;
     static comparePublicKeys(acct1: Account<AccountKeyAlgorithm> | string | undefined | null, acct2: Account<AccountKeyAlgorithm> | string | undefined | null): boolean;
     static isInstance: (obj: any, strict?: boolean) => obj is Account<AccountKeyAlgorithm>;
-    static Set: import("./utils/helper").InstanceSetConstructor<Account<AccountKeyAlgorithm>, string>;
+    static Set: import("./utils/helper").InstanceSetConstructor<Account<AccountKeyAlgorithm>, `0x00${string}` | `0x01${string}` | `0x03${string}` | `0x02${string}` | `0x04${string}` | `0x06${string}` | `0x07${string}`>;
     constructor(key: KeyPairTypes | ECDSASECP256K1PrivateKey | ECDSASECP256R1PrivateKey | ED25519PrivateKey | ECDSASECP256K1PublicKey | ECDSASECP256R1PublicKey | ED25519PublicKey | IdentifierKeyPair | IdentifierKey | PublicKeyString | Account<T>, requiredKeyType?: T);
     /**
      * Sign some data and generate a detached signature in SEC format
@@ -507,6 +544,7 @@ export declare class Account<T extends AccountKeyAlgorithm = Exclude<AccountKeyA
      */
     get publicKey(): ECDSASECP256K1PublicKey | ECDSASECP256R1PublicKey | ED25519PublicKey;
     get publicKeyAndType(): Buffer;
+    get publicKeyAndTypeString(): PublicKeyAndTypeStringHex<T>;
     /**
      * Determine if this account has a private key associated with it
      */
@@ -529,15 +567,16 @@ export declare class Account<T extends AccountKeyAlgorithm = Exclude<AccountKeyA
     isStorage(): this is Account<AccountKeyAlgorithm.STORAGE>;
     isNetwork(): this is Account<AccountKeyAlgorithm.NETWORK>;
     isToken(): this is Account<AccountKeyAlgorithm.TOKEN>;
+    isMultisig(): this is Account<AccountKeyAlgorithm.MULTISIG>;
     assertKeyType<KeyType extends AccountKeyAlgorithm>(keyType: KeyType): Account<KeyType>;
     assertAccount(): Account;
     assertIdentifier(): IdentifierAddress;
-    static toJSONSerializablePrefix: string;
-    static toJSONSerializable(value: GenericAccount): Secp256K1PublicKeyString | ED25519PublicKeyString | NetworkPublicKeyString | TokenPublicKeyString | StoragePublicKeyString | Secp256R1PublicKeyString;
+    toJSON(): PublicKeyStringMapping[T];
 }
 export type TokenAddress = Account<AccountKeyAlgorithm.TOKEN>;
 export type StorageAddress = Account<AccountKeyAlgorithm.STORAGE>;
 export type NetworkAddress = Account<AccountKeyAlgorithm.NETWORK>;
+export type MultisigAddress = Account<AccountKeyAlgorithm.MULTISIG>;
 export type IdentifierAddress = Account<IdentifierKeyAlgorithm>;
 export type NonIdentifierAccount = Account<Exclude<AccountKeyAlgorithm, IdentifierKeyAlgorithm>>;
 export type GenericAccount = Account<AccountKeyAlgorithm>;

package/lib/block/index.d.ts

@@ -2,7 +2,7 @@ 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 type { ToJSONSerializable, ToJSONSerializableOptions } from '../utils/conversion';
 import * as Operations from './operations';
 export declare enum AdjustMethod {
     ADD = 0,
@@ -10,18 +10,21 @@ export declare enum AdjustMethod {
     SET = 2
 }
 export declare function assertAdjustMethod(value: any, bigintOkay?: boolean): AdjustMethod;
+type BlockHashString = string & {
+    readonly __blockhash: never;
+};
 /**
  * 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 Set: import("../utils/helper").InstanceSetConstructor<BlockHash, BlockHashString>;
     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;
+    toJSON(): BlockHashString;
+    toString(): BlockHashString;
 }
 /**
  * Network ID
@@ -39,7 +42,7 @@ type BlockSignature = Buffer;
  * Representation of the block
  */
 export interface BlockJSON {
-    version: number;
+    version: 1;
     date: string | Date;
     previous: string | BlockHash;
     network: string | NetworkID;
@@ -53,17 +56,13 @@ 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 BlockJSONOutput = ToJSONSerializable<ReturnType<Block['toJSON']>>;
 export type BlockJSONOutputIncomplete = Partial<BlockJSONOutput>;
 /**
  * Map input to our values
  */
 interface BlockUnsignedCanonical {
-    version: number;
+    version: 1;
     date: Date;
     previous: BlockHash;
     account: GenericAccount;
@@ -95,11 +94,12 @@ export declare class Block implements BlockCanonical {
         TOKEN_ADMIN_SUPPLY: typeof Operations.BlockOperationTOKEN_ADMIN_SUPPLY;
         TOKEN_ADMIN_MODIFY_BALANCE: typeof Operations.BlockOperationTOKEN_ADMIN_MODIFY_BALANCE;
         RECEIVE: typeof Operations.BlockOperationRECEIVE;
+        MANAGE_CERTIFICATE: typeof Operations.BlockOperationMANAGE_CERTIFICATE;
     };
     static NO_PREVIOUS: string;
     static AdjustMethod: typeof AdjustMethod;
     static Builder: typeof BlockBuilder;
-    readonly version: number;
+    readonly version: 1;
     readonly date: Date;
     readonly previous: BlockHash;
     readonly account: GenericAccount;
@@ -116,7 +116,20 @@ export declare class Block implements BlockCanonical {
     static getAccountOpeningHash(account: GenericAccount): BlockHash;
     toBytes(includeSignature?: boolean): ArrayBuffer;
     protected static getASN1ContainerWithoutSignature(input: BlockUnsignedCanonical | BlockCanonical): BlockASN1WithoutSignature;
-    toJSON(): BlockJSONOutput;
+    toJSON(options?: ToJSONSerializableOptions): {
+        $binary?: string;
+        version: 1;
+        date: Date;
+        previous: BlockHash;
+        account: GenericAccount;
+        signer: Account<import("../account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../account").AccountKeyAlgorithm.ED25519 | import("../account").AccountKeyAlgorithm.ECDSA_SECP256R1>;
+        signature: string;
+        network: bigint;
+        subnet: bigint | undefined;
+        operations: Operations.ExportedJSONOperation[];
+        $hash: BlockHash;
+        $opening: boolean;
+    };
     /**
      * Hash of the block minus the signature
      *
@@ -126,13 +139,6 @@ export declare class Block implements BlockCanonical {
      *           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;
@@ -148,13 +154,37 @@ export declare class BlockBuilder implements BlockJSONIncomplete {
         TOKEN_ADMIN_SUPPLY: typeof Operations.BlockOperationTOKEN_ADMIN_SUPPLY;
         TOKEN_ADMIN_MODIFY_BALANCE: typeof Operations.BlockOperationTOKEN_ADMIN_MODIFY_BALANCE;
         RECEIVE: typeof Operations.BlockOperationRECEIVE;
+        MANAGE_CERTIFICATE: typeof Operations.BlockOperationMANAGE_CERTIFICATE;
     };
     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;
+    toJSON(opts?: ToJSONSerializableOptions): {
+        $binary?: string;
+        version: 1;
+        date: Date;
+        previous: BlockHash;
+        account: GenericAccount;
+        signer: Account<import("../account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../account").AccountKeyAlgorithm.ED25519 | import("../account").AccountKeyAlgorithm.ECDSA_SECP256R1>;
+        signature: string;
+        network: bigint;
+        subnet: bigint | undefined;
+        operations: Operations.ExportedJSONOperation[];
+        $hash: BlockHash;
+        $opening: boolean;
+    } | {
+        version: 1 | undefined;
+        date: Date | undefined;
+        previous: BlockHash | undefined;
+        account: GenericAccount | undefined;
+        signer: Account<import("../account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../account").AccountKeyAlgorithm.ED25519 | import("../account").AccountKeyAlgorithm.ECDSA_SECP256R1> | undefined;
+        network: bigint | undefined;
+        subnet: bigint | undefined;
+        operations: Operations.BlockOperations[] | undefined;
+        $opening: boolean | undefined;
+    };
     seal(): Promise<Block>;
     unseal(): BlockJSONIncomplete;
     get sealed(): boolean;
@@ -169,8 +199,8 @@ export declare class BlockBuilder implements BlockJSONIncomplete {
     get $opening(): boolean | undefined;
     set date(date: Date | string | undefined);
     get date(): Date | undefined;
-    set version(version: number | undefined);
-    get version(): number | undefined;
+    set version(version: 1 | undefined);
+    get version(): 1 | undefined;
     set network(network: NetworkID | string | undefined);
     get network(): NetworkID | undefined;
     set subnet(subnet: SubnetID | string | undefined);

package/lib/block/operations.d.ts

@@ -4,8 +4,9 @@ import type { GenericAccount, IdentifierAddress, TokenAddress, TokenPublicKeyStr
 import Account from '../account';
 import type { AcceptedPermissionTypes } from '../permissions';
 import { Permissions } from '../permissions';
-import type { JSONSupported } from '../utils/conversion';
+import type { ToJSONSerializable } from '../utils/conversion';
 import Block, { AdjustMethod } from '.';
+import { Certificate, CertificateBundle, CertificateHash } from '../utils/certificate';
 /**
  * All supported operations
  */
@@ -17,7 +18,8 @@ export declare enum OperationType {
     CREATE_IDENTIFIER = 4,
     TOKEN_ADMIN_SUPPLY = 5,
     TOKEN_ADMIN_MODIFY_BALANCE = 6,
-    RECEIVE = 7
+    RECEIVE = 7,
+    MANAGE_CERTIFICATE = 8
 }
 export type BlockOperationTypes = keyof typeof OperationType;
 /**
@@ -126,6 +128,22 @@ declare const BlockOperationASN1SchemaBase: {
         readonly name: "method";
         readonly schema: typeof ValidateASN1.IsInteger;
     }];
+    readonly MANAGE_CERTIFICATE: [{
+        readonly name: "method";
+        readonly schema: typeof ValidateASN1.IsInteger;
+    }, {
+        readonly name: "certificateOrHash";
+        readonly schema: typeof ValidateASN1.IsOctetString;
+    }, {
+        readonly name: "intermediateCertificates";
+        readonly schema: {
+            readonly optional: {
+                readonly choice: [typeof ValidateASN1.IsNull, {
+                    readonly sequenceOf: typeof ValidateASN1.IsOctetString;
+                }];
+            };
+        };
+    }];
 };
 type ExtractSchemaFromBase<T extends {
     name: string;
@@ -142,15 +160,8 @@ export declare const BlockOperationASN1Schema: { [T in BlockOperationTypes]: {
     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 {
+export interface BlockJSONOperation {
     type: OperationType;
 }
 interface BlockOperationValidateContext {
@@ -165,7 +176,7 @@ declare class BlockOperation {
     protected computeTo(to: string | GenericAccount, isIdentifier?: undefined): GenericAccount;
     protected computeAmount(amount: string | bigint): bigint;
 }
-interface BlockJSONOperationSEND extends BlockJSONOperation {
+export interface BlockJSONOperationSEND extends BlockJSONOperation {
     type: OperationType.SEND;
     to: string | GenericAccount;
     amount: string | bigint;
@@ -185,9 +196,9 @@ declare class BlockOperationSEND extends BlockOperation implements BlockJSONOper
     set amount(amount: string | bigint);
     get amount(): bigint;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): JSONSupported<BlockJSONOperationSEND>;
+    toJSON(): BlockJSONOperationSEND;
 }
-interface BlockJSONOperationRECEIVE extends BlockJSONOperation {
+export interface BlockJSONOperationRECEIVE extends BlockJSONOperation {
     type: OperationType.RECEIVE;
     amount: string | bigint;
     token: TokenPublicKeyString | TokenAddress;
@@ -211,9 +222,9 @@ declare class BlockOperationRECEIVE extends BlockOperation implements BlockJSONO
     set amount(amount: string | bigint);
     get amount(): bigint;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): JSONSupported<BlockJSONOperationSEND>;
+    toJSON(): BlockJSONOperationRECEIVE;
 }
-interface BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE extends BlockJSONOperation {
+export interface BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE extends BlockJSONOperation {
     type: OperationType.TOKEN_ADMIN_MODIFY_BALANCE;
     token: TokenPublicKeyString | TokenAddress;
     amount: string | bigint;
@@ -231,12 +242,12 @@ declare class BlockOperationTOKEN_ADMIN_MODIFY_BALANCE extends BlockOperation im
     set amount(amount: string | bigint);
     get amount(): bigint;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): JSONSupported<BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE>;
+    toJSON(): BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE;
 }
 /**
  * SetRep operation
  */
-interface BlockJSONOperationSET_REP extends BlockJSONOperation {
+export interface BlockJSONOperationSET_REP extends BlockJSONOperation {
     type: OperationType.SET_REP;
     to: string | GenericAccount;
 }
@@ -248,12 +259,12 @@ declare class BlockOperationSET_REP extends BlockOperation implements BlockJSONO
     set to(to: string | Account);
     get to(): Account;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): JSONSupported<BlockJSONOperationSET_REP>;
+    toJSON(): BlockJSONOperationSET_REP;
 }
 /**
  * TokenCreate Operation
  */
-interface BlockJSONOperationCREATE_IDENTIFIER extends BlockJSONOperation {
+export interface BlockJSONOperationCREATE_IDENTIFIER extends BlockJSONOperation {
     type: OperationType.CREATE_IDENTIFIER;
     identifier: IdentifierAddress | string;
 }
@@ -265,12 +276,12 @@ declare class BlockOperationCREATE_IDENTIFIER extends BlockOperation implements
     set identifier(identifier: string | IdentifierAddress);
     get identifier(): IdentifierAddress;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): JSONSupported<BlockJSONOperationCREATE_IDENTIFIER>;
+    toJSON(): BlockJSONOperationCREATE_IDENTIFIER;
 }
 /**
  * SetInfo operation
  */
-interface BlockJSONOperationSET_INFO extends BlockJSONOperation {
+export interface BlockJSONOperationSET_INFO extends BlockJSONOperation {
     type: OperationType.SET_INFO;
     name: string;
     description: string;
@@ -291,12 +302,12 @@ declare class BlockOperationSET_INFO extends BlockOperation implements BlockJSON
     set defaultPermission(newPerms: Permissions | undefined);
     get defaultPermission(): Permissions | undefined;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): JSONSupported<BlockJSONOperationSET_INFO>;
+    toJSON(): BlockJSONOperationSET_INFO;
 }
 /**
  * Set Permissions Operation
  */
-interface BlockJSONOperationMODIFY_PERMISSIONS extends BlockJSONOperation {
+export interface BlockJSONOperationMODIFY_PERMISSIONS extends BlockJSONOperation {
     type: OperationType.MODIFY_PERMISSIONS;
     principal: string | GenericAccount;
     method: AdjustMethod;
@@ -317,15 +328,15 @@ declare class BlockOperationMODIFY_PERMISSIONS extends BlockOperation implements
     set method(method: AdjustMethod);
     get method(): AdjustMethod;
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): JSONSupported<BlockOperationMODIFY_PERMISSIONS>;
+    toJSON(): BlockJSONOperationMODIFY_PERMISSIONS;
 }
 /**
  * Token Supply operation
  */
-interface BlockJSONOperationTOKEN_ADMIN_SUPPLY extends BlockJSONOperation {
+export interface BlockJSONOperationTOKEN_ADMIN_SUPPLY extends BlockJSONOperation {
     type: OperationType.TOKEN_ADMIN_SUPPLY;
     amount: bigint | string;
-    method: Omit<AdjustMethod, AdjustMethod.SET>;
+    method: AdjustMethod.ADD | AdjustMethod.SUBTRACT;
 }
 declare class BlockOperationTOKEN_ADMIN_SUPPLY extends BlockOperation implements BlockJSONOperationTOKEN_ADMIN_SUPPLY {
     #private;
@@ -334,10 +345,36 @@ declare class BlockOperationTOKEN_ADMIN_SUPPLY extends BlockOperation implements
     constructor(input: BlockJSONOperationTOKEN_ADMIN_SUPPLY);
     set amount(amount: string | bigint);
     get amount(): bigint;
-    set method(shouldAdd: AdjustMethod);
-    get method(): AdjustMethod;
+    set method(shouldAdd: BlockJSONOperationTOKEN_ADMIN_SUPPLY['method']);
+    get method(): BlockJSONOperationTOKEN_ADMIN_SUPPLY['method'];
     validate(context: BlockOperationValidateContext): void;
-    toJSON(): JSONSupported<BlockJSONOperationTOKEN_ADMIN_SUPPLY>;
+    toJSON(): 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;
+    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;
+    constructor(input: BlockJSONOperationMANAGE_CERTIFICATE);
+    get intermediateCertificates(): CertificateBundle | null | undefined;
+    set intermediateCertificates(bundle: ConstructorParameters<typeof CertificateBundle>[0] | null | undefined);
+    get certificateOrHash(): Certificate | CertificateHash;
+    set certificateOrHash(certificate: string | Certificate | CertificateHash | Buffer);
+    set method(shouldAdd: Exclude<AdjustMethod, AdjustMethod.SET>);
+    get method(): Exclude<AdjustMethod, AdjustMethod.SET>;
+    validate(context: BlockOperationValidateContext): void;
+    toJSON(): BlockJSONOperationMANAGE_CERTIFICATESerializable;
 }
 /**
  * Aggregate set of operations
@@ -351,18 +388,22 @@ export declare const Operation: {
     TOKEN_ADMIN_SUPPLY: typeof BlockOperationTOKEN_ADMIN_SUPPLY;
     TOKEN_ADMIN_MODIFY_BALANCE: typeof BlockOperationTOKEN_ADMIN_MODIFY_BALANCE;
     RECEIVE: typeof BlockOperationRECEIVE;
+    MANAGE_CERTIFICATE: typeof BlockOperationMANAGE_CERTIFICATE;
 };
-export type { BlockOperationSEND, BlockOperationSET_REP, BlockOperationSET_INFO, BlockOperationMODIFY_PERMISSIONS, BlockOperationCREATE_IDENTIFIER, BlockOperationTOKEN_ADMIN_SUPPLY, BlockOperationTOKEN_ADMIN_MODIFY_BALANCE, BlockOperationRECEIVE };
+export type { BlockOperationSEND, BlockOperationSET_REP, BlockOperationSET_INFO, BlockOperationMODIFY_PERMISSIONS, BlockOperationCREATE_IDENTIFIER, BlockOperationTOKEN_ADMIN_SUPPLY, BlockOperationTOKEN_ADMIN_MODIFY_BALANCE, BlockOperationRECEIVE, BlockOperationMANAGE_CERTIFICATE };
 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 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[]): JSONSupported<BlockJSONOperations>[];
-export declare function ImportOperationsJSON(operations: BlockOperations[] | BlockJSONOperations[]): BlockOperations[];
+export declare function ExportOperationsJSON(operations: BlockOperations[]): ExportedJSONOperation[];
+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;
@@ -371,6 +412,10 @@ export declare function ExportBlockOperations(operations: BlockOperations[]): ((
     contains: [Buffer, bigint, bigint];
     value: OperationType.TOKEN_ADMIN_MODIFY_BALANCE;
     kind: "explicit";
+}) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+    contains: [bigint, Buffer, Buffer[] | null | undefined];
+    value: OperationType.MANAGE_CERTIFICATE;
+    kind: "explicit";
 }) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
     contains: [Buffer, bigint, Buffer, (Omit<import("../utils/asn1").ASN1String, "kind"> & {
         kind: "utf8";

package/lib/error/block.d.ts

@@ -1,6 +1,6 @@
 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"];
+declare const BlockErrorCodes: readonly ["INVALID_TYPE", "INVALID_VERSION", "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", "NO_MULTISIG_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", "CERTIFICATE_SUBJECT_MISMATCH", "NO_DUPLICATE_CERTIFICATE_OPERATION", "INTERMEDIATE_CERTIFICATES_ONLY_ADD", "INVALID_CERTIFICATE_VALUE", "EXTERNAL_TOO_LONG", "EXTERNAL_INVALID", "EXTERNAL_MISSING", "SUPPLY_INVALID"];
 export type BlockErrorCode = `${typeof BlockErrorType}_${typeof BlockErrorCodes[number]}`;
 export default class KeetaNetBlockError extends KeetaNetError {
     static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetBlockError;

package/lib/error/certificate.d.ts

@@ -0,0 +1,9 @@
+import { KeetaNetError } from '.';
+declare const CertificateErrorType: "CERTIFICATE";
+declare const BlockErrorCodes: readonly ["DUPLICATE_INCLUDED", "ORPHAN_FOUND", "CYCLE_FOUND", "SECONDARY_GRAPH"];
+export type CertificateErrorCode = `${typeof CertificateErrorType}_${typeof BlockErrorCodes[number]}`;
+export default class KeetaNetCertificateError extends KeetaNetError {
+    static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetCertificateError;
+    constructor(code: CertificateErrorCode, message: string);
+}
+export {};

package/lib/error/client.d.ts

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

package/lib/error/index.d.ts

@@ -5,7 +5,8 @@ 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;
+import type { CertificateErrorCode } from './certificate';
+export type ErrorCode = BlockErrorCode | LedgerErrorCode | AccountErrorCode | ClientErrorCode | VoteErrorCode | PermissionsErrorCode | KVErrorCode | CertificateErrorCode;
 export declare function ExpectErrorCode(code: ErrorCode, test: () => any): Promise<void>;
 interface ValidationOptions {
     type: string;

package/lib/error/kv.d.ts

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