@keetanetwork/keetanet-client 0.10.5 → 0.12.2

package/lib/ledger/index.d.ts

@@ -6,8 +6,9 @@ import Account from '../account';
 import type Node from '../node';
 import type { BloomFilter } from '../utils/bloom';
 import type { ComputedEffectOfBlocks } from './effects';
-import type { ACLRow, AccountInfo, GetAllBalancesResponse, LedgerStatistics } from './types';
+import type { ACLRow, AccountInfo, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
 import LedgerRequestCache from './cache';
+import type { CertificateHash } from '../utils/certificate';
 /**
  * Kind of ledger
  */
@@ -47,6 +48,16 @@ export interface LedgerConfig {
      * no-voting: Normal mode (read-write enabled), but no voting
      */
     ledgerWriteMode?: 'bootstrap-only' | 'read-only' | 'read-write' | 'no-voting';
+    /**
+     * Timeout for storage operations
+     */
+    transactionRetries?: ({
+        timeout?: number;
+        maxRetries?: never;
+    } | {
+        timeout?: never;
+        maxRetries?: number;
+    });
     /**
      * Logging method
      */
@@ -84,6 +95,15 @@ export type GetVotesAfterOptions = {
      */
     timeout?: number;
 };
+/**
+ * Each transaction can contain the node object making the request to access things like timing information
+ */
+export interface LedgerStorageTransactionBase {
+    node?: Node;
+    moment: Date;
+    identifier: string;
+    readOnly: boolean;
+}
 /**
  * Each Ledger Storage backend must implement this interface
  */
@@ -99,7 +119,7 @@ export interface LedgerStorageAPI {
     /**
      * Begin a transaction
      */
-    beginTransaction: (identifier: string, readOnly?: boolean) => Promise<any>;
+    beginTransaction: (transactionBase: LedgerStorageTransactionBase) => Promise<LedgerStorageTransactionBase>;
     /**
      * Commit an active transaction
      */
@@ -115,9 +135,9 @@ export interface LedgerStorageAPI {
     evaluateError: (error: any) => Promise<any>;
     /**
      * Get the amount of delegated weight for an account,
-     * if "rep" is not supplied get the total delegated weight
+     * if "rep" is not supplied get the total delegated weight, if "rep" is of type Account.Set, return the sum of the weights for the provided account(s)
      */
-    delegatedWeight: (transaction: any, rep?: Account) => Promise<bigint>;
+    delegatedWeight: (transaction: any, rep?: Account | InstanceType<typeof Account.Set>) => Promise<bigint>;
     /**
      * Get the balance of an account or token
      */
@@ -147,7 +167,7 @@ export interface LedgerStorageAPI {
     /**
      * Adjust the ledger by performing a set of changes based on some blocks and votes
      */
-    adjust: (transaction: any, input: VoteStaple, changes: ComputedEffectOfBlocks) => Promise<BlockHash[]>;
+    adjust: (transaction: any, input: VoteStaple, changes: ComputedEffectOfBlocks) => Promise<VoteStaple[]>;
     /**
      * Add a transitional vote (to the side-ledger)
      */
@@ -159,9 +179,16 @@ export interface LedgerStorageAPI {
     /**
      * Get the block height from a given block hash
      */
-    getBlockHeight: (transaction: any, blockHash: BlockHash, account: GenericAccount) => Promise<{
-        blockHeight: string | null;
-    } | null>;
+    getBlockHeight: (transaction: any, blockHash: BlockHash, account: GenericAccount) => Promise<bigint | null>;
+    /**
+     * Get multiple block heights for a given set of block hashes and chains.
+     */
+    getBlockHeights: (transaction: any, toFetch: {
+        blockHash: BlockHash;
+        account: GenericAccount;
+    }[]) => Promise<{
+        [blockHash: string]: bigint | null;
+    }>;
     /**
      * Get the votes for a given block
      */
@@ -190,6 +217,12 @@ export interface LedgerStorageAPI {
     getHeadBlocks: (transaction: any, accounts: GenericAccount[], from: LedgerSelector) => Promise<{
         [account: string]: Block | null;
     }>;
+    /**
+     * Get multiple head block hashes at the same time for a set of accounts
+     */
+    getHeadBlockHashes: (transaction: any, accounts: InstanceType<typeof Account.Set>) => Promise<{
+        [account: string]: BlockHash | null;
+    }>;
     /**
      * Get the HEAD block for an account (implemented by LedgerStorageBase using getHeadBlocks())
      */
@@ -222,6 +255,14 @@ export interface LedgerStorageAPI {
      * Get the next serial number for a representative
      */
     getNextSerialNumber: (transaction?: any) => Promise<bigint>;
+    /**
+     * Get the X.509 Certificates associated with an account
+     */
+    getAccountCertificates: (transaction: any, account: GenericAccount) => Promise<CertificateWithIntermediates[]>;
+    /**
+     * Get the X.509 Certificate associated with an account using the certificate hash
+     */
+    getAccountCertificateByHash: (transaction: any, account: GenericAccount, hash: CertificateHash) => Promise<CertificateWithIntermediates | null>;
     /**
      * Get ledger statistics
      */
@@ -232,13 +273,15 @@ export interface LedgerStorageAPI {
  */
 declare class LedgerAtomicInterface {
     #private;
-    constructor(transaction: any, storage: LedgerStorageAPI, config: LedgerConfig, ledger: Ledger);
+    constructor(transaction: LedgerStorageTransactionBase, storage: LedgerStorageAPI, config: LedgerConfig, ledger: Ledger);
     commit(): Promise<void>;
     abort(): Promise<void>;
     vote(blocks: Block[], otherVotes?: Vote[]): Promise<Vote>;
-    add(votesAndBlocks: VoteStaple, from?: 'bootstrap' | string): Promise<BlockHash[]>;
+    add(votesAndBlocks: VoteStaple, from?: 'bootstrap' | string): Promise<VoteStaple[]>;
     getBalance(account: GenericAccount, token: TokenAddress): Promise<bigint>;
     getAllBalances(account: GenericAccount): Promise<GetAllBalancesResponse>;
+    getAccountCertificates(account: GenericAccount): Promise<CertificateWithIntermediates[]>;
+    getAccountCertificateByHash(account: GenericAccount, hash: CertificateHash): Promise<CertificateWithIntermediates | null>;
     listACLsByPrincipal(principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
     listACLsByEntity(entity: GenericAccount): Promise<ACLRow[]>;
     votingPower(rep?: Account): Promise<bigint>;
@@ -260,7 +303,7 @@ declare class LedgerAtomicInterface {
     getStaplesFromBlockHashes(hashes: BlockHash[]): Promise<VoteStaple[]>;
     getVoteStaplesAfter(moment: Date, limit?: number, options?: GetVotesAfterOptions): Promise<VoteStaple[]>;
     gc(): Promise<boolean>;
-    _testingRunStorageFunction<T>(code: (storage: LedgerStorageAPI, transaction: any) => Promise<T>): Promise<T>;
+    _testingRunStorageFunction<T>(code: (storage: LedgerStorageAPI, transaction: LedgerStorageTransactionBase) => Promise<T>): Promise<T>;
 }
 /**
  * The core Ledger components
@@ -292,6 +335,8 @@ export declare class Ledger implements Omit<LedgerAtomicInterface, 'commit' | 'a
     listACLsByEntity(...args: Parameters<LedgerAtomicInterface['listACLsByEntity']>): ReturnType<LedgerAtomicInterface['listACLsByEntity']>;
     getBalance(...args: Parameters<LedgerAtomicInterface['getBalance']>): ReturnType<LedgerAtomicInterface['getBalance']>;
     getAllBalances(...args: Parameters<LedgerAtomicInterface['getAllBalances']>): ReturnType<LedgerAtomicInterface['getAllBalances']>;
+    getAccountCertificates(...args: Parameters<LedgerAtomicInterface['getAccountCertificates']>): ReturnType<LedgerAtomicInterface['getAccountCertificates']>;
+    getAccountCertificateByHash(...args: Parameters<LedgerAtomicInterface['getAccountCertificateByHash']>): ReturnType<LedgerAtomicInterface['getAccountCertificateByHash']>;
     votingPower(...args: Parameters<LedgerAtomicInterface['votingPower']>): ReturnType<LedgerAtomicInterface['votingPower']>;
     getVotes(...args: Parameters<LedgerAtomicInterface['getVotes']>): ReturnType<LedgerAtomicInterface['getVotes']>;
     getVotesFromMultiplePrevious(...args: Parameters<LedgerAtomicInterface['getVotesFromMultiplePrevious']>): ReturnType<LedgerAtomicInterface['getVotesFromMultiplePrevious']>;
@@ -308,6 +353,6 @@ export declare class Ledger implements Omit<LedgerAtomicInterface, 'commit' | 'a
     getVoteStaplesAfter(...args: Parameters<LedgerAtomicInterface['getVoteStaplesAfter']>): ReturnType<LedgerAtomicInterface['getVoteStaplesAfter']>;
     gc(...args: Parameters<LedgerAtomicInterface['gc']>): ReturnType<LedgerAtomicInterface['gc']>;
     stats(): Promise<LedgerStatistics>;
-    _testingRunStorageFunction<T>(code: (storage: LedgerStorageAPI, transaction: any) => Promise<T>): Promise<T>;
+    _testingRunStorageFunction<T>(code: (storage: LedgerStorageAPI, transaction: LedgerStorageTransactionBase) => Promise<T>): Promise<T>;
 }
 export default Ledger;

package/lib/ledger/types.d.ts

@@ -1,7 +1,8 @@
 import type { GenericAccount, TokenAddress } from '../account';
 import type { AdjustMethod } from '../block';
 import type { Permissions } from '../permissions';
-import type { TimeStats } from '../stats';
+import type { DbStats, TimeStats } from '../stats';
+import type { Certificate, CertificateBundle } from '../utils/certificate';
 /**
  * Account info entry
  */
@@ -97,5 +98,10 @@ export interface LedgerStatistics {
     blockCount: number;
     transactionCount: number;
     representativeCount: number;
+    db: DbStats;
     settlementTimes: TimeStats;
 }
+export interface CertificateWithIntermediates {
+    certificate: Certificate;
+    intermediates: CertificateBundle | null;
+}

package/lib/node/local.d.ts

@@ -1,11 +1,18 @@
+import type { Response as ExpressResponse } from 'express';
 import type { NodeConfig } from './';
 import { Node } from './';
 import type { BootstrapConfig } from '../bootstrap';
 import { BootstrapClient } from '../bootstrap';
 import type { ErrorCode } from '../error';
-export type LocalNodeConfig = NodeConfig & {
+export type LocalNodeConfig = Omit<NodeConfig, 'nodeOptions'> & {
     bootstrap?: BootstrapConfig;
     invokeSecret?: string;
+    nodeOptions?: {
+        listenIP?: string;
+        listenPort?: number;
+        timingSampleRate?: number;
+        noSyncAfterEachRoute?: boolean;
+    };
 };
 export type ApiErrorResponse = {
     error: boolean;
@@ -19,7 +26,9 @@ type LocalNodeRunOptions = {
 export declare class LocalNode extends Node {
     #private;
     static isInstance: (obj: any, strict?: boolean) => obj is LocalNode;
+    config: LocalNodeConfig;
     constructor(config: LocalNodeConfig);
+    setCorsHeaders(response: ExpressResponse): void;
     addRoutes(prefix?: string): void;
     get _app(): import("express-serve-static-core").Express;
     run(options?: LocalNodeRunOptions): Promise<void>;

package/lib/node/timing.d.ts

@@ -1,11 +1,50 @@
+interface DisposableTimingHandle extends Disposable {
+    /**
+     * Unique identifier for the timing section
+     */
+    id: symbol;
+    /**
+     * End the timing section
+     */
+    end: () => void;
+    /**
+     * Dispose of the timing section, ending it
+     */
+    [Symbol.dispose]: () => void;
+}
 export declare class RequestTiming {
     #private;
-    startTime(section: string): void;
-    endTime(section: string, deduplicate?: boolean): void;
-    runTimer<T>(section: string, code: () => Promise<T>, deduplicate?: boolean): Promise<T>;
-    getTiming(section: string): number;
+    static defaultLogger: Console;
+    log: Console;
+    /**
+     * Start timing a section of code
+     * @param section Name of the section to time -- should be unique within the code base so that it can be identified later
+     * @returns A handle which can be used to end the timing section
+     */
+    startTime(section: string): DisposableTimingHandle;
+    endTime(section: symbol | undefined | ReturnType<RequestTiming['startTime']>): void;
+    /** @deprecated Use `endTime(section: symbol)` instead */
+    endTime(section: string | undefined, deduplicate?: boolean): void;
+    /**
+     * Run a piece of code and time it, returning the result of the code
+     *
+     * This takes an optional "timing" parameter which is a timing object
+     * if one exists, to update -- if this parameter is undefined no timing
+     * will be done.
+     *
+     * @param section Name of the section to time -- should be unique within the code base so that it can be identified later
+     * @param timing Timing object to update, if available
+     * @param code The code to run
+     * @returns The result of the code
+     */
+    static runTimer<T>(section: string, timing: RequestTiming | undefined, code: () => Promise<T>): Promise<T>;
+    runTimer<T>(section: string, code: () => Promise<T>): Promise<T>;
+    private getTiming;
     getAllTiming(): {
-        [section: string]: number;
+        [section: string]: {
+            name: string;
+            duration: number;
+        };
     };
     counter(): number;
 }

package/lib/p2p.d.ts

@@ -72,9 +72,12 @@ interface P2PPeerBase {
 interface P2PPeerRepBase extends P2PPeerBase {
     kind: NodeKind.REPRESENTATIVE;
     /**
-     * Endpoint to reach the representative
+     * Endpoints to reach the representative
      */
-    endpoint: string;
+    endpoints: {
+        p2p: string;
+        api: string;
+    };
     /**
      * Public key of the representative (used as the ID)
      */
@@ -224,7 +227,7 @@ export declare class P2PWebSocket implements P2PConnection {
 /**
  * The interfaces from the Node that the P2P switch uses
  */
-type NodeLike = Pick<Node, 'recvMessageFromPeer' | 'config' | 'stats' | 'log'>;
+type NodeLike = Pick<Node, 'recvMessageFromPeer' | 'sendMessage' | 'config' | 'stats' | 'log'>;
 /**
  * Deserializer DB
  */

package/lib/permissions.d.ts

@@ -17,7 +17,8 @@ declare enum BaseFlag {
     TOKEN_ADMIN_SUPPLY = 6,/* 0x0040 */
     TOKEN_ADMIN_MODIFY_BALANCE = 7,/* 0x0080 */
     PERMISSION_DELEGATE_ADD = 11,/* 0x0800 */
-    PERMISSION_DELEGATE_REMOVE = 12
+    PERMISSION_DELEGATE_REMOVE = 12,/* 0x1000 */
+    MANAGE_CERTIFICATE = 13
 }
 type ExternalFlagName = `${typeof externalFlagPrefix}${string}`;
 export type BaseFlagName = keyof typeof BaseFlag;
@@ -116,6 +117,5 @@ export declare class Permissions {
     get canUseDelegation(): boolean;
     get base(): BaseSet;
     get external(): ExternalSet;
-    static toJSONSerializablePrefix: string;
-    static toJSONSerializable(value: Permissions): bigint[];
+    toJSON(): [bigint, bigint];
 }

package/lib/pubsub/index.d.ts

@@ -1,7 +1,7 @@
 import type { JSONSerializable } from '../utils/conversion';
 export type SubscriptionCallback = (message: JSONSerializable) => void;
 export interface PubSubProviderAPI {
-    subscribe: (channel: string, callback: SubscriptionCallback) => Promise<void>;
     publish: (channel: string, message: JSONSerializable) => Promise<void>;
+    subscribe: (channel: string, callback: SubscriptionCallback) => Promise<void>;
     destroy: () => Promise<void>;
 }

package/lib/pubsub/providers.d.ts

@@ -1,7 +1,9 @@
 import PubSubProviderMemory from './ps_memory';
 import PubSubProviderRedis from './ps_redis';
+import PubSubProviderGCP from './ps_gcp';
 export declare const PS: {
     Memory: typeof PubSubProviderMemory;
     Redis: typeof PubSubProviderRedis;
+    GCP: typeof PubSubProviderGCP;
 };
 export default PS;

package/lib/pubsub/ps_gcp.d.ts

@@ -0,0 +1,14 @@
+import type { JSONSerializable } from '../utils/conversion';
+import type { PubSubProviderAPI, SubscriptionCallback } from '.';
+import { PubSub } from '@google-cloud/pubsub';
+import type { Topic } from '@google-cloud/pubsub';
+export declare class PubSubProviderGCP implements PubSubProviderAPI {
+    #private;
+    constructor(projectId: string, apiEndpoint?: string);
+    get _testing_pubsub(): PubSub;
+    publish(channel: string, message: JSONSerializable): Promise<void>;
+    subscribe(channel: string, callback: SubscriptionCallback): Promise<void>;
+    destroy(): Promise<void>;
+    assertTopicExists(topic: Topic, channel: string): Promise<true | undefined>;
+}
+export default PubSubProviderGCP;

package/lib/stats.d.ts

@@ -1,6 +1,7 @@
 import type { KVStorageProvider } from './kv';
 import { BufferStorage } from './utils/buffer';
 import type { BlockHash } from './block';
+import type { RequestTiming } from './node/timing';
 export interface StatsConfig {
     kv: KVStorageProvider | null;
 }
@@ -33,6 +34,9 @@ type TimeStat = {
 export type TimeStats = {
     [duration in DurationBreakdowns]: TimeStat;
 };
+export type DbStats = {
+    retries: number;
+};
 export declare class Stats {
     #private;
     constructor(config: StatsConfig);
@@ -44,6 +48,7 @@ export declare class Stats {
     xor(key: string, change: BlockHash | BufferStorage): void;
     getXor(key: string): Promise<BufferStorage>;
     addTimingPoint(arena: string, category: string, duration: number, returnOnly?: boolean): Parameters<Stats['incr']>;
+    addRequestTiming(arena: string, timing: RequestTiming, returnOnly?: boolean): Parameters<Stats['incr']>[];
     get(arena: string, key: string): Promise<number>;
     getTimingData(arena: string, category: string): Promise<TimeStats>;
     sync(): Promise<void>;

package/lib/utils/asn1.d.ts

@@ -44,6 +44,7 @@ export interface ASN1String extends ASN1Object {
     kind: 'printable' | 'ia5' | 'utf8';
     value: string;
 }
+export declare function isASN1Object(input: unknown): input is ASN1Object;
 /**
  * Validation function for {@link isValidSequenceSchema}
  */
@@ -63,7 +64,7 @@ export declare namespace ValidateASN1 {
         sequenceOf: Schema;
     } | {
         optional: Schema;
-    } | {
+    } | bigint | {
         type: 'context';
         kind: 'implicit' | 'explicit';
         contains: Schema;
@@ -110,7 +111,7 @@ export declare namespace ValidateASN1 {
         sequenceOf: Schema;
     } ? SchemaMap<T['sequenceOf']>[] : T extends {
         optional: Schema;
-    } ? SchemaMap<T['optional']> | undefined : T extends {
+    } ? SchemaMap<T['optional']> | undefined : T extends bigint ? T : T extends {
         type: 'context';
         kind: infer U extends 'implicit' | 'explicit';
         value: number;
@@ -182,7 +183,7 @@ type Mutable<T> = T extends Buffer | ArrayBuffer | Date ? T : T extends object ?
 export declare class BufferStorageASN1<T extends ASN1AnyJS | Readonly<ASN1AnyJS> = Readonly<ASN1AnyJS>, S extends ValidateASN1.Schema | undefined = undefined> {
     #private;
     static readonly Validate: typeof ValidateASN1;
-    static readonly isInstance: (obj: any, strict?: boolean) => obj is BufferStorageASN1<string | number | bigint | boolean | Buffer | ASN1AnyJS[] | Date | ASN1OID | ASN1Set | ASN1ExplicitContextTag | ASN1ImplicitContextTag | ASN1BitString | ASN1Date | ASN1String | readonly ASN1AnyJS[] | Readonly<Buffer> | Readonly<Date> | Readonly<ASN1OID> | Readonly<ASN1Set> | Readonly<ASN1ExplicitContextTag> | Readonly<ASN1ImplicitContextTag> | Readonly<ASN1BitString> | Readonly<ASN1Date> | Readonly<ASN1String> | null | undefined, ValidateASN1.Schema | undefined>;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is BufferStorageASN1<string | number | bigint | boolean | Date | Buffer | ASN1AnyJS[] | ASN1OID | ASN1Set | ASN1ExplicitContextTag | ASN1ImplicitContextTag | ASN1BitString | ASN1Date | ASN1String | readonly ASN1AnyJS[] | Readonly<Date> | Readonly<Buffer> | Readonly<ASN1OID> | Readonly<ASN1Set> | Readonly<ASN1ExplicitContextTag> | Readonly<ASN1ImplicitContextTag> | Readonly<ASN1BitString> | Readonly<ASN1Date> | Readonly<ASN1String> | null | undefined, ValidateASN1.Schema | undefined>;
     constructor(input: T | ArrayBuffer, schema?: S);
     getDER(): ArrayBuffer;
     getDERBuffer(): Buffer;

package/lib/utils/buffer.d.ts

@@ -1,3 +1,4 @@
+import { Buffer } from 'buffer';
 import zlib from 'zlib';
 /**
  * RFC 4648 Base32 Decoder
@@ -11,6 +12,8 @@ export declare function DecodeBase64(data: string): ArrayBuffer;
 export declare function EncodeBase64(data: ArrayBuffer): string;
 export declare function ZlibInflate(data: ArrayBuffer, options?: zlib.ZlibOptions): ArrayBuffer;
 export declare function ZlibDeflate(data: ArrayBuffer, options?: zlib.ZlibOptions): ArrayBuffer;
+export declare function ZlibInflateAsync(data: ArrayBuffer, options?: zlib.ZlibOptions): Promise<ArrayBuffer>;
+export declare function ZlibDeflateAsync(data: ArrayBuffer, options?: zlib.ZlibOptions): Promise<ArrayBuffer>;
 export declare class BufferStorage {
     #private;
     readonly storageKind: string;
@@ -24,3 +27,4 @@ export declare class BufferStorage {
     compare(compareWith: typeof this | undefined | null): boolean;
     compareHexString(compareWith: BufferStorage | string | undefined | null): boolean;
 }
+export { Buffer };

package/lib/utils/certificate.d.ts

@@ -1,6 +1,8 @@
 import * as ASN1 from './asn1';
-import Account from '../account';
+import Account, { AccountKeyAlgorithm } from '../account';
 import * as HashLib from './hash';
+import { BufferStorage } from './buffer';
+import type { ToJSONSerializableOptions, ToJSONSerializable } from './conversion';
 /**
  * De-normalized mapped Certificate Schema, for use in type annotations since
  * we do not want to expose such a complex type
@@ -132,7 +134,7 @@ export declare class CertificateBuilder {
      * Create a certificate
      */
     buildDER(params?: Partial<CertificateBuilderParams>): Promise<ArrayBuffer>;
-    build(params?: Partial<CertificateBuilderParams>): Promise<Certificate>;
+    build(params?: Partial<CertificateBuilderParams>, options?: ConstructorParameters<typeof Certificate>[1]): Promise<Certificate>;
 }
 type CertificateOptions = {
     /**
@@ -163,12 +165,48 @@ type CertificateOptions = {
      */
     isTrustedRoot?: boolean;
 };
+type CertificateHashString = string & {
+    readonly __certificateHash: never;
+};
+/**
+ * Certificate hash
+ */
+export declare class CertificateHash extends BufferStorage {
+    static isInstance: (obj: any, strict?: boolean) => obj is CertificateHash;
+    static Set: import("./helper").InstanceSetConstructor<CertificateHash, CertificateHashString>;
+    get hashFunctionName(): string;
+    constructor(certificateHash: ConstructorParameters<typeof BufferStorage>[0]);
+    static fromData(data: Buffer): CertificateHash;
+    toJSON(): CertificateHashString;
+    toString(): CertificateHashString;
+}
+export declare class CertificateBundle {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is CertificateBundle;
+    constructor(input: CertificateBundle | Certificate[] | ArrayBuffer | Buffer | string | (ConstructorParameters<typeof Certificate>[0])[] | Set<Certificate>);
+    get bundleSize(): number;
+    getDER(): ArrayBuffer;
+    getDERBuffer(): Buffer;
+    getCertificates(): Certificate[];
+    toJSON(): {
+        certificates: string[];
+    };
+}
+export type CertificateJSONOutput = ToJSONSerializable<ReturnType<Certificate['toJSON']>>;
 export declare class Certificate {
     #private;
     /**
      * The Certificate Builder
      */
     static readonly Builder: typeof CertificateBuilder;
+    /**
+     * The certificate bundle
+     */
+    static readonly Bundle: typeof CertificateBundle;
+    /**
+     * The certificate hash information
+     */
+    static readonly Hash: typeof CertificateHash;
     /**
      * The serial number of the certificate
      */
@@ -185,10 +223,24 @@ export declare class Certificate {
      * The Subject DN of the certificate as a string --- for informational purposes only
      */
     readonly subject: string;
+    /**
+     * The Subject DN of the certificate --- for informational purposes only
+     */
+    readonly subjectDN: ({
+        name: string;
+        value: string;
+    })[];
     /**
      * The Issuer DN of the certificate as a string --- for informational purposes only
      */
     readonly issuer: string;
+    /**
+     * The Issuer DN of the certificate --- for informational purposes only
+     */
+    readonly issuerDN: ({
+        name: string;
+        value: string;
+    })[];
     /**
      * The Subject of the certificate as a KeetaNet Account, derived from the
      * public key in the certificate
@@ -229,11 +281,11 @@ export declare class Certificate {
     /**
      * The complete SubjectDN
      */
-    protected subjectDN: CertificateSchema[0][5];
+    protected subjectDNSet: CertificateSchema[0][5];
     /**
      * The complete IssuerDN
      */
-    protected issuerDN: CertificateSchema[0][3];
+    protected issuerDNSet: CertificateSchema[0][3];
     /**
      * Object type ID for {@link Certificate.isCertificate}
      */
@@ -269,6 +321,11 @@ export declare class Certificate {
      * Verifies that the certificate is was signed by the given account or certificate
      */
     verify(account: Account | Certificate): boolean;
+    /**
+     * Asserts provided certificates can construct a valid graph with no loops or orphans, and that all provided certificates can reach the root, or current certificate
+     * @param certificates Additional intermediate certificates to verify
+     */
+    assertCanConstructValidGraph(certificates: Set<Certificate>): true | undefined;
     /**
      * Verify against a given certificate store
      */
@@ -328,13 +385,57 @@ export declare class Certificate {
      * Get the certificate as a PEM encoded string
      */
     toPEM(): string;
+    /**
+     * The string representation of the certificate
+     * is a PEM encoded certificate -- this misses
+     * some of the internal details like chain
+     * and verified, but is usually what someone
+     * wants to see when they call toString()
+     */
+    toString(): string;
     /**
      * Compute a hash of the certificate
      */
-    hash(): string;
+    hash(): CertificateHash;
     /**
      * Get a JSON representation of the certificate
      */
-    toJSON(includeChain?: boolean): any;
+    toJSON(options?: ToJSONSerializableOptions, includeChain?: boolean): {
+        $binary?: string;
+        $chain?: unknown;
+        serial: bigint;
+        notBefore: Date;
+        notAfter: Date;
+        subject: string;
+        issuer: string;
+        subjectPublicKey: Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1>;
+        baseExtensions: {
+            /**
+             * Basic Constraints
+             */
+            basicConstraints?: [ca: boolean, pathLenConstraint?: bigint];
+            /**
+             * Subject Key Identifier
+             */
+            subjectKeyIdentifier?: Buffer;
+            /**
+             * Authority Key Identifier
+             */
+            authorityKeyIdentifier?: {
+                type: "context";
+                value: 0;
+                contains: Buffer;
+            };
+        } | undefined;
+        subjectDN: {
+            name: string;
+            value: string;
+        }[];
+        issuerDN: {
+            name: string;
+            value: string;
+        }[];
+        $hash: CertificateHash;
+    };
 }
 export {};