@keetanetwork/keetanet-client 0.16.0 → 0.16.2

package/lib/error/vote.d.ts

@@ -1,6 +1,6 @@
 import { KeetaNetErrorBase } from './base';
-export 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", "FEE_IS_QUOTE", "FEE_QUOTE_MISSING_FEES", "FEE_NOT_QUOTE", "MALFORMED_FEES_KIND_MISSING", "MALFORMED_FEES_QUOTE_INVALID"];
-export declare const FullVoteErrorCodes: ("VOTE_INVALID_VERSION" | "VOTE_SERIAL_MISMATCH" | "VOTE_INVALID_CONSTRUCTION" | "VOTE_INVALID_CONSTRUCTION_JSON" | "VOTE_SIGNATURE_INVALID" | "VOTE_EXPIRED" | "VOTE_INVALID_VALIDITY" | "VOTE_MOMENT_BEFORE_VALIDITY_FROM" | "VOTE_STAPLE_INVALID_CONSTRUCTION" | "VOTE_STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_COUNT" | "VOTE_STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_MISSING" | "VOTE_STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_ORDER" | "VOTE_STAPLE_DUPLICATE_VOTE_ISSUER" | "VOTE_STAPLE_PERMANENCE_MISMATCH" | "VOTE_BUILDER_INVALID_CONSTRUCTION" | "VOTE_BUILDER_INVALID_BLOCK_TYPE" | "VOTE_BUILDER_INVALID_SERIAL" | "VOTE_BUILDER_INVALID_VALID_TO_FROM" | "VOTE_MALFORMED_WRAPPER" | "VOTE_MALFORMED_VOTE_WRAPPER" | "VOTE_MALFORMED_VOTE_CONTENT" | "VOTE_MALFORMED_VOTE_CONTENT_EXTRA_DATA" | "VOTE_MALFORMED_VOTE_VERSION" | "VOTE_MALFORMED_VOTE_SERIAL" | "VOTE_MALFORMED_VOTE_SIGNATURE_INFORMATION" | "VOTE_MALFORMED_VOTE_ISSUER_INFORMATION" | "VOTE_MALFORMED_VOTE_SUBJECT_INFORMATION" | "VOTE_MALFORMED_VOTE_VALIDITY_INFORMATION" | "VOTE_MALFORMED_VOTE_EXTENSIONS" | "VOTE_MALFORMED_VOTE_EXTENSIONS_DATA" | "VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE" | "VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE_OID" | "VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL" | "VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE" | "VOTE_MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER" | "VOTE_MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER" | "VOTE_MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE" | "VOTE_MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME" | "VOTE_MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION" | "VOTE_MALFORMED_VOTE_SIGNATURE_VALUE" | "VOTE_MALFORMED_VOTE_NO_BLOCKS_FOUND" | "VOTE_MALFORMED_STAPLE" | "VOTE_MALFORMED_STAPLE_BLOCKS" | "VOTE_MALFORMED_STAPLE_BLOCKS_AT_LEAST_ONE" | "VOTE_MALFORMED_STAPLE_VOTES" | "VOTE_MALFORMED_STAPLE_VOTES_AT_LEAST_ONE" | "VOTE_MALFORMED_FIND_RDN_INVALID_TYPE" | "VOTE_MALFORMED_FIND_RDN_MUST_HAVE_ONE" | "VOTE_MALFORMED_FIND_RDN_PART_WELL_FORMED" | "VOTE_MALFORMED_FIND_RDN_MUST_BE_SET" | "VOTE_MALFORMED_FIND_RDN_TYPE_MUST_BE_OID" | "VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT" | "VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE" | "VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE" | "VOTE_MALFORMED_FEES_AMOUNT" | "VOTE_MALFORMED_FEES_FROM_VOTE_INVALID_INPUT" | "VOTE_MALFORMED_FEES_IN_PERMANENT_VOTE" | "VOTE_MALFORMED_FEES_PAY_TO_INVALID" | "VOTE_MALFORMED_FEES_TOKEN_NOT_TOKEN" | "VOTE_FEE_IS_QUOTE" | "VOTE_FEE_QUOTE_MISSING_FEES" | "VOTE_FEE_NOT_QUOTE" | "VOTE_MALFORMED_FEES_KIND_MISSING" | "VOTE_MALFORMED_FEES_QUOTE_INVALID")[];
+export 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", "BUILDER_INVALID_FEE", "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_INVALID_QUOTE_VALUE", "MALFORMED_FEES_MULTIPLE_FEE_EMPTY", "MALFORMED_FEES_PAY_TO_INVALID", "MALFORMED_FEES_TOKEN_NOT_TOKEN", "FEE_IS_QUOTE", "FEE_QUOTE_MISSING_FEES", "FEE_NOT_QUOTE", "MALFORMED_FEES_KIND_MISSING", "MALFORMED_FEES_QUOTE_INVALID"];
+export declare const FullVoteErrorCodes: ("VOTE_INVALID_CONSTRUCTION" | "VOTE_INVALID_VERSION" | "VOTE_SERIAL_MISMATCH" | "VOTE_INVALID_CONSTRUCTION_JSON" | "VOTE_SIGNATURE_INVALID" | "VOTE_EXPIRED" | "VOTE_INVALID_VALIDITY" | "VOTE_MOMENT_BEFORE_VALIDITY_FROM" | "VOTE_STAPLE_INVALID_CONSTRUCTION" | "VOTE_STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_COUNT" | "VOTE_STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_MISSING" | "VOTE_STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_ORDER" | "VOTE_STAPLE_DUPLICATE_VOTE_ISSUER" | "VOTE_STAPLE_PERMANENCE_MISMATCH" | "VOTE_BUILDER_INVALID_CONSTRUCTION" | "VOTE_BUILDER_INVALID_BLOCK_TYPE" | "VOTE_BUILDER_INVALID_SERIAL" | "VOTE_BUILDER_INVALID_VALID_TO_FROM" | "VOTE_BUILDER_INVALID_FEE" | "VOTE_MALFORMED_WRAPPER" | "VOTE_MALFORMED_VOTE_WRAPPER" | "VOTE_MALFORMED_VOTE_CONTENT" | "VOTE_MALFORMED_VOTE_CONTENT_EXTRA_DATA" | "VOTE_MALFORMED_VOTE_VERSION" | "VOTE_MALFORMED_VOTE_SERIAL" | "VOTE_MALFORMED_VOTE_SIGNATURE_INFORMATION" | "VOTE_MALFORMED_VOTE_ISSUER_INFORMATION" | "VOTE_MALFORMED_VOTE_SUBJECT_INFORMATION" | "VOTE_MALFORMED_VOTE_VALIDITY_INFORMATION" | "VOTE_MALFORMED_VOTE_EXTENSIONS" | "VOTE_MALFORMED_VOTE_EXTENSIONS_DATA" | "VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE" | "VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE_OID" | "VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL" | "VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE" | "VOTE_MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER" | "VOTE_MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER" | "VOTE_MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE" | "VOTE_MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME" | "VOTE_MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION" | "VOTE_MALFORMED_VOTE_SIGNATURE_VALUE" | "VOTE_MALFORMED_VOTE_NO_BLOCKS_FOUND" | "VOTE_MALFORMED_STAPLE" | "VOTE_MALFORMED_STAPLE_BLOCKS" | "VOTE_MALFORMED_STAPLE_BLOCKS_AT_LEAST_ONE" | "VOTE_MALFORMED_STAPLE_VOTES" | "VOTE_MALFORMED_STAPLE_VOTES_AT_LEAST_ONE" | "VOTE_MALFORMED_FIND_RDN_INVALID_TYPE" | "VOTE_MALFORMED_FIND_RDN_MUST_HAVE_ONE" | "VOTE_MALFORMED_FIND_RDN_PART_WELL_FORMED" | "VOTE_MALFORMED_FIND_RDN_MUST_BE_SET" | "VOTE_MALFORMED_FIND_RDN_TYPE_MUST_BE_OID" | "VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT" | "VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE" | "VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE" | "VOTE_MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE" | "VOTE_MALFORMED_FEES_AMOUNT" | "VOTE_MALFORMED_FEES_FROM_VOTE_INVALID_INPUT" | "VOTE_MALFORMED_FEES_IN_PERMANENT_VOTE" | "VOTE_MALFORMED_FEES_INVALID_QUOTE_VALUE" | "VOTE_MALFORMED_FEES_MULTIPLE_FEE_EMPTY" | "VOTE_MALFORMED_FEES_PAY_TO_INVALID" | "VOTE_MALFORMED_FEES_TOKEN_NOT_TOKEN" | "VOTE_FEE_IS_QUOTE" | "VOTE_FEE_QUOTE_MISSING_FEES" | "VOTE_FEE_NOT_QUOTE" | "VOTE_MALFORMED_FEES_KIND_MISSING" | "VOTE_MALFORMED_FEES_QUOTE_INVALID")[];
 export type VoteErrorCode = typeof FullVoteErrorCodes[number];
 export default class KeetaNetVoteError extends KeetaNetErrorBase<VoteErrorCode> {
     static readonly isInstance: (obj: any, strict?: boolean) => obj is KeetaNetVoteError;

package/lib/index.d.ts

@@ -11,6 +11,7 @@ import { KeetaNetError as Error } from './error';
 import * as ASN1 from './utils/asn1';
 import * as Bloom from './utils/bloom';
 import * as Buffer from './utils/buffer';
+import * as DomainSeparation from './utils/domain-separation';
 import * as Hash from './utils/hash';
 import * as Helper from './utils/helper';
 import * as Initial from './utils/initial';
@@ -35,11 +36,12 @@ declare const _default: {
         ASN1: typeof ASN1;
         Bloom: typeof Bloom;
         Buffer: typeof Buffer;
+        Certificate: typeof Certificate;
+        Conversion: typeof Conversion;
+        DomainSeparation: typeof DomainSeparation;
         Hash: typeof Hash;
         Helper: typeof Helper;
         Initial: typeof Initial;
-        Conversion: typeof Conversion;
-        Certificate: typeof Certificate;
     };
 };
 export default _default;

package/lib/ledger/common.d.ts

@@ -1,10 +1,10 @@
 import type { VoteStaple } from '../vote';
 import type Vote from '../vote';
 import type { GenericAccount, TokenAddress } from '../account';
-import Account from '../account';
+import Account, { AccountKeyAlgorithm } from '../account';
 import { Block, BlockHash } from '../block';
 import type { LedgerConfig, LedgerSelector, LedgerStorage, LedgerStorageAPI } from '.';
-import type { AccountInfo, ACLRow, ACLEntry, ACLUpdate } from './types';
+import type { AccountInfo, ACLRow, ACLEntry, ACLUpdate, AccountInfoForType } from './types';
 import type Node from '../node';
 import type Stats from '../stats';
 import type { BaseSet, ExternalSet } from '../permissions';
@@ -62,6 +62,18 @@ export declare function validateNumericValue(value: bigint, block: Pick<Block, '
 }): void;
 export declare function validateBlockSignerCount(amount: bigint, network: bigint): void;
 export declare function validateBlockSignerDepth(depth: bigint, network: bigint): void;
+/**
+ * Determines if an account type can delegate voting weight via SET_REP.
+ *
+ * Regular accounts (ECDSA_SECP256K1, ED25519, ECDSA_SECP256R1) can always delegate.
+ * Among identifier accounts, only STORAGE accounts can delegate.
+ * TOKEN, NETWORK, and MULTISIG identifier accounts cannot delegate.
+ *
+ * @param keyType - The account key algorithm type to check
+ * @returns true if the account type can use SET_REP to delegate, false otherwise
+ *
+ */
+export declare function canDelegate(keyType: AccountKeyAlgorithm): boolean;
 /**
  * Compute effects on the ledger from block effects
  */
@@ -129,7 +141,7 @@ export declare abstract class LedgerStorageBase {
     preAdjust(input: VoteStaple, mayDefer?: boolean, transaction?: any): Promise<{
         [hash: string]: bigint;
     }>;
-    _formatAccountInfoFromRow(account: GenericAccount, row?: AccountInfoUnparsedRow | undefined): AccountInfo;
+    _formatAccountInfoFromRow<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(account: Account<T>, row: AccountInfoUnparsedRow | undefined): AccountInfoForType<T>;
     _validateAccountInfoKeys(account: GenericAccount, info: Partial<AccountInfo>): void;
     /**
      * @param moment - The date to use as the base for the timestamp.

package/lib/ledger/db_dynamodb.d.ts

@@ -2,10 +2,10 @@ import { VoteStaple, Vote } from '../vote';
 import { Block, BlockHash } from '../block';
 import type { VoteBlockHash, VoteBlockHashMap } from '../vote';
 import type { GenericAccount, IdentifierAddress, TokenAddress } from '../account';
-import Account from '../account';
+import Account, { AccountKeyAlgorithm } from '../account';
 import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions, IdempotentKey } from '../ledger';
 import { LedgerStorageTransactionBase } from '../ledger';
-import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
+import type { ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates, AccountInfoForType } from './types';
 import { LedgerStorageBase } from './common';
 import type { ComputedEffectOfBlocks } from './effects';
 import type { CertificateHash } from '../utils/certificate';
@@ -50,8 +50,8 @@ declare class DynamoDBTransaction extends LedgerStorageTransactionBase {
     getHeadBlocks(accounts: GenericAccount[], from: LedgerSelector): Promise<{
         [publicKey: string]: Block | null;
     }>;
-    getAccountRep(userAccount: Account | string): Promise<Account | null>;
-    getAccountInfo(account: GenericAccount | string): Promise<AccountInfo>;
+    getAccountRep(userAccount: GenericAccount | string): Promise<Account | null>;
+    getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(account: Account<T> | string): Promise<AccountInfoForType<T>>;
     listOwners(identifier: IdentifierAddress): Promise<Account[]>;
     listACLsByEntity(entity: GenericAccount): Promise<ACLRow[]>;
     listACLsByPrincipal(principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
@@ -90,8 +90,8 @@ export declare class DBDynamoDB extends LedgerStorageBase implements LedgerStora
     getHeadBlocks(transaction: DynamoDBTransaction, accounts: GenericAccount[], from: LedgerSelector): Promise<{
         [publicKey: string]: Block | null;
     }>;
-    getAccountRep(transaction: DynamoDBTransaction, account: Account | string): Promise<Account | null>;
-    getAccountInfo(transaction: DynamoDBTransaction, account: GenericAccount | string): Promise<AccountInfo>;
+    getAccountRep(transaction: DynamoDBTransaction, account: GenericAccount | string): Promise<Account | null>;
+    getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(transaction: DynamoDBTransaction, account: Account<T> | string): Promise<AccountInfoForType<T>>;
     listOwners(transaction: DynamoDBTransaction, identifier: IdentifierAddress): Promise<Account[]>;
     listACLsByPrincipal(transaction: DynamoDBTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
     listACLsByEntity(transaction: DynamoDBTransaction, entity: GenericAccount): Promise<ACLRow[]>;

package/lib/ledger/db_postgres.d.ts

@@ -5,7 +5,7 @@ import type { GenericAccount, IdentifierAddress, TokenAddress } from '../account
 import Account, { AccountKeyAlgorithm } from '../account';
 import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions } from '../ledger';
 import { IdempotentKey, LedgerStorageTransactionBase } from '../ledger';
-import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
+import type { ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates, AccountInfoForType } from './types';
 import { LedgerStorageBase } from './common';
 import type { PoolClient as PostgresPoolClient } from 'pg';
 import { Pool as PostgresPool } from 'pg';
@@ -35,7 +35,7 @@ export declare class DBPostgres extends LedgerStorageBase implements LedgerStora
     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>;
-    getAccountRep(transaction: PostgresTransaction, userAccount: Account | string): Promise<Account | null>;
+    getAccountRep(transaction: PostgresTransaction, userAccount: GenericAccount | string): Promise<Account | null>;
     /**
      * If an adjustment cannot be made right now, defer it for follow-up
      */
@@ -43,7 +43,7 @@ export declare class DBPostgres extends LedgerStorageBase implements LedgerStora
     listOwners(transaction: PostgresTransaction, entity: IdentifierAddress): Promise<Account<AccountKeyAlgorithm.TOKEN>[]>;
     listACLsByEntity(transaction: PostgresTransaction, entity: GenericAccount): Promise<ACLRow[]>;
     listACLsByPrincipal(transaction: PostgresTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
-    getAccountInfo(transaction: PostgresTransaction, account: GenericAccount | string): Promise<AccountInfo>;
+    getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(transaction: PostgresTransaction, account: Account<T> | string): Promise<AccountInfoForType<T>>;
     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<bigint | null>;

package/lib/ledger/db_spanner.d.ts

@@ -3,10 +3,10 @@ import type { Block } from '../block';
 import { BlockHash } from '../block';
 import type { VoteBlockHash, VoteBlockHashMap } from '../vote';
 import type { GenericAccount, IdentifierAddress, TokenAddress } from '../account';
-import Account from '../account';
+import Account, { AccountKeyAlgorithm } from '../account';
 import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions } from '../ledger';
 import { IdempotentKey, LedgerStorageTransactionBase } from '../ledger';
-import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
+import type { ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates, AccountInfoForType } from './types';
 import type { KVStorageProviderAPI } from '../kv';
 import { LedgerStorageBase } from './common';
 import type { Database as GoogleSpannerDatabase } from '@google-cloud/spanner';
@@ -70,7 +70,7 @@ export declare class DBSpanner extends LedgerStorageBase implements LedgerStorag
     getBalance(transaction: SpannerTransaction, account: GenericAccount | string, token: TokenAddress | string): Promise<bigint>;
     getAllBalances(transaction: SpannerTransaction, account: GenericAccount): Promise<GetAllBalancesResponse>;
     addPendingVote(transaction: SpannerTransaction, votesAndBlocks: VoteStaple): Promise<void>;
-    getAccountRep(transaction: SpannerTransaction, userAccount: Account | string): Promise<Account | null>;
+    getAccountRep(transaction: SpannerTransaction, userAccount: GenericAccount | string): Promise<Account | null>;
     /**
      * If an adjustment cannot be made right now, defer it for follow-up
      */
@@ -97,7 +97,7 @@ export declare class DBSpanner extends LedgerStorageBase implements LedgerStorag
     getHeadBlocks(transaction: SpannerTransaction, accounts: GenericAccount[], from: LedgerSelector): Promise<{
         [publicKey: string]: Block | null;
     }>;
-    getAccountInfo(transaction: SpannerTransaction, account: GenericAccount | string): Promise<AccountInfo>;
+    getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(transaction: SpannerTransaction, account: Account<T> | string): Promise<AccountInfoForType<T>>;
     listOwners(transaction: SpannerTransaction, entity: IdentifierAddress): Promise<GenericAccount[]>;
     listACLsByEntity(transaction: SpannerTransaction, entity: GenericAccount): Promise<ACLRow[]>;
     listACLsByPrincipal(transaction: SpannerTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;

package/lib/ledger/db_spanner_helper.d.ts

@@ -15,7 +15,7 @@ declare const ColumnTypes: {
         readonly toComparable: (name: string) => string;
     };
     readonly ACCOUNT: {
-        readonly fromSpanner: (pubKey: string) => Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1>;
+        readonly fromSpanner: (pubKey: string) => Account<import("../account").KeyPairKeyAlgorithm>;
         readonly toSpanner: (account: Account) => import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
         readonly dbType: string;
         readonly dbSize: number;
@@ -304,7 +304,7 @@ declare const schema: {
     readonly delegation: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly account: ColumnInterface<"ACCOUNT", false>;
+            readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
             readonly delegatedToRep: ColumnInterface<"ACCOUNT", false>;
         };
         readonly key: readonly [Key];

package/lib/ledger/db_sqlite.d.ts

@@ -6,7 +6,7 @@ import type { GenericAccount, IdentifierAddress, TokenAddress } from '../account
 import Account, { AccountKeyAlgorithm } from '../account';
 import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions } from '../ledger';
 import { IdempotentKey, LedgerStorageTransactionBase } from '../ledger';
-import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
+import type { ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates, AccountInfoForType } from './types';
 import { LedgerStorageBase } from './common';
 import * as sqlite from 'sqlite';
 import type { ComputedEffectOfBlocks } from './effects';
@@ -34,7 +34,7 @@ export declare class DBSqlite extends LedgerStorageBase implements LedgerStorage
     getBalance(transaction: DBSqliteTransaction, account: GenericAccount, token: TokenAddress): Promise<bigint>;
     getAllBalances(transaction: DBSqliteTransaction, account: GenericAccount): Promise<GetAllBalancesResponse>;
     addPendingVote(transaction: DBSqliteTransaction, votesAndBlocks: VoteStaple): Promise<void>;
-    getAccountRep(transaction: DBSqliteTransaction, userAccount: Account | string): Promise<Account | null>;
+    getAccountRep(transaction: DBSqliteTransaction, userAccount: GenericAccount | string): Promise<Account | null>;
     /**
      * If an adjustment cannot be made right now, defer it for follow-up
      */
@@ -42,7 +42,7 @@ export declare class DBSqlite extends LedgerStorageBase implements LedgerStorage
     listOwners(transaction: DBSqliteTransaction, entity: IdentifierAddress): Promise<Account<AccountKeyAlgorithm.TOKEN>[]>;
     listACLsByEntity(transaction: DBSqliteTransaction, entity: GenericAccount): Promise<ACLRow[]>;
     listACLsByPrincipal(transaction: DBSqliteTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
-    getAccountInfo(transaction: DBSqliteTransaction, account: GenericAccount | string): Promise<AccountInfo>;
+    getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(transaction: DBSqliteTransaction, account: Account<T> | string): Promise<AccountInfoForType<T>>;
     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>;

package/lib/ledger/effects.d.ts

@@ -3,9 +3,10 @@ import Account from '../account';
 import type { AdjustMethod } from '../block';
 import { Block } from '../block';
 import type * as Operations from '../block/operations';
-import type { UserEditableAccountInfo, ACLEntry, ACLUpdate } from '../ledger/types';
+import type { ACLEntry, ACLUpdate, AccountInfo } from '../ledger/types';
 import type { Certificate, CertificateBundle } from '../utils/certificate';
 import { CertificateHash } from '../utils/certificate';
+import type { DistributiveOmit } from '../utils/helper';
 interface NumericValueEntry {
     value: bigint;
 }
@@ -49,6 +50,7 @@ interface CreateIdentifierRequest {
 type DelegationUpdate = {
     delegateTo: Account;
 };
+type UserEditableAccountInfo = DistributiveOmit<AccountInfo, 'supply' | 'account'>;
 interface ComputedBlocksEffectFields {
     balance?: ComputedBlocksEffectTokenChangesField;
     supply?: NumericValueEntry[];

package/lib/ledger/index.d.ts

@@ -1,12 +1,12 @@
 import { VoteStaple, Vote, VoteBlockHashMap } from '../vote';
 import { Block, BlockHash } from '../block';
 import type { FeeAmountAndToken, VoteBlockHash, VoteQuote } from '../vote';
-import type { GenericAccount, IdentifierAddress, NetworkAddress, StorageAddress, TokenAddress } from '../account';
+import type { AccountKeyAlgorithm, GenericAccount, IdentifierAddress, NetworkAddress, StorageAddress, TokenAddress } from '../account';
 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, CertificateWithIntermediates } from './types';
+import type { ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates, AccountInfoForType } from './types';
 import LedgerRequestCache from './cache';
 import type { Logger } from '../log';
 import type { CertificateHash } from '../utils/certificate';
@@ -37,7 +37,7 @@ export interface LedgerConfig {
     /**
      * Provided function to compute fees for a given set of Blocks and computed effects
      */
-    computeFeeFromBlocks: (ledger: Ledger, blocks: Block[], effects: ComputedEffectOfBlocks) => FeeAmountAndToken | null;
+    computeFeeFromBlocks: (ledger: Ledger, blocks: Block[], effects: ComputedEffectOfBlocks) => FeeAmountAndToken | FeeAmountAndToken[] | null;
     /**
      * Storage mechanism
      */
@@ -189,7 +189,7 @@ export interface LedgerStorageAPI {
      * If token account, return supply
      * If non user account, returns default permissions
      */
-    getAccountInfo: (transaction: any, account: GenericAccount | string) => Promise<AccountInfo>;
+    getAccountInfo: <T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(transaction: any, account: Account<T> | string) => Promise<AccountInfoForType<T>>;
     /**
      * List all owners of an account
      */
@@ -285,7 +285,7 @@ export interface LedgerStorageAPI {
     /**
      * Get the Account Representative
      */
-    getAccountRep: (transaction: any, account: Account | string) => Promise<Account | null>;
+    getAccountRep: (transaction: any, account: GenericAccount | string) => Promise<Account | null>;
     /**
      * Get Votes after a specific moment
      */
@@ -350,8 +350,8 @@ declare class LedgerAtomicInterface {
         [account: string]: Block | null;
     }>;
     getHeadBlock(account: GenericAccount, from: LedgerSelector): Promise<Block | null>;
-    getAccountRep(account: Account | string): Promise<Account | null>;
-    getAccountInfo(account: GenericAccount | string): Promise<AccountInfo>;
+    getAccountRep(account: GenericAccount | string): Promise<Account | null>;
+    getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(account: Account<T> | string): Promise<AccountInfoForType<T>>;
     getBlock(blockhash: BlockHash, from?: LedgerSelector): Promise<Block | null>;
     getAccountsBlockHeightInfo(toFetch: {
         account: GenericAccount;
@@ -368,7 +368,7 @@ declare class LedgerAtomicInterface {
     getStaplesFromBlockHashes(hashes: BlockHash[]): Promise<VoteStaple[]>;
     getVoteStaplesAfter(moment: Date, limit?: number, options?: GetVotesAfterOptions): Promise<VoteStaple[]>;
     gc(timeLimitMS?: number): Promise<boolean>;
-    getFee(blocks: Block[], effectsInput?: ComputedEffectOfBlocks): Promise<FeeAmountAndToken | null>;
+    getFee(blocks: Block[], effectsInput?: ComputedEffectOfBlocks): Promise<FeeAmountAndToken | FeeAmountAndToken[] | null>;
     getIdempotentBlockHash(account: GenericAccount, idempotent: string | Buffer, from?: LedgerSelector, excludeBlockHash?: BlockHash): Promise<BlockHash | null>;
     getBlockFromIdempotent(account: GenericAccount, idempotent: string | Buffer, from?: LedgerSelector, excludeBlockHash?: BlockHash): Promise<Block | null>;
     _testingRunStorageFunction<T>(code: (storage: LedgerStorageAPI, transaction: LedgerStorageTransactionBase) => Promise<T>): Promise<T>;
@@ -414,7 +414,7 @@ export declare class Ledger implements Omit<LedgerAtomicInterface, 'commit' | 'a
     getHeadBlocks(...args: Parameters<LedgerAtomicInterface['getHeadBlocks']>): ReturnType<LedgerAtomicInterface['getHeadBlocks']>;
     getHeadBlock(...args: Parameters<LedgerAtomicInterface['getHeadBlock']>): ReturnType<LedgerAtomicInterface['getHeadBlock']>;
     getAccountRep(...args: Parameters<LedgerAtomicInterface['getAccountRep']>): ReturnType<LedgerAtomicInterface['getAccountRep']>;
-    getAccountInfo(...args: Parameters<LedgerAtomicInterface['getAccountInfo']>): ReturnType<LedgerAtomicInterface['getAccountInfo']>;
+    getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(account: Account<T> | string): Promise<AccountInfoForType<T>>;
     getBlock(...args: Parameters<LedgerAtomicInterface['getBlock']>): ReturnType<LedgerAtomicInterface['getBlock']>;
     getAccountsBlockHeightInfo(...args: Parameters<LedgerAtomicInterface['getAccountsBlockHeightInfo']>): ReturnType<LedgerAtomicInterface['getAccountsBlockHeightInfo']>;
     getVoteStaple(...args: Parameters<LedgerAtomicInterface['getVoteStaple']>): ReturnType<LedgerAtomicInterface['getVoteStaple']>;

package/lib/ledger/types.d.ts

@@ -1,8 +1,9 @@
-import type { Account, GenericAccount, MultisigAddress, TokenAddress } from '../account';
+import type { Account, AccountKeyAlgorithm, GenericAccount, IdentifierKeyAlgorithm, 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';
+import type { DistributiveOmit } from '../utils/helper';
 export interface MultisigConfig {
     signers: (Account | MultisigAddress)[];
     quorum: bigint;
@@ -10,7 +11,11 @@ export interface MultisigConfig {
 /**
  * Account info entry
  */
-export interface AccountInfo {
+interface BaseAccountInfo<KeyType extends AccountKeyAlgorithm> {
+    /**
+     * The account that this info is for
+     */
+    account: Account<KeyType>;
     /**
      * A name for the account
      */
@@ -23,20 +28,48 @@ export interface AccountInfo {
      * Arbitrary metadata for the account
      */
     metadata: string;
-    /**
-     * If the account is a token, the supply of the token
-     */
-    supply?: bigint;
+}
+interface BaseIdentifierAccountInfo<KeyType extends IdentifierKeyAlgorithm> extends BaseAccountInfo<KeyType> {
     /**
      * The default permissions for the account
      */
     defaultPermission?: Permissions;
+}
+interface ECDSA_SECP256K1AccountInfo extends BaseAccountInfo<AccountKeyAlgorithm.ECDSA_SECP256K1> {
+}
+interface ECDSA_SECP256R1AccountInfo extends BaseAccountInfo<AccountKeyAlgorithm.ECDSA_SECP256R1> {
+}
+interface ED25519AccountInfo extends BaseAccountInfo<AccountKeyAlgorithm.ED25519> {
+}
+type KeyPairAccountInfo = ECDSA_SECP256K1AccountInfo | ECDSA_SECP256R1AccountInfo | ED25519AccountInfo;
+interface TokenAccountInfo extends BaseIdentifierAccountInfo<AccountKeyAlgorithm.TOKEN> {
     /**
-     * If this is a multisig account, the number of signers required
+     * The current supply of the token
      */
-    multisigQuorum?: bigint;
+    supply: bigint;
+}
+interface MultisigAccountInfo extends BaseIdentifierAccountInfo<AccountKeyAlgorithm.MULTISIG> {
+    /**
+     * The number of signers required for this multisig
+     */
+    multisigQuorum: bigint | null;
+}
+interface NetworkAccountInfo extends BaseIdentifierAccountInfo<AccountKeyAlgorithm.NETWORK> {
+}
+interface StorageAccountInfo extends BaseIdentifierAccountInfo<AccountKeyAlgorithm.STORAGE> {
 }
-export type UserEditableAccountInfo = Omit<AccountInfo, 'supply'>;
+export type AccountInfo = KeyPairAccountInfo | TokenAccountInfo | MultisigAccountInfo | StorageAccountInfo | NetworkAccountInfo;
+export type AccountInfoWithoutAccount = DistributiveOmit<AccountInfo, 'account'>;
+export type AccountInfoForType<T extends AccountKeyAlgorithm> = Extract<AccountInfo, {
+    account: Account<T>;
+}>;
+export declare function isIdentifierAccountInfo(info: AccountInfo): info is Extract<AccountInfo, {
+    account: Account<IdentifierKeyAlgorithm>;
+}>;
+export declare function isKeyPairAccountInfo(info: AccountInfo): info is KeyPairAccountInfo;
+export declare function isAccountInfoOfType<T extends AccountKeyAlgorithm>(info: AccountInfo, type: T): info is Extract<AccountInfo, {
+    account: Account<T>;
+}>;
 /**
  * Permissions types
  */
@@ -114,3 +147,4 @@ export interface CertificateWithIntermediates {
     certificate: Certificate;
     intermediates: CertificateBundle | null;
 }
+export {};

package/lib/log/target_gcp.js

@@ -586,6 +586,9 @@ function convertSingleValue(value, opts = {}) {
     return (checkPrefix(out, prefix, opts));
 }
 function toJSONSerializable(data, opts) {
+    if (data === undefined) {
+        throw (new Error('undefined is not JSON serializable'));
+    }
     return (JSON.parse(JSON.stringify(convertSingleValue(data, opts))));
 }
 function objectToBuffer(data, opts = {}) {

package/lib/log/target_https.js

@@ -5659,6 +5659,10 @@ function assertNever(value) {
   // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
   throw new Error(`Unexpected value: ${value}`);
 }
+
+/**
+ * Asserts that the provided type is never.
+ */
 ;// ./src/lib/log/target_console.ts
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
@@ -5786,6 +5790,9 @@ function convertSingleValue(value) {
   return checkPrefix(out, prefix, opts);
 }
 function toJSONSerializable(data, opts) {
+  if (data === undefined) {
+    throw new Error('undefined is not JSON serializable');
+  }
   return JSON.parse(JSON.stringify(convertSingleValue(data, opts)));
 }
 function objectToBuffer(data) {

package/lib/utils/certificate.d.ts

@@ -462,24 +462,12 @@ export declare class Certificate {
      * Get a JSON representation of the certificate
      */
     toJSON(options?: ToJSONSerializableOptions, includeChain?: boolean): {
-        $binary?: string | undefined;
-        $chain?: undefined;
         serial: string;
         notBefore: string;
         notAfter: string;
         subject: string;
         issuer: string;
         subjectPublicKey: import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
-        baseExtensions: {
-            basicConstraints?: [ca: boolean, pathLenConstraint?: string | undefined] | undefined;
-            keyUsage?: KeyUsage | undefined;
-            subjectKeyIdentifier?: string | undefined;
-            authorityKeyIdentifier?: {
-                type: "context";
-                value: 0;
-                contains: string;
-            } | undefined;
-        } | undefined;
         subjectDN: {
             name: string;
             value: string;
@@ -489,6 +477,19 @@ export declare class Certificate {
             value: string;
         }[];
         $hash: CertificateHashString;
+    } & {
+        $binary?: string | undefined;
+        $chain?: undefined;
+        baseExtensions?: ({} & {
+            basicConstraints?: [ca: boolean, pathLenConstraint?: string | null | undefined] | undefined;
+            keyUsage?: KeyUsage | undefined;
+            subjectKeyIdentifier?: string | undefined;
+            authorityKeyIdentifier?: ({
+                type: "context";
+                value: 0;
+                contains: string;
+            } & {}) | undefined;
+        }) | undefined;
     };
 }
 export {};

package/lib/utils/conversion.d.ts

@@ -15,13 +15,22 @@ type AddBinaryIfIncluded<I> = I extends {
 } : I;
 type IsTuple<T> = T extends readonly any[] ? number extends T['length'] ? false : true : false;
 type JSONDepthLimit = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-export type ToJSONSerializable<T, Options extends ToJSONSerializableOptions = ToJSONSerializableOptions, Depth extends number = 10> = T extends never ? never : Depth extends never ? never : T extends JSONSerializable ? T : T extends undefined ? undefined : T extends bigint ? string : T extends Date ? string : T extends Buffer | ArrayBuffer ? string : T extends {
+export type ToJSONSerializable<T, Options extends ToJSONSerializableOptions = ToJSONSerializableOptions, Depth extends number = 10> = T extends never ? never : Depth extends never ? never : symbol extends keyof T ? {
+    [key: symbol]: never;
+} : T extends JSONSerializable ? T : T extends undefined ? never : T extends bigint ? string : T extends Date ? string : T extends Buffer | ArrayBuffer ? string : T extends {
     toJSON(): infer U;
 } ? Options['addBinary'] extends true ? ToJSONSerializable<AddBinaryIfIncluded<U>, Options, JSONDepthLimit[Depth]> : ToJSONSerializable<U, Options, JSONDepthLimit[Depth]> : IsTuple<T> extends true ? {
+    [K in keyof T]: undefined extends T[K] ? ToJSONSerializable<Exclude<T[K], undefined>, Options, JSONDepthLimit[Depth]> | null : ToJSONSerializable<T[K], Options, JSONDepthLimit[Depth]>;
+} : T extends readonly (infer U)[] ? Array<undefined extends U ? ToJSONSerializable<Exclude<U, undefined>, Options, JSONDepthLimit[Depth]> | null : ToJSONSerializable<U, Options, JSONDepthLimit[Depth]>> : T extends object ? (string extends keyof T ? {
     [K in keyof T]: ToJSONSerializable<T[K], Options, JSONDepthLimit[Depth]>;
-} : T extends readonly (infer U)[] ? ToJSONSerializable<U, Options, JSONDepthLimit[Depth]>[] : T extends object ? {
+} : number extends keyof T ? {
     [K in keyof T]: ToJSONSerializable<T[K], Options, JSONDepthLimit[Depth]>;
-} : never;
+} : // number index signature type
+{
+    [K in keyof T as ({} extends Pick<T, K> ? never : undefined extends T[K] ? never : K)]: ToJSONSerializable<T[K], Options, JSONDepthLimit[Depth]>;
+} & {
+    [K in keyof T as ({} extends Pick<T, K> ? K : undefined extends T[K] ? K : never)]?: ToJSONSerializable<Exclude<T[K], undefined>, Options, JSONDepthLimit[Depth]>;
+}) : never;
 export declare function toJSONSerializable<Value = never, Options extends ToJSONSerializableOptions = ToJSONSerializableOptions>(data: Value, opts?: Options): ToJSONSerializable<Value, Options>;
 export declare function objectToBuffer(data: any, opts?: ToJSONSerializableOptions): Buffer;
 export declare function parseHexBigIntString(input: string): bigint;

package/lib/utils/domain-separation.d.ts

@@ -0,0 +1,31 @@
+import { ValidateASN1 } from './asn1';
+/**
+ * Version for Keeta's domain separation namespace schema, encoded as the
+ * `INTEGER` field of `namespacePrefixSchema`.
+ */
+export declare const KeetaNamespaceVersion = 0;
+/**
+ * Maximum domain separation namespace length in bytes (for strings,
+ * this is the UTF-8 byte length, not the character count).
+ */
+export declare const MaxNamespaceLength = 255;
+/**
+ * Schema for the namespace prefix:
+ *
+ * ```asn1
+ * NamespacePrefix ::= SEQUENCE {
+ *     version   INTEGER,
+ *     namespace OCTET STRING,
+ *     data      OCTET STRING
+ * }
+ * ```
+ */
+export declare const namespacePrefixSchema: readonly [typeof ValidateASN1.IsInteger, typeof ValidateASN1.IsOctetString, typeof ValidateASN1.IsOctetString];
+/**
+ * Apply the `NamespacePrefix` domain separator to `data`.
+ *
+ * String namespaces are UTF-8 encoded; ArrayBuffer namespaces are used
+ * verbatim. Namespace length MUST be 1-`MaxNamespaceLength` bytes after
+ * encoding.
+ */
+export declare function applyNamespace(namespace: string | ArrayBuffer, data: ArrayBuffer): ArrayBuffer;

package/lib/utils/external-keys/gcp-kms.d.ts

@@ -0,0 +1,53 @@
+/**
+ * ExternalKeyPair for the Keeta Network which uses Google Cloud KMS
+ * for signing operations. This implementation supports ECDSA keys on
+ * both SECP256K1 and SECP256R1 curves, with potential for ED25519
+ * support in the future.
+ */
+import type { KeyManagementServiceClient } from '@google-cloud/kms';
+import type * as KeetaNet from '../../../client';
+import type { AccountKeyAlgorithm } from '../../../lib/account';
+import type * as crypto from 'node:crypto';
+type KeetaGCPKMSKeyPairPackages = {
+    KeyManagementServiceClient: typeof KeyManagementServiceClient;
+    KeetaNet: {
+        lib: {
+            Account: typeof KeetaNet.lib.Account;
+            Utils: {
+                Helper: typeof KeetaNet.lib.Utils.Helper;
+                Buffer: typeof KeetaNet.lib.Utils.Buffer;
+                ASN1: typeof KeetaNet.lib.Utils.ASN1;
+            };
+        };
+    };
+    crypto: Pick<typeof crypto, 'createPublicKey'>;
+};
+type KeetaGCPKMSKeyPairOptions = {
+    /**
+     * The GCP KMS key resource name or config object.
+     * Format: projects/<project>/locations/<location>/keyRings/<keyRing>/cryptoKeys/<key>
+     */
+    key: string | {
+        projectId: string;
+        locationId: string;
+        keyRingId: string;
+        keyId: string;
+        versionId?: string;
+    };
+    /**
+     * Key type for the KMS key. Optional - will be auto-detected from KMS
+     * if not provided, but can be explicitly specified for validation.
+     */
+    keyType?: AccountKeyAlgorithm;
+};
+interface KeetaGCPKMSKeyPair extends InstanceType<typeof KeetaNet.lib.Account.ExternalKeyPair> {
+    /**
+     * The full GCP KMS key resource name used for this key pair.
+     */
+    readonly keyName: string;
+}
+interface KeetaGCPKMSKeyPairClass {
+    lookup: (options: KeetaGCPKMSKeyPairOptions) => Promise<KeetaGCPKMSKeyPair>;
+}
+export declare function KeetaGCPKMSKeyPairFactory(packages: KeetaGCPKMSKeyPairPackages): Omit<KeetaGCPKMSKeyPairClass, '_Testing'>;
+export {};