@keetanetwork/keetanet-client 0.12.2 → 0.14.2

package/lib/ledger/db_spanner_helper.d.ts

@@ -184,7 +184,21 @@ declare const ColumnTypes: {
         fromSpanner: (pubKey: string) => GenericAccount;
         toSpanner: (account: GenericAccount) => import("../account").TokenPublicKeyString | import("../account").NetworkPublicKeyString | import("../account").StoragePublicKeyString | import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
     };
-    readonly BUFFER_BIGINT: {
+    readonly BUFFER_BIGINT_39: {
+        dbType: string;
+        dbSize: string;
+        toSpanner: (buf: bigint) => Buffer;
+        fromSpanner: (value: Buffer) => bigint;
+        toComparable: (val: Buffer | bigint | string) => bigint;
+    };
+    readonly BUFFER_BIGINT_16: {
+        dbType: string;
+        dbSize: string;
+        toSpanner: (buf: bigint) => Buffer;
+        fromSpanner: (value: Buffer) => bigint;
+        toComparable: (val: Buffer | bigint | string) => bigint;
+    };
+    readonly BUFFER_BIGINT_8: {
         dbType: string;
         dbSize: string;
         toSpanner: (buf: bigint) => Buffer;
@@ -231,6 +245,7 @@ declare const schema: {
             readonly description: ColumnInterface<"INFO_DESCRIPTION", true>;
             readonly metadata: ColumnInterface<"INFO_METADATA", true>;
             readonly supply: ColumnInterface<"SUPPLY", true>;
+            readonly multisigQuorum: ColumnInterface<"BIGINT", true>;
             readonly defaultBasePermission: ColumnInterface<"BASE_PERMISSION", true>;
             readonly defaultExternalPermission: ColumnInterface<"EXTERNAL_PERMISSION", true>;
         };
@@ -274,7 +289,7 @@ declare const schema: {
         readonly columns: {
             readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
             readonly voteBlockHash: ColumnInterface<"VOTEBLOCKHASH", false>;
-            readonly orderIndex: ColumnInterface<"BUFFER_BIGINT", false>;
+            readonly orderIndex: ColumnInterface<"BUFFER_BIGINT_39", false>;
         };
         readonly key: readonly [Key, Key];
         readonly interleave: Interleave;
@@ -295,9 +310,10 @@ declare const schema: {
             readonly onLedger: ColumnInterface<"LEDGER", false>;
             readonly vote: ColumnInterface<"VOTE", false>;
             readonly timestamp: ColumnInterface<"TIMESTAMP", false>;
-            readonly expires: ColumnInterface<"TIMESTAMP", false>;
             readonly issuer: ColumnInterface<"ACCOUNT", false>;
             readonly voteBlockHash: ColumnInterface<"VOTEBLOCKHASH", false>;
+            readonly orderIndex: ColumnInterface<"BUFFER_BIGINT_16", false>;
+            readonly expiresIndex: ColumnInterface<"BUFFER_BIGINT_8", true>;
         };
         readonly key: readonly [Key, Key];
     };
@@ -365,11 +381,17 @@ declare const schema: {
         readonly table: "permissions";
         readonly key: readonly [Key, Key];
     };
-    readonly historyVoteBlockHash: {
+    readonly historyVoteBlockHashAccount: {
         readonly type: "INDEX";
         readonly table: "history";
         readonly key: readonly [Key, Key];
     };
+    readonly historyOrdered: {
+        readonly type: "INDEX";
+        readonly table: "history";
+        readonly key: readonly [Key];
+        readonly storing: readonly [Key];
+    };
     readonly chainAccountHash: {
         readonly type: "INDEX";
         readonly table: "chain";
@@ -383,15 +405,16 @@ declare const schema: {
         readonly key: readonly [Key];
         readonly storing: readonly [Key];
     };
-    readonly votesTimestamp: {
+    readonly votesOrderIndex: {
         readonly type: "INDEX";
         readonly table: "votes";
         readonly key: readonly [Key, Key];
         readonly storing: readonly [Key];
     };
-    readonly votesOnLedgerExpired: {
+    readonly votesExpiredIndex: {
         readonly type: "INDEX";
         readonly table: "votes";
+        readonly nullFiltered: true;
         readonly key: readonly [Key, Key];
         readonly storing: readonly [Key];
     };

package/lib/ledger/db_sqlite.d.ts

@@ -4,16 +4,18 @@ import type { BlockHash } from '../block';
 import { Block } from '../block';
 import type { GenericAccount, IdentifierAddress, TokenAddress } from '../account';
 import Account, { AccountKeyAlgorithm } from '../account';
-import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBase } from '../ledger';
+import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions } from '../ledger';
+import { LedgerStorageTransactionBase } from '../ledger';
 import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
 import { LedgerStorageBase } from './common';
 import * as sqlite from 'sqlite';
 import type { ComputedEffectOfBlocks } from './effects';
 import type { CertificateHash } from '../utils/certificate';
-interface DBSqliteTransaction extends LedgerStorageTransactionBase {
+declare class DBSqliteTransaction extends LedgerStorageTransactionBase {
     sql: Awaited<ReturnType<typeof sqlite['open']>>;
     release: null | ((value: null | number) => void);
     lock: null | Promise<null | number>;
+    constructor(baseTransaction: LedgerStorageTransactionBaseOptions, db: Awaited<ReturnType<typeof sqlite['open']>>);
 }
 export interface DBSqliteConfig {
     filename: string;
@@ -24,7 +26,7 @@ export declare class DBSqlite extends LedgerStorageBase implements LedgerStorage
     constructor();
     init(config: LedgerConfig, ledger: Ledger): void;
     destroy(): Promise<void>;
-    beginTransaction(transactionBase: LedgerStorageTransactionBase): Promise<DBSqliteTransaction>;
+    beginTransaction(transactionBase: LedgerStorageTransactionBaseOptions): Promise<DBSqliteTransaction>;
     commitTransaction(transaction: DBSqliteTransaction): Promise<void>;
     abortTransaction(transaction: DBSqliteTransaction): Promise<void>;
     evaluateError(error: any): Promise<any>;
@@ -44,9 +46,15 @@ export declare class DBSqlite extends LedgerStorageBase implements LedgerStorage
     adjust(transaction: DBSqliteTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean, completedStaples?: Set<string>): Promise<VoteStaple[]>;
     getBlock(transaction: DBSqliteTransaction, block: BlockHash, from: LedgerSelector): Promise<Block | null>;
     getBlockHeight(transaction: DBSqliteTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
+    getBlockHeights(transaction: DBSqliteTransaction, toFetch: {
+        blockHash: BlockHash;
+        account: GenericAccount;
+    }[]): Promise<{
+        [blockHash: string]: bigint | null;
+    }>;
     getVotes(transaction: DBSqliteTransaction, block: BlockHash, from: LedgerSelector): Promise<Vote[] | null>;
     getVoteStaples(transaction: DBSqliteTransaction, voteBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
-    getHistory(transaction: DBSqliteTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
+    getHistory(transaction: DBSqliteTransaction, account: GenericAccount | null, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
     getBlockFromPrevious(transaction: DBSqliteTransaction, prevBlock: BlockHash, from: LedgerSelector): Promise<Block | null>;
     getVotesFromMultiplePrevious(transaction: DBSqliteTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: GenericAccount): Promise<{
         [hash: string]: Vote[] | null;

package/lib/ledger/effects.d.ts

@@ -1,8 +1,9 @@
 import type { GenericAccount, IdentifierAddress, NetworkAddress, TokenAddress } from '../account';
 import Account from '../account';
-import type { AdjustMethod, BlockHash } from '../block';
+import type { AdjustMethod } from '../block';
 import { Block } from '../block';
-import type { AccountInfo, ACLEntry, ACLUpdate } from '../ledger/types';
+import type * as Operations from '../block/operations';
+import type { UserEditableAccountInfo, ACLEntry, ACLUpdate } from '../ledger/types';
 import type { Certificate, CertificateBundle } from '../utils/certificate';
 import { CertificateHash } from '../utils/certificate';
 interface NumericValueEntry {
@@ -41,24 +42,23 @@ interface ComputedBlocksEffectTokenChangesField {
 /**
  * Which fields may be affected by blocks
  */
-type CreateIdentifierRequest = {
-    previousBlockHash: BlockHash;
-    requestedIdentifier: IdentifierAddress;
-    operationIndex: number;
-    account: GenericAccount;
-};
+interface CreateIdentifierRequest {
+    createdIdentifier: IdentifierAddress;
+    createArguments?: Operations.IdentifierCreateArguments;
+}
 type DelegationUpdate = {
     delegateTo: Account;
 };
 interface ComputedBlocksEffectFields {
     balance?: ComputedBlocksEffectTokenChangesField;
     supply?: NumericValueEntry[];
-    info?: AccountInfo;
+    info?: Partial<UserEditableAccountInfo>;
     permissions?: ACLUpdate[];
     permissionRequirements?: ACLEntry[];
     createRequests?: CreateIdentifierRequest[];
     delegation?: DelegationUpdate;
     certificate?: CertificateUpdate[];
+    minSignerSetLength?: bigint;
 }
 /**
  * Which accounts and fields are affected by a set of block
@@ -80,6 +80,7 @@ export type ComputedEffectOfBlocks = {
     metadata: {
         operationCount: number;
         blockCount: number;
+        feeUnits: bigint;
     };
 };
 type LedgerOptions = {

package/lib/ledger/index.d.ts

@@ -1,7 +1,7 @@
 import { VoteStaple, Vote, VoteBlockHashMap } from '../vote';
 import { Block, BlockHash } from '../block';
-import type { VoteBlockHash } from '../vote';
-import type { GenericAccount, IdentifierAddress, NetworkAddress, TokenAddress } from '../account';
+import type { FeeAmountAndToken, VoteBlockHash, VoteQuote } from '../vote';
+import type { GenericAccount, IdentifierAddress, NetworkAddress, StorageAddress, TokenAddress } from '../account';
 import Account from '../account';
 import type Node from '../node';
 import type { BloomFilter } from '../utils/bloom';
@@ -9,6 +9,7 @@ import type { ComputedEffectOfBlocks } from './effects';
 import type { ACLRow, AccountInfo, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
 import LedgerRequestCache from './cache';
 import type { CertificateHash } from '../utils/certificate';
+import { StatsPending } from '../stats';
 /**
  * Kind of ledger
  */
@@ -31,6 +32,10 @@ export interface LedgerConfig {
      * Private key for the ledger if it is acting as a representative
      */
     privateKey?: Account;
+    /**
+     * Provided function to compute fees for a given set of Blocks and computed effects
+     */
+    computeFeeFromBlocks: (ledger: Ledger, blocks: Block[], effects: ComputedEffectOfBlocks) => FeeAmountAndToken | null;
     /**
      * Storage mechanism
      */
@@ -98,11 +103,19 @@ export type GetVotesAfterOptions = {
 /**
  * Each transaction can contain the node object making the request to access things like timing information
  */
-export interface LedgerStorageTransactionBase {
+export interface LedgerStorageTransactionBaseOptions {
+    node?: Node;
+    moment?: Date;
+    identifier: string;
+    readOnly?: boolean;
+}
+export declare class LedgerStorageTransactionBase implements LedgerStorageTransactionBaseOptions {
     node?: Node;
     moment: Date;
     identifier: string;
     readOnly: boolean;
+    statsPending: StatsPending;
+    constructor(options: LedgerStorageTransactionBaseOptions);
 }
 /**
  * Each Ledger Storage backend must implement this interface
@@ -119,7 +132,7 @@ export interface LedgerStorageAPI {
     /**
      * Begin a transaction
      */
-    beginTransaction: (transactionBase: LedgerStorageTransactionBase) => Promise<LedgerStorageTransactionBase>;
+    beginTransaction: (transactionBase: LedgerStorageTransactionBaseOptions) => Promise<LedgerStorageTransactionBase>;
     /**
      * Commit an active transaction
      */
@@ -208,9 +221,9 @@ export interface LedgerStorageAPI {
      */
     getVoteStaples: (transaction: any, voteBlockHashes: VoteBlockHash[], from: LedgerSelector) => Promise<VoteBlockHashMap<VoteStaple | null>>;
     /**
-     * Get the history for a specific account
+     * Get the history for a specific account or all accounts if account is null
      */
-    getHistory: (transaction: any, account: GenericAccount, start: VoteBlockHash | null, limit?: number) => Promise<VoteBlockHash[]>;
+    getHistory: (transaction: any, account: GenericAccount | null, start: VoteBlockHash | null, limit?: number) => Promise<VoteBlockHash[]>;
     /**
      * Get multiple head blocks at the same time for a set of accounts
      */
@@ -250,7 +263,7 @@ export interface LedgerStorageAPI {
     /**
      * Perform Garbage Collection
      */
-    gc: (transaction: any) => Promise<boolean>;
+    gc: (transaction: any, timeLimitMS?: number) => Promise<boolean>;
     /**
      * Get the next serial number for a representative
      */
@@ -276,7 +289,8 @@ declare class LedgerAtomicInterface {
     constructor(transaction: LedgerStorageTransactionBase, storage: LedgerStorageAPI, config: LedgerConfig, ledger: Ledger);
     commit(): Promise<void>;
     abort(): Promise<void>;
-    vote(blocks: Block[], otherVotes?: Vote[]): Promise<Vote>;
+    vote(blocks: Block[], otherVotes?: Vote[], quote?: VoteQuote): Promise<Vote>;
+    quote(blocks: Block[]): Promise<VoteQuote>;
     add(votesAndBlocks: VoteStaple, from?: 'bootstrap' | string): Promise<VoteStaple[]>;
     getBalance(account: GenericAccount, token: TokenAddress): Promise<bigint>;
     getAllBalances(account: GenericAccount): Promise<GetAllBalancesResponse>;
@@ -299,10 +313,11 @@ declare class LedgerAtomicInterface {
     getBlock(blockhash: BlockHash, from?: LedgerSelector): Promise<Block | null>;
     getVoteStaple(stapleBlockHash: VoteBlockHash, from?: LedgerSelector): Promise<VoteStaple | null>;
     getVoteStaples(stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
-    getHistory(account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteStaple[]>;
+    getHistory(account: GenericAccount | null, start: VoteBlockHash | null, limit?: number): Promise<VoteStaple[]>;
     getStaplesFromBlockHashes(hashes: BlockHash[]): Promise<VoteStaple[]>;
     getVoteStaplesAfter(moment: Date, limit?: number, options?: GetVotesAfterOptions): Promise<VoteStaple[]>;
-    gc(): Promise<boolean>;
+    gc(timeLimitMS?: number): Promise<boolean>;
+    getFee(blocks: Block[], effectsInput?: ComputedEffectOfBlocks): Promise<FeeAmountAndToken | null>;
     _testingRunStorageFunction<T>(code: (storage: LedgerStorageAPI, transaction: LedgerStorageTransactionBase) => Promise<T>): Promise<T>;
 }
 /**
@@ -319,6 +334,7 @@ export declare class Ledger implements Omit<LedgerAtomicInterface, 'commit' | 'a
     constructor(config: LedgerConfig, node?: Node, existingStorage?: LedgerStorageAPI);
     get ledgerWriteMode(): NonNullable<LedgerConfig['ledgerWriteMode']>;
     copy(newNode: Node): Ledger;
+    getFeePayToAndToken(accounts?: (Account | StorageAddress)[], token?: TokenAddress): Partial<FeeAmountAndToken>;
     /**
      * Execute some code with a transaction held, if the code fails the
      * transaction is aborted, otherwise it is committed
@@ -330,6 +346,7 @@ export declare class Ledger implements Omit<LedgerAtomicInterface, 'commit' | 'a
     runReadOnly<T>(identifier: string, code: (transaction: LedgerAtomicInterface) => Promise<T>): ReturnType<typeof code>;
     beginTransaction(identifier: string, readOnly?: boolean): Promise<LedgerAtomicInterface>;
     vote(...args: Parameters<LedgerAtomicInterface['vote']>): ReturnType<LedgerAtomicInterface['vote']>;
+    quote(...args: Parameters<LedgerAtomicInterface['quote']>): ReturnType<LedgerAtomicInterface['quote']>;
     add(...args: Parameters<LedgerAtomicInterface['add']>): ReturnType<LedgerAtomicInterface['add']>;
     listACLsByPrincipal(...args: Parameters<LedgerAtomicInterface['listACLsByPrincipal']>): ReturnType<LedgerAtomicInterface['listACLsByPrincipal']>;
     listACLsByEntity(...args: Parameters<LedgerAtomicInterface['listACLsByEntity']>): ReturnType<LedgerAtomicInterface['listACLsByEntity']>;
@@ -352,6 +369,7 @@ export declare class Ledger implements Omit<LedgerAtomicInterface, 'commit' | 'a
     getStaplesFromBlockHashes(...args: Parameters<LedgerAtomicInterface['getStaplesFromBlockHashes']>): ReturnType<LedgerAtomicInterface['getStaplesFromBlockHashes']>;
     getVoteStaplesAfter(...args: Parameters<LedgerAtomicInterface['getVoteStaplesAfter']>): ReturnType<LedgerAtomicInterface['getVoteStaplesAfter']>;
     gc(...args: Parameters<LedgerAtomicInterface['gc']>): ReturnType<LedgerAtomicInterface['gc']>;
+    getFee(...args: Parameters<LedgerAtomicInterface['getFee']>): ReturnType<LedgerAtomicInterface['getFee']>;
     stats(): Promise<LedgerStatistics>;
     _testingRunStorageFunction<T>(code: (storage: LedgerStorageAPI, transaction: LedgerStorageTransactionBase) => Promise<T>): Promise<T>;
 }

package/lib/ledger/types.d.ts

@@ -1,8 +1,12 @@
-import type { GenericAccount, TokenAddress } from '../account';
+import type { Account, GenericAccount, MultisigAddress, TokenAddress } from '../account';
 import type { AdjustMethod } from '../block';
 import type { Permissions } from '../permissions';
 import type { DbStats, TimeStats } from '../stats';
 import type { Certificate, CertificateBundle } from '../utils/certificate';
+export interface MultisigConfig {
+    signers: (Account | MultisigAddress)[];
+    quorum: bigint;
+}
 /**
  * Account info entry
  */
@@ -27,7 +31,12 @@ export interface AccountInfo {
      * The default permissions for the account
      */
     defaultPermission?: Permissions;
+    /**
+     * If this is a multisig account, the number of signers required
+     */
+    multisigQuorum?: bigint;
 }
+export type UserEditableAccountInfo = Omit<AccountInfo, 'supply'>;
 /**
  * Permissions types
  */

package/lib/node/utils.d.ts

@@ -1,4 +1,9 @@
+import Account, { type StorageAddress, type TokenAddress } from '../account';
 import type { NodeConfig } from '.';
 export declare function getConfigFromEnv(type: 'local' | 'lambda'): Partial<Omit<NodeConfig, 'ledger'> & {
     ledger: Partial<NodeConfig['ledger']>;
 }>;
+export declare function getFeeConfigFromEnv(type: 'local' | 'lambda'): {
+    feeAccounts: (Account | StorageAddress)[];
+    feeToken: TokenAddress | undefined;
+};

package/lib/p2p.d.ts

@@ -48,6 +48,10 @@ export interface P2PConfig {
      * Forget about seen message ids after this many milliseconds
      */
     seenMessageTTL?: number;
+    /**
+     * Whether to republish over http or p2p websockets
+     */
+    useHTTPRepublish?: boolean;
 }
 /**
  * Shape of statistics
@@ -66,6 +70,7 @@ export interface P2PSwitchStatistics {
 interface P2PPeerBase {
     kind: NodeKind;
 }
+export type P2PUpdateOptions = 'http' | 'websocket';
 /**
  * Peering information for a Representative (Basic, unsigned information)
  */
@@ -82,6 +87,10 @@ interface P2PPeerRepBase extends P2PPeerBase {
      * Public key of the representative (used as the ID)
      */
     key: Account;
+    /**
+     * Prefer to receive updates over http or websocket
+     */
+    preferUpdates: P2PUpdateOptions;
 }
 /**
  * Peering information for a Representative
@@ -200,6 +209,23 @@ type JSONMessage = {
 };
 export declare function randomizeReps(reps: Representative[]): Representative[];
 export declare function formatRepEndpoints(peers: P2PPeer[]): Representative[];
+export declare class P2PHttpConnection implements P2PConnection {
+    #private;
+    abort: boolean;
+    peer: P2PPeer;
+    validatedPeer: P2PPeer | null;
+    timeout: number;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is P2PHttpConnection;
+    /**
+     * Initiate an outbound http connection and attach it to the specified switch
+     */
+    static initiate(peer: P2PPeer, p2pSwitch: P2PSwitch): Promise<P2PHttpConnection | null>;
+    constructor(peer: P2PPeer, p2pSwitch: P2PSwitch);
+    get connString(): string;
+    get peerString(): string | null;
+    send(messageBuffer: Buffer): Promise<boolean>;
+    close(): Promise<void>;
+}
 /**
  * A P2PConnection using the "ws" package
  */
@@ -275,6 +301,7 @@ export declare class P2PSwitch {
      * Our own peer information
      */
     selfPeer(): Promise<P2PPeer | null>;
+    getOutgoingGreetingInfo(): Promise<JSONSerializableObject>;
     /**
      * Receive a message from a connection
      *
@@ -299,5 +326,10 @@ export declare class P2PSwitch {
      * @returns If the message could be delivered to at least one peer
      */
     sendMessage(to: P2PConnection | Account | P2PPeer | null, id: string, type: string, data: any, ttl?: number, exclude?: (string | P2PConnection)[], skipConnectToPeers?: boolean): Promise<boolean>;
+    /**
+     * TODO - make this private after refactoring websockets to handle higher load
+     * https://github.com/KeetaNetwork/node/issues/785
+     */
+    haveAnyFilter(data: any): Promise<boolean>;
 }
 export default P2PSwitch;

package/lib/permissions.d.ts

@@ -18,7 +18,8 @@ declare enum BaseFlag {
     TOKEN_ADMIN_MODIFY_BALANCE = 7,/* 0x0080 */
     PERMISSION_DELEGATE_ADD = 11,/* 0x0800 */
     PERMISSION_DELEGATE_REMOVE = 12,/* 0x1000 */
-    MANAGE_CERTIFICATE = 13
+    MANAGE_CERTIFICATE = 13,/* 0x2000 */
+    MULTISIG_SIGNER = 14
 }
 type ExternalFlagName = `${typeof externalFlagPrefix}${string}`;
 export type BaseFlagName = keyof typeof BaseFlag;
@@ -42,7 +43,9 @@ declare enum BasePermissionGroup {
     NONIDENTIFIER = 2,
     NETWORK = 3,
     TOKEN = 4,
-    STORAGE = 5
+    STORAGE = 5,
+    NONIDENTIFIER_OR_MULTISIG = 6,
+    MULTISIG = 7
 }
 interface BaseFlagRule {
     canBeDefault: boolean;

package/lib/stats.d.ts

@@ -37,15 +37,34 @@ export type TimeStats = {
 export type DbStats = {
     retries: number;
 };
-export declare class Stats {
+export declare class StatsPending {
+    protected localDBIncr: {
+        [key: string]: number;
+    };
+    protected localDBXOR: {
+        [key: string]: bigint;
+    };
+    protected consume(): {
+        incrChanges: {
+            [key: string]: number;
+        };
+        xorChanges: {
+            [key: string]: bigint;
+        };
+    };
+    protected compoundKey(arena: string, key: string): string;
+    protected incrCompoundKey(compoundKey: string, change: number): void;
+    incr(arena: string, key: string, change?: number): void;
+    xor(key: string, change: BlockHash | BufferStorage | bigint): void;
+    merge(pending: StatsPending): void;
+}
+export declare class Stats extends StatsPending {
     #private;
     constructor(config: StatsConfig);
     static durationBreakdownList(): DurationBreakdowns[];
     static assertDurationBreakdown(duration: string): asserts duration is DurationBreakdowns;
     static durationBreakdown(duration: number): DurationBreakdowns;
     static placeholderTimingData(): TimeStats;
-    incr(arena: string, key: string, change?: number): void;
-    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']>[];

package/lib/utils/asn1.d.ts

@@ -45,6 +45,23 @@ export interface ASN1String extends ASN1Object {
     value: string;
 }
 export declare function isASN1Object(input: unknown): input is ASN1Object;
+declare function isASN1OID(input: unknown): input is ASN1OID;
+declare function isASN1String(input: unknown): input is ASN1String;
+declare function isASN1Set(input: unknown): input is ASN1Set;
+declare function isASN1ContextTag<T extends ASN1ContextTag['kind']>(input: unknown, tagKind?: T): input is Extract<ASN1ContextTag, {
+    kind: T;
+}>;
+declare function isASN1BitString(input: unknown): input is ASN1BitString;
+declare function isASN1Date(input: unknown): input is ASN1Date;
+export declare const ASN1CheckUtilities: {
+    isASN1Object: typeof isASN1Object;
+    isASN1OID: typeof isASN1OID;
+    isASN1String: typeof isASN1String;
+    isASN1Set: typeof isASN1Set;
+    isASN1ContextTag: typeof isASN1ContextTag;
+    isASN1BitString: typeof isASN1BitString;
+    isASN1Date: typeof isASN1Date;
+};
 /**
  * Validation function for {@link isValidSequenceSchema}
  */
@@ -59,7 +76,7 @@ declare function jsASN1toJS(input: ArrayBuffer): ASN1AnyJS;
 declare const ASN1toJS: typeof jsASN1toJS, JStoASN1: typeof jsJStoASN1, ASN1IntegerToBigInt: typeof jsIntegerToBigInt, ASN1BigIntToBuffer: typeof jsBigIntToBuffer;
 export declare namespace ValidateASN1 {
     export type Schema = keyof BasicSchemaMap | {
-        choice: Schema[];
+        choice: Schema[] | readonly Schema[];
     } | {
         sequenceOf: Schema;
     } | {
@@ -87,7 +104,7 @@ export declare namespace ValidateASN1 {
     } | {
         type: 'date';
         kind: 'general';
-    } | readonly [Schema, ...Schema[]];
+    } | readonly [Schema, ...Schema[]] | (() => Schema);
     type BasicSchemaMap = {
         [ValidateASN1.IsAny]: ASN1AnyJS;
         [ValidateASN1.IsUnknown]: unknown;
@@ -103,7 +120,7 @@ export declare namespace ValidateASN1 {
         [ValidateASN1.IsSet]: ASN1Set;
         [ValidateASN1.IsNull]: null;
     };
-    export type SchemaMap<T extends Schema> = T extends keyof BasicSchemaMap ? BasicSchemaMap[T] : T extends {
+    export type SchemaMap<T extends Schema> = T extends () => infer U ? U extends Schema ? SchemaMap<U> : never : T extends keyof BasicSchemaMap ? BasicSchemaMap[T] : T extends {
         choice: Schema[];
     } ? SchemaMap<T['choice'][number]> : T extends {
         choice: readonly Schema[];
@@ -113,7 +130,7 @@ export declare namespace ValidateASN1 {
         optional: Schema;
     } ? SchemaMap<T['optional']> | undefined : T extends bigint ? T : T extends {
         type: 'context';
-        kind: infer U extends 'implicit' | 'explicit';
+        kind: infer U extends ASN1ContextTag['kind'];
         value: number;
         contains: Schema;
     } ? Omit<ASN1ContextTag, 'contains' | 'value' | 'kind'> & {
@@ -163,7 +180,7 @@ export declare class ValidateASN1<T extends ValidateASN1.Schema> {
      * Given a schema, validate the ASN.1 object against it and return the
      * object as the validated type
      */
-    static againstSchema<T extends ValidateASN1.Schema>(input: ASN1AnyJS, schema: T): ValidateASN1.SchemaMap<T>;
+    static againstSchema<T extends ValidateASN1.Schema>(input: ASN1AnyJS, schemaIn: T): ValidateASN1.SchemaMap<T>;
     constructor(schema: T);
     validate(input: ASN1AnyJS): ValidateASN1.SchemaMap<T>;
 }

package/lib/utils/certificate.d.ts

@@ -44,6 +44,7 @@ type CertificateSchema = [
     signatureAlgorithm: ASN1.ASN1OID[],
     signature: ASN1.ASN1BitString
 ];
+type HashNames = 'sha256' | 'sha3-256';
 type CertificateBuilderParams = {
     /**
      * Subject for the certificate, to store as the public key within the certificate
@@ -93,15 +94,45 @@ type CertificateBuilderParams = {
     includeCommonExts?: boolean;
     /**
      * Hashing library to use
+     *
+     * Because several different things are hashed this is
+     * @deprecated Use `hashParams` instead
      */
-    hashLib: {
+    hashLib?: {
         hash: (...args: Parameters<typeof HashLib.Hash>) => ReturnType<typeof HashLib.Hash>;
         name: string;
     };
+    /**
+     * This option lets you control the hashing method used for the
+     * certificate signature as well as provide alternative implementations
+     */
+    hashParams: {
+        functions?: {
+            [name in HashNames]?: (...args: Parameters<typeof HashLib.Hash>) => ReturnType<typeof HashLib.Hash>;
+        };
+        defaults?: {
+            /**
+             * Default hashing function to use for the certificate signature
+             */
+            signature?: HashNames;
+            /**
+             * Default hashing function to use for the Subject Key Identifier
+             */
+            ski?: HashNames;
+            /**
+             * Default hashing function to use for the Authority Key Identifier
+             * (must match the issuer certificate's Subject Key Identifier
+             * hashing function)
+             */
+            aki?: HashNames;
+        };
+    };
 };
 export declare class CertificateBuilder {
     #private;
     constructor(params?: Partial<CertificateBuilderParams>);
+    private static hashName;
+    private static hash;
     /**
      * Construct an extension
      */
@@ -367,6 +398,12 @@ export declare class Certificate {
      * Get the issuer account
      */
     getIssuerAccount(): Account | null;
+    /**
+     * Get the extensions present in the certificate -- this is the raw
+     * extensions as they were parsed from the certificate, and may
+     * contain extensions that are not processed by this class.
+     */
+    getExtensions(): NonNullable<CertificateSchema[0][7]>['contains'] | undefined;
     private assertConstructed;
     /**
      * Compare the certificate with another certificate and return true if they

package/lib/utils/helper.d.ts

@@ -2,6 +2,7 @@ import _crypto from 'crypto';
 import type { JSONSerializable } from './conversion';
 export type DistributiveOmit<T, P extends PropertyKey> = T extends T ? Omit<T, P> : never;
 export declare function bufferToArrayBuffer(input: Buffer): ArrayBuffer;
+export declare function bufferToBigInt(buffer: Buffer): bigint;
 /**
  * Check if a value is an integer or a bigint.
  */
@@ -73,7 +74,7 @@ interface InstanceSet<Instance, Encoded = string> extends Set<Instance> {
  */
 export declare const AsyncDisposableStack: AsyncDisposableStackConstructor;
 export interface InstanceSetConstructor<Instance, Encoded = string> {
-    new (data?: (Instance)[]): InstanceSet<Instance, Encoded>;
+    new (data?: Iterable<(Instance)>): InstanceSet<Instance, Encoded>;
 }
 export declare function setGenerator<P extends WithIsInstance<Instance>, E extends EncodeFunc<Instance, Encoded>, D extends DecodeFunc<Instance, Encoded>, Instance = InstanceType<P>, Encoded = ReturnType<E>>(parent: P, rawEncode: E, rawDecode: D): InstanceSetConstructor<Instance, Encoded>;
 export declare const crypto: {

package/lib/utils/static-types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utility types for static type checking
+ */
+/**
+ * Expects a type to be true, otherwise raises a type error.
+ */
+export type Expect<T extends true> = T;
+/**
+ * Checks if two types are equal.
+ */
+export type Equal<A, B> = A extends B ? (B extends A ? true : false) : false;