@keetanetwork/keetanet-client 0.10.5 → 0.12.2

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;

package/lib/error/vote.d.ts

@@ -1,6 +1,6 @@
 import { KeetaNetError } from '.';
 declare const VoteErrorType: "VOTE";
-declare const VoteErrorCodes: readonly ["SERIAL_MISMATCH", "INVALID_VERSION", "INVALID_CONSTRUCTION", "INVALID_CONSTRUCTION_JSON", "SIGNATURE_INVALID", "EXPIRED", "INVALID_VALIDITY", "MOMENT_BEFORE_VALIDITY_FROM", "STAPLE_INVALID_CONSTRUCTION", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_COUNT", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_MISSING", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_ORDER", "STAPLE_DUPLICATE_VOTE_ISSUER", "STAPLE_PERMANENCE_MISMATCH", "BUILDER_INVALID_CONSTRUCTION", "BUILDER_INVALID_BLOCK_TYPE", "BUILDER_INVALID_SERIAL", "BUILDER_INVALID_VALID_TO_FROM", "MALFORMED_WRAPPER", "MALFORMED_VOTE_WRAPPER", "MALFORMED_VOTE_CONTENT", "MALFORMED_VOTE_CONTENT_EXTRA_DATA", "MALFORMED_VOTE_VERSION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_SIGNATURE_INFORMATION", "MALFORMED_VOTE_ISSUER_INFORMATION", "MALFORMED_VOTE_SUBJECT_INFORMATION", "MALFORMED_VOTE_VALIDITY_INFORMATION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_EXTENSIONS", "MALFORMED_VOTE_EXTENSIONS_VALUE", "MALFORMED_VOTE_EXTENSIONS_VALUE_OID", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE", "MALFORMED_VOTE_EXTENSIONS_VALUE_HASH_DATA", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER", "MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE", "MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME", "MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION", "MALFORMED_VOTE_SIGNATURE_VALUE", "MALFORMED_VOTE_NO_BLOCKS_FOUND", "MALFORMED_STAPLE", "MALFORMED_STAPLE_BLOCKS", "MALFORMED_STAPLE_BLOCKS_AT_LEAST_ONE", "MALFORMED_STAPLE_VOTES", "MALFORMED_STAPLE_VOTES_AT_LEAST_ONE", "MALFORMED_FIND_RDN_INVALID_TYPE", "MALFORMED_FIND_RDN_MUST_HAVE_ONE", "MALFORMED_FIND_RDN_PART_WELL_FORMED", "MALFORMED_FIND_RDN_MUST_BE_SET", "MALFORMED_FIND_RDN_TYPE_MUST_BE_OID", "MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT", "MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE", "MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC", "MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID", "MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE", "MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE", "MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE"];
+declare const VoteErrorCodes: readonly ["SERIAL_MISMATCH", "INVALID_VERSION", "INVALID_CONSTRUCTION", "INVALID_CONSTRUCTION_JSON", "SIGNATURE_INVALID", "EXPIRED", "INVALID_VALIDITY", "MOMENT_BEFORE_VALIDITY_FROM", "STAPLE_INVALID_CONSTRUCTION", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_COUNT", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_MISSING", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_ORDER", "STAPLE_DUPLICATE_VOTE_ISSUER", "STAPLE_PERMANENCE_MISMATCH", "BUILDER_INVALID_CONSTRUCTION", "BUILDER_INVALID_BLOCK_TYPE", "BUILDER_INVALID_SERIAL", "BUILDER_INVALID_VALID_TO_FROM", "MALFORMED_WRAPPER", "MALFORMED_VOTE_WRAPPER", "MALFORMED_VOTE_CONTENT", "MALFORMED_VOTE_CONTENT_EXTRA_DATA", "MALFORMED_VOTE_VERSION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_SIGNATURE_INFORMATION", "MALFORMED_VOTE_ISSUER_INFORMATION", "MALFORMED_VOTE_SUBJECT_INFORMATION", "MALFORMED_VOTE_VALIDITY_INFORMATION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_EXTENSIONS", "MALFORMED_VOTE_EXTENSIONS_DATA", "MALFORMED_VOTE_EXTENSIONS_VALUE", "MALFORMED_VOTE_EXTENSIONS_VALUE_OID", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER", "MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE", "MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME", "MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION", "MALFORMED_VOTE_SIGNATURE_VALUE", "MALFORMED_VOTE_NO_BLOCKS_FOUND", "MALFORMED_STAPLE", "MALFORMED_STAPLE_BLOCKS", "MALFORMED_STAPLE_BLOCKS_AT_LEAST_ONE", "MALFORMED_STAPLE_VOTES", "MALFORMED_STAPLE_VOTES_AT_LEAST_ONE", "MALFORMED_FIND_RDN_INVALID_TYPE", "MALFORMED_FIND_RDN_MUST_HAVE_ONE", "MALFORMED_FIND_RDN_PART_WELL_FORMED", "MALFORMED_FIND_RDN_MUST_BE_SET", "MALFORMED_FIND_RDN_TYPE_MUST_BE_OID", "MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT", "MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE", "MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC", "MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID", "MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE", "MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE", "MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE", "MALFORMED_FEES_AMOUNT", "MALFORMED_FEES_FROM_VOTE_INVALID_INPUT", "MALFORMED_FEES_IN_PERMANENT_VOTE", "MALFORMED_FEES_PAY_TO_INVALID", "MALFORMED_FEES_TOKEN_NOT_TOKEN"];
 export type VoteErrorCode = `${typeof VoteErrorType}_${typeof VoteErrorCodes[number]}`;
 export default class KeetaNetVoteError extends KeetaNetError {
     static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetVoteError;

package/lib/kv/index.d.ts

@@ -1,21 +1,28 @@
 import type { BufferStorage } from '../utils/buffer';
 import type { JSONSerializable } from '../utils/conversion';
-export interface KVSetOptionsType {
+import type { Node } from '../node';
+type NodeLike = Pick<Node, 'timing'>;
+export interface KVGenericOptionsType {
+    node?: NodeLike;
+}
+export interface KVSetOptionsType extends KVGenericOptionsType {
     exclusiveCreate?: boolean;
     ttl?: number;
 }
 export interface KVStorageProviderAPI {
     set(arena: string, key: string, value: JSONSerializable | undefined, options?: KVSetOptionsType): Promise<void>;
-    get(arena: string | null, key: string): Promise<JSONSerializable | undefined>;
-    getAll(arena: string): Promise<{
+    get(arena: string | null, key: string, options?: KVGenericOptionsType): Promise<JSONSerializable | undefined>;
+    getAll(arena: string, options?: KVGenericOptionsType): Promise<{
         [key: string]: JSONSerializable;
     }>;
-    list(arena: string): Promise<string[]>;
-    incr(arena: string, key: string, change: number): Promise<bigint>;
-    xor(arena: null, key: string, change: BufferStorage): Promise<void>;
-    destroy?: () => Promise<void>;
+    list(arena: string, options?: KVGenericOptionsType): Promise<string[]>;
+    incr(arena: string, key: string, change: number, options?: KVGenericOptionsType): Promise<bigint>;
+    xor(arena: null, key: string, change: BufferStorage, options?: KVGenericOptionsType): Promise<void>;
+    destroy?: (options?: KVGenericOptionsType) => Promise<void>;
 }
 export type KVStorageProvider = KVStorageProviderAPI;
 export declare class KVStorageProviderBase {
-    xor(_ignored_arena: null, key: string, _ignored_change: BufferStorage): Promise<void>;
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    xor(_ignored_arena: null, key: string, _ignored_change: BufferStorage, _ignored_options?: KVGenericOptionsType): Promise<void>;
 }
+export {};

package/lib/kv/kv_redis.d.ts

@@ -1,18 +1,28 @@
-import type { KVStorageProviderAPI, KVSetOptionsType } from './';
+import type { KVStorageProviderAPI, KVSetOptionsType, KVGenericOptionsType } from './';
 import { KVStorageProviderBase } from './';
 import type { JSONSerializable } from '../utils/conversion';
 import type { BufferStorage } from '../utils/buffer';
+export type KVStorageProviderRedisConfig = {
+    host: string;
+    password: string;
+    port?: number;
+    log?: typeof KVStorageProviderRedis['defaultLogger'];
+    node?: KVGenericOptionsType['node'];
+};
 export declare class KVStorageProviderRedis extends KVStorageProviderBase implements KVStorageProviderAPI {
     #private;
-    constructor(host: string, password: string, port?: number);
-    destroy(): Promise<void>;
+    static defaultLogger: Pick<typeof console, 'debug' | 'error'>;
+    log: Pick<Console, "debug" | "error">;
+    constructor(config: KVStorageProviderRedisConfig);
+    private node;
+    destroy(options?: KVGenericOptionsType): Promise<void>;
     set(arena: string, key: string, value: JSONSerializable | undefined, opt?: KVSetOptionsType): Promise<void>;
-    get(arena: string | null, key: string): Promise<JSONSerializable | undefined>;
-    getAll(arena: string): Promise<{
+    get(arena: string | null, key: string, options?: KVGenericOptionsType): Promise<JSONSerializable | undefined>;
+    getAll(arena: string, options?: KVGenericOptionsType): Promise<{
         [key: string]: JSONSerializable;
     }>;
-    list(arena: string): Promise<string[]>;
-    incr(arena: string, key: string, change: number): Promise<bigint>;
-    xor(arena: null, key: string, change: BufferStorage): Promise<void>;
+    list(arena: string, options?: KVGenericOptionsType): Promise<string[]>;
+    incr(arena: string, key: string, change: number, options?: KVGenericOptionsType): Promise<bigint>;
+    xor(arena: null, key: string, change: BufferStorage, options?: KVGenericOptionsType): Promise<void>;
 }
 export default KVStorageProviderRedis;

package/lib/ledger/common.d.ts

@@ -53,13 +53,14 @@ interface ComputeLedgerEffectOptions<T extends boolean, P extends boolean, W ext
     getFinalNumericValues?: T;
     computePermissions?: P;
     computeWeights?: W;
-    checkNegative?: boolean;
+    checkRangeConstraints?: boolean;
     baseToken: TokenAddress;
 }
+export declare function validateSupply(amount: bigint, network: bigint): void;
 /**
  * Compute effects on the ledger from block effects
  */
-export declare function computeLedgerEffect<T extends boolean, P extends boolean, W extends boolean>(options: ComputeLedgerEffectOptions<T, P, W>, effects: ComputedEffectOfBlocksByAccount, storageProvider: computeLedgerEffectStorageProvider, transaction?: any): Promise<BalanceSupplyChangeResp<T, P, W>>;
+export declare function computeLedgerEffect<T extends boolean, P extends boolean, W extends boolean>(options: ComputeLedgerEffectOptions<T, P, W>, effects: ComputedEffectOfBlocksByAccount, storageProvider: computeLedgerEffectStorageProvider, network: bigint, transaction?: any): Promise<BalanceSupplyChangeResp<T, P, W>>;
 /**
  * A partial LedgerStorageAPI which just has the methods for "addTimeStatistics"
  */
@@ -94,12 +95,19 @@ export declare abstract class LedgerStorageBase {
     protected config: LedgerConfig | null;
     constructor();
     protected abstract adjustDefer(transaction: any, input: VoteStaple): Promise<void>;
-    abstract getBlockHeight(transaction: any, blockHash: BlockHash, account: GenericAccount): Promise<{
-        blockHeight: string | null;
-    } | null>;
+    abstract getBlockHeight(transaction: any, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
+    getBlockHeights(transaction: any, toFetch: {
+        blockHash: BlockHash;
+        account: GenericAccount;
+    }[]): Promise<{
+        [blockHash: string]: bigint | null;
+    }>;
     abstract getHeadBlocks(transaction: any, accounts: GenericAccount[], from: LedgerSelector): Promise<{
         [account: string]: Block | null;
     }>;
+    getHeadBlockHashes(transaction: any, accounts: InstanceType<typeof Account.Set>): Promise<{
+        [account: string]: BlockHash | null;
+    }>;
     abstract getVotesFromMultiplePrevious(transaction: any, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
         [hash: string]: Vote[] | null;
     }>;

package/lib/ledger/db_dynamodb.d.ts

@@ -3,11 +3,13 @@ import { Block, BlockHash } from '../block';
 import type { VoteBlockHash, VoteBlockHashMap } from '../vote';
 import type { GenericAccount, IdentifierAddress, TokenAddress } from '../account';
 import Account from '../account';
-import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions } from '../ledger';
-import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics } from './types';
+import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBase } from '../ledger';
+import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
 import { LedgerStorageBase } from './common';
 import type { ComputedEffectOfBlocks } from './effects';
-declare const dynamoDBTableNames: readonly ["votes", "voteUIDs", "permissions", "accountInfo", "accountOwners", "blocks", "balances", "weight", "heapBlocks", "heapStorage", "chain", "delegation", "serial", "kv"];
+import type Node from '../node';
+import type { CertificateHash } from '../utils/certificate';
+declare const dynamoDBTableNames: readonly ["votes", "voteUIDs", "permissions", "accountInfo", "accountOwners", "accountCertificates", "blocks", "balances", "weight", "heapBlocks", "heapStorage", "chain", "delegation", "serial", "kv"];
 declare const optionalDynamoDbTables: readonly ["kv"];
 type TableName = typeof dynamoDBTableNames[number];
 type OptionalTableName = typeof optionalDynamoDbTables[number];
@@ -20,22 +22,23 @@ export interface DynamoDBConfig {
     transactionSize?: number;
     batchUpdateSize?: number;
 }
-declare class DynamoDBTransaction {
+declare class DynamoDBTransaction implements LedgerStorageTransactionBase {
     #private;
+    readonly node: Node | undefined;
     readonly moment: Date;
-    constructor(config: DynamoDBConfig, ledger: Ledger, log: LedgerConfig['log'], dbDynamoDB: DBDynamoDB);
+    readonly identifier: string;
+    readonly readOnly: boolean;
+    constructor(config: DynamoDBConfig, ledger: Ledger, log: LedgerConfig['log'], dbDynamoDB: DBDynamoDB, transactionBase: LedgerStorageTransactionBase);
     commit(): Promise<void>;
     abort(): Promise<void>;
-    delegatedWeight(rep?: Account): Promise<bigint>;
+    delegatedWeight(rep?: Account | InstanceType<typeof Account.Set>): Promise<bigint>;
     getBalance(account: GenericAccount, token: TokenAddress): Promise<bigint>;
     getAllBalances(account: GenericAccount): Promise<GetAllBalancesResponse>;
     adjustDefer(input: VoteStaple): Promise<void>;
-    adjust(input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean): Promise<BlockHash[]>;
+    adjust(input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean, completedStaples?: Set<string>): Promise<VoteStaple[]>;
     addPendingVote(blocksAndVotes: VoteStaple): Promise<void>;
     getBlock(block: BlockHash, from: LedgerSelector): Promise<Block | null>;
-    getBlockHeight(blockHash: BlockHash, account: GenericAccount): Promise<{
-        blockHeight: string | null;
-    } | null>;
+    getBlockHeight(blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
     getVotes(block: BlockHash, from: LedgerSelector, issuer?: Account, transactionAlreadyVerifiedActiveByCaller?: boolean): Promise<Vote[] | null>;
     getVoteStaple(stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
     getHistory(account: GenericAccount, start: VoteBlockHash | null, limit: number): Promise<VoteBlockHash[]>;
@@ -57,29 +60,30 @@ declare class DynamoDBTransaction {
     listACLsByEntity(entity: GenericAccount): Promise<ACLRow[]>;
     listACLsByPrincipal(principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
     getVotesAfter(moment: Date, startKey?: string, options?: GetVotesAfterOptions): Promise<PaginatedVotes>;
+    getAccountCertificates(account: GenericAccount): Promise<CertificateWithIntermediates[]>;
+    getAccountCertificateByHash(account: GenericAccount, hash: CertificateHash): Promise<CertificateWithIntermediates | null>;
     gcBatch(): Promise<boolean>;
 }
 export declare class DBDynamoDB extends LedgerStorageBase implements LedgerStorageAPI {
     #private;
+    ledgerConfig: LedgerConfig | null;
     static Testing: {
         deleteTables: (config: DynamoDBConfig) => Promise<void>;
         createTables: (config: DynamoDBConfig) => Promise<void>;
     };
     init(config: LedgerConfig, ledger: Ledger): void;
-    beginTransaction(): Promise<DynamoDBTransaction>;
+    beginTransaction(transactionBase: LedgerStorageTransactionBase): Promise<DynamoDBTransaction>;
     commitTransaction(transaction: DynamoDBTransaction): Promise<void>;
     abortTransaction(transaction: DynamoDBTransaction): Promise<void>;
     evaluateError(error: any): Promise<any>;
-    delegatedWeight(transaction: DynamoDBTransaction, rep?: Account): Promise<bigint>;
+    delegatedWeight(transaction: DynamoDBTransaction, rep?: Account | InstanceType<typeof Account.Set>): Promise<bigint>;
     getBalance(transaction: DynamoDBTransaction, account: GenericAccount, token: TokenAddress): Promise<bigint>;
     getAllBalances(transaction: DynamoDBTransaction, account: GenericAccount): Promise<GetAllBalancesResponse>;
     protected adjustDefer(transaction: DynamoDBTransaction, input: VoteStaple): Promise<void>;
-    adjust(transaction: DynamoDBTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean): Promise<BlockHash[]>;
+    adjust(transaction: DynamoDBTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean): Promise<VoteStaple[]>;
     addPendingVote(transaction: DynamoDBTransaction, blocksAndVote: VoteStaple): Promise<void>;
     getBlock(transaction: DynamoDBTransaction, block: BlockHash, from: LedgerSelector): Promise<Block | null>;
-    getBlockHeight(transaction: DynamoDBTransaction, blockHash: BlockHash, account: GenericAccount): Promise<{
-        blockHeight: string | null;
-    } | null>;
+    getBlockHeight(transaction: DynamoDBTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
     getVotes(transaction: DynamoDBTransaction, block: BlockHash, from: LedgerSelector): Promise<Vote[] | null>;
     getVoteStaples(transaction: DynamoDBTransaction, stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
     getHistory(transaction: DynamoDBTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
@@ -96,6 +100,8 @@ export declare class DBDynamoDB extends LedgerStorageBase implements LedgerStora
     listACLsByPrincipal(transaction: DynamoDBTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
     listACLsByEntity(transaction: DynamoDBTransaction, entity: GenericAccount): Promise<ACLRow[]>;
     getVotesAfter(transaction: DynamoDBTransaction, moment: Date, startKey?: string): Promise<PaginatedVotes>;
+    getAccountCertificates(transaction: DynamoDBTransaction, account: GenericAccount): Promise<CertificateWithIntermediates[]>;
+    getAccountCertificateByHash(transaction: DynamoDBTransaction, account: GenericAccount, hash: CertificateHash): Promise<CertificateWithIntermediates | null>;
     getNextSerialNumber(): Promise<bigint>;
     gcBatch(transaction: DynamoDBTransaction): Promise<boolean>;
     stats(): Promise<LedgerStatistics>;

package/lib/ledger/db_postgres.d.ts

@@ -3,16 +3,16 @@ import { Block, BlockHash } from '../block';
 import type { VoteBlockHash, VoteBlockHashMap } from '../vote';
 import type { GenericAccount, IdentifierAddress, TokenAddress } from '../account';
 import Account, { AccountKeyAlgorithm } from '../account';
-import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions } from '../ledger';
-import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics } from './types';
+import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBase } from '../ledger';
+import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
 import { LedgerStorageBase } from './common';
 import type { PoolClient as PostgresPoolClient } from 'pg';
 import { Pool as PostgresPool } from 'pg';
 import type { ComputedEffectOfBlocks } from './effects';
 import LedgerRequestCache from './cache';
-interface PostgresTransaction {
+import type { CertificateHash } from '../utils/certificate';
+interface PostgresTransaction extends LedgerStorageTransactionBase {
     client: PostgresPoolClient;
-    moment: Date;
     cache: LedgerRequestCache;
 }
 interface PostgresSelectOptions {
@@ -24,12 +24,12 @@ export declare class DBPostgres extends LedgerStorageBase implements LedgerStora
     constructor();
     init(config: LedgerConfig, ledger: Ledger): void;
     destroy(): Promise<void>;
-    beginTransaction(): Promise<PostgresTransaction>;
+    beginTransaction(transactionBase: LedgerStorageTransactionBase): Promise<PostgresTransaction>;
     commitTransaction(transaction: PostgresTransaction): Promise<void>;
     abortTransaction(transaction: PostgresTransaction): Promise<void>;
     cache(transaction: PostgresTransaction): LedgerRequestCache;
     evaluateError(error: any): Promise<any>;
-    delegatedWeight(transaction: PostgresTransaction, rep?: Account, options?: PostgresSelectOptions): Promise<bigint>;
+    delegatedWeight(transaction: PostgresTransaction, rep?: Account | InstanceType<typeof Account.Set>, options?: PostgresSelectOptions): Promise<bigint>;
     getBalance(transaction: PostgresTransaction, account: GenericAccount, token: TokenAddress, options?: PostgresSelectOptions): Promise<bigint>;
     getAllBalances(transaction: PostgresTransaction, account: GenericAccount): Promise<GetAllBalancesResponse>;
     addPendingVote(transaction: PostgresTransaction, votesAndBlocks: VoteStaple): Promise<void>;
@@ -42,11 +42,9 @@ export declare class DBPostgres extends LedgerStorageBase implements LedgerStora
     listACLsByEntity(transaction: PostgresTransaction, entity: GenericAccount): Promise<ACLRow[]>;
     listACLsByPrincipal(transaction: PostgresTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
     getAccountInfo(transaction: PostgresTransaction, account: GenericAccount | string): Promise<AccountInfo>;
-    adjust(transaction: PostgresTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean): Promise<BlockHash[]>;
+    adjust(transaction: PostgresTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean, completedStaples?: Set<string>): Promise<VoteStaple[]>;
     getBlock(transaction: PostgresTransaction, block: BlockHash, from: LedgerSelector): Promise<Block | null>;
-    getBlockHeight(transaction: PostgresTransaction, blockHash: BlockHash, account: GenericAccount): Promise<{
-        blockHeight: string | null;
-    } | null>;
+    getBlockHeight(transaction: PostgresTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
     getVotes(transaction: PostgresTransaction, block: BlockHash, from: LedgerSelector, issuer?: GenericAccount): Promise<Vote[] | null>;
     getVoteStaples(transaction: PostgresTransaction, stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
     getHistory(transaction: PostgresTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
@@ -59,6 +57,8 @@ export declare class DBPostgres extends LedgerStorageBase implements LedgerStora
     }>;
     getVoteStaplesFromBlockHash(transaction: PostgresTransaction, blocks: BlockHash[], onLedger: LedgerSelector): Promise<VoteStaple[]>;
     getVotesAfter(transaction: PostgresTransaction, moment: Date, startKey?: string, options?: GetVotesAfterOptions): Promise<PaginatedVotes>;
+    getAccountCertificates(transaction: PostgresTransaction, account: GenericAccount): Promise<CertificateWithIntermediates[]>;
+    getAccountCertificateByHash(transaction: PostgresTransaction, account: GenericAccount, hash: CertificateHash): Promise<CertificateWithIntermediates | null>;
     protected gcBatch(transaction: PostgresTransaction): Promise<boolean>;
     getNextSerialNumber(): Promise<bigint>;
     stats(): Promise<LedgerStatistics>;