@keetanetwork/keetanet-client 0.10.2

package/lib/error/ledger.d.ts

@@ -0,0 +1,12 @@
+import KeetaNetError from '.';
+declare const LedgerErrorType: "LEDGER";
+declare const LedgerErrorCodes: readonly ["TRANSACTION_ABORTED", "INVALID_CHAIN", "INVALID_NETWORK", "INVALID_SUBNET", "NOT_EMPTY", "NOT_OPENING", "NOT_SUCCESSOR", "INVALID_PERMISSIONS", "INVALID_OWNER_COUNT", "INVALID_BALANCE", "PREVIOUS_ALREADY_USED", "PREVIOUS_NOT_SEEN", "SUCCESSOR_VOTE_EXISTS", "INSUFFICIENT_VOTING_WEIGHT", "INVALID_ACCOUNT_INFO_KEY", "RECEIVE_NOT_MET", "DUPLICATE_VOTE_FOUND", "CANNOT_EXCHANGE_PERM_VOTE", "BLOCKS_DIFFER_FROM_VOTED_ON", "NO_PERM_WITHOUT_SELF_TEMP", "DUPLICATE_VOTE_ISSUER_FOUND", "OTHER"];
+export type LedgerErrorCode = `${typeof LedgerErrorType}_${typeof LedgerErrorCodes[number]}`;
+export declare class KeetaNetLedgerError extends KeetaNetError {
+    static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetLedgerError;
+    readonly type: "LEDGER";
+    readonly shouldRetry: boolean;
+    readonly retryDelay?: number;
+    constructor(code: LedgerErrorCode, message: string, shouldRetry?: boolean, retryDelay?: number);
+}
+export default KeetaNetLedgerError;

package/lib/error/permissions.d.ts

@@ -0,0 +1,9 @@
+import KeetaNetError from '.';
+declare const PermissionsErrorType: "PERMISSIONS";
+declare const PermissionsErrorCodes: readonly ["CANNOT_MIX_FLAGS_AND_TYPES", "EXTERNAL_OFFSET_TOO_LARGE", "INVALID_EXTERNAL_FLAG", "INVALID_FLAG", "INVALID_FLAG_ASSERTION"];
+export type PermissionsErrorCode = `${typeof PermissionsErrorType}_${typeof PermissionsErrorCodes[number]}`;
+export default class KeetaNetPermissionsError extends KeetaNetError {
+    static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetPermissionsError;
+    constructor(code: PermissionsErrorCode, message: string);
+}
+export {};

package/lib/error/vote.d.ts

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

package/lib/index.d.ts

@@ -0,0 +1,39 @@
+import Account from './account';
+import Block from './block';
+import Ledger from './ledger';
+import Node from './node';
+import P2P from './p2p';
+import Stats from './stats';
+import Permissions from './permissions';
+import Vote from './vote';
+import Error from './error';
+import * as ASN1 from './utils/asn1';
+import * as Bloom from './utils/bloom';
+import * as Buffer from './utils/buffer';
+import * as Hash from './utils/hash';
+import * as Helper from './utils/helper';
+import * as Initial from './utils/initial';
+import * as Conversion from './utils/conversion';
+import * as Certificate from './utils/certificate';
+declare const _default: {
+    Account: typeof Account;
+    Block: typeof Block;
+    Error: typeof Error;
+    Ledger: typeof Ledger;
+    Node: typeof Node;
+    P2P: typeof P2P;
+    Permissions: typeof Permissions;
+    Stats: typeof Stats;
+    Vote: typeof Vote;
+    Utils: {
+        ASN1: typeof ASN1;
+        Bloom: typeof Bloom;
+        Buffer: typeof Buffer;
+        Hash: typeof Hash;
+        Helper: typeof Helper;
+        Initial: typeof Initial;
+        Conversion: typeof Conversion;
+        Certificate: typeof Certificate;
+    };
+};
+export default _default;

package/lib/kv/index.d.ts

@@ -0,0 +1,22 @@
+import type BufferStorage from '../utils/buffer';
+import type { JSONSerializable } from '../utils/conversion';
+import type KVStorageProviders from './providers';
+export interface KVSetOptionsType {
+    exclusiveCreate?: boolean;
+    ttl?: number;
+}
+export interface KVStorageProviderAPI {
+    set(arena: string, key: string, value: JSONSerializable | undefined, options?: KVSetOptionsType): Promise<void>;
+    get(arena: string | null, key: string): Promise<JSONSerializable | undefined>;
+    getAll(arena: string): Promise<{
+        [key: string]: JSONSerializable;
+    }>;
+    list(arena: string): Promise<string[]>;
+    incr(arena: string, key: string, change: number): Promise<bigint>;
+    xor(arena: null, key: string, change: BufferStorage): Promise<void>;
+    destroy?: () => Promise<void>;
+}
+export type KVStorageProvider = InstanceType<typeof KVStorageProviders[keyof typeof KVStorageProviders]>;
+export declare class KVStorageProviderBase {
+    xor(_ignored_arena: null, key: string, _ignored_change: BufferStorage): Promise<void>;
+}

package/lib/kv/index.test.data.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Random Values in hex which will be XOR'd together to produce
+ * TestHashValuesXOR
+ */
+export declare const TestHashValues: string[];
+/**
+ * The result of XORing all the values of TestHashValues
+ */
+export declare const TestHashValuesXOR = "3819BCCE11FF17A70475E7683CE0ADD80525F27134EBDDD880B4208EFECDB771";

package/lib/kv/kv_dynamodb.d.ts

@@ -0,0 +1,20 @@
+import type { KVStorageProviderAPI, KVSetOptionsType } from './';
+import { KVStorageProviderBase } from './';
+import type { JSONSerializable } from '../utils/conversion';
+import BufferStorage from '../utils/buffer';
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+export declare class KVStorageProviderDynamoDB extends KVStorageProviderBase implements KVStorageProviderAPI {
+    #private;
+    constructor(table: string, ...dynamodbArgs: ConstructorParameters<typeof DynamoDB>);
+    static createTable(table: string, ...dynamodbArgs: ConstructorParameters<typeof DynamoDB>): Promise<void>;
+    static deleteTable(table: string, ...dynamodbArgs: ConstructorParameters<typeof DynamoDB>): Promise<void>;
+    set(arena: string, key: string, value: JSONSerializable | undefined, options?: KVSetOptionsType): Promise<void>;
+    get(arena: string | null, key: string): Promise<JSONSerializable | undefined>;
+    getAll(arena: string): Promise<{
+        [key: string]: JSONSerializable;
+    }>;
+    list(arena: string): Promise<string[]>;
+    incr(arena: string, key: string, change: number): Promise<bigint>;
+    xor(arena: null, key: string, change: BufferStorage): Promise<void>;
+}
+export default KVStorageProviderDynamoDB;

package/lib/kv/kv_memory.d.ts

@@ -0,0 +1,17 @@
+import type { KVStorageProviderAPI, KVSetOptionsType } from './';
+import { KVStorageProviderBase } from './';
+import type { JSONSerializable } from '../utils/conversion';
+import BufferStorage from '../utils/buffer';
+export declare class KVStorageProviderMemory extends KVStorageProviderBase implements KVStorageProviderAPI {
+    #private;
+    constructor();
+    set(arena: string, key: string, value: JSONSerializable | undefined, options?: KVSetOptionsType): Promise<void>;
+    get(arena: string | null, key: string): Promise<JSONSerializable | undefined>;
+    getAll(arena: string): Promise<{
+        [key: string]: JSONSerializable;
+    }>;
+    list(arena: string): Promise<string[]>;
+    incr(arena: string, key: string, change: number): Promise<bigint>;
+    xor(arena: null, key: string, change: BufferStorage): Promise<void>;
+}
+export default KVStorageProviderMemory;

package/lib/kv/kv_redis.d.ts

@@ -0,0 +1,22 @@
+import type { KVStorageProviderAPI, KVSetOptionsType } from './';
+import { KVStorageProviderBase } from './';
+import type { JSONSerializable } from '../utils/conversion';
+import type BufferStorage from '../utils/buffer';
+import { RedisClient } from '../utils/redis';
+export declare class KVStorageProviderRedis extends KVStorageProviderBase implements KVStorageProviderAPI {
+    #private;
+    constructor(host: string, password: string, port?: number);
+    destroy(): Promise<void>;
+    private deleteExpiredKeys;
+    _testingDeleteExpiredKeys(): Promise<void>;
+    set(arena: string, key: string, value: JSONSerializable | undefined, opt?: KVSetOptionsType): Promise<void>;
+    get(arena: string | null, key: string): Promise<JSONSerializable | undefined>;
+    getAll(arena: string): Promise<{
+        [key: string]: JSONSerializable;
+    }>;
+    list(arena: string): Promise<string[]>;
+    incr(arena: string, key: string, change: number): Promise<bigint>;
+    xor(arena: null, key: string, change: BufferStorage): Promise<void>;
+    get _testingClient(): RedisClient;
+}
+export default KVStorageProviderRedis;

package/lib/kv/providers.d.ts

@@ -0,0 +1,9 @@
+import KVStorageProviderMemory from './kv_memory';
+import KVStorageProviderDynamoDB from './kv_dynamodb';
+import KVStorageProviderRedis from './kv_redis';
+export declare const KV: {
+    Memory: typeof KVStorageProviderMemory;
+    DynamoDB: typeof KVStorageProviderDynamoDB;
+    Redis: typeof KVStorageProviderRedis;
+};
+export default KV;

package/lib/ledger/cache.d.ts

@@ -0,0 +1,14 @@
+import type Vote from '../vote';
+export declare class LedgerRequestCache {
+    #private;
+    addVote(vote: null, contents: Buffer | ArrayBuffer): null;
+    addVote(vote: Vote): Vote;
+    addVote(vote: Vote | null, contents?: Buffer | ArrayBuffer): Vote | null;
+    addVotes(votes: Vote[]): Vote[];
+    getVote(contents: Buffer | ArrayBuffer): Vote | null;
+    getVote(contents: Buffer | ArrayBuffer, lookupVote: () => Vote): Vote;
+    getVote(contents: Buffer | ArrayBuffer, lookupVote: () => Vote | null): Vote | null;
+    getVoteByUID(uid: string): Vote | null;
+    getVoteByContents(contents: Buffer | ArrayBuffer): Vote | null;
+}
+export default LedgerRequestCache;

package/lib/ledger/common.d.ts

@@ -0,0 +1,115 @@
+import type { VoteStaple } from '../vote';
+import type Vote from '../vote';
+import type { GenericAccount, TokenAddress } from '../account';
+import Account from '../account';
+import { Block, BlockHash } from '../block';
+import type { LedgerConfig, LedgerSelector, LedgerStorage, LedgerStorageAPI } from '.';
+import type { AccountInfo, ACLRow, ACLEntry, ACLUpdate } from './types';
+import type Node from '../node';
+import type Stats from '../stats';
+import type { BaseSet, ExternalSet } from '../permissions';
+import type { ComputedEffectOfBlocksByAccount } from './effects';
+interface NumericEffect {
+    change: bigint;
+    starting?: bigint;
+    fellNegative?: boolean;
+    final?: bigint;
+}
+interface NumericEffectFinal extends NumericEffect {
+    final: bigint;
+}
+interface BalanceNumericEffect extends NumericEffect {
+    fellNegative?: boolean;
+    lowestChange: bigint;
+    receiveValidated?: boolean;
+}
+interface BalanceNumericEffectFinal extends BalanceNumericEffect {
+    final: bigint;
+    fellNegative: boolean;
+    starting: bigint;
+}
+type IfTrue<B, V, E = {
+    [key: string]: never;
+}> = B extends true ? V : E;
+type BalanceEffect<T extends boolean> = IfTrue<T, BalanceNumericEffectFinal, BalanceNumericEffect>;
+type CompNumericEffect<T extends boolean> = IfTrue<T, NumericEffectFinal, NumericEffect>;
+type PerAccount<T> = {
+    [pubKey: string]: T;
+};
+type NumericEffectPerAccount<T extends boolean> = PerAccount<CompNumericEffect<T>>;
+type BalanceChanges<T extends boolean> = PerAccount<PerAccount<BalanceEffect<T>>>;
+type computeLedgerEffectStorageProvider = Pick<LedgerStorageAPI, 'getAccountInfo' | 'getBalance' | 'listACLsByPrincipal' | 'delegatedWeight' | 'getAccountRep'>;
+type BalanceSupplyChangeRespBase<T extends boolean> = {
+    balances: BalanceChanges<T>;
+    supplies: NumericEffectPerAccount<T>;
+};
+type BalanceSupplyChangeResp<T extends boolean, P extends boolean, W extends boolean> = BalanceSupplyChangeRespBase<T> & IfTrue<P, {
+    permissions: ACLUpdate[];
+}> & IfTrue<W, {
+    weights: NumericEffectPerAccount<T>;
+}>;
+export declare function findPermissionMatch(lookingFor: Pick<ACLEntry, 'entity' | 'principal' | 'target'>, entries: ACLRow[]): ACLRow | undefined;
+interface ComputeLedgerEffectOptions<T extends boolean, P extends boolean, W extends boolean> {
+    getFinalNumericValues?: T;
+    computePermissions?: P;
+    computeWeights?: W;
+    checkNegative?: boolean;
+    baseToken: TokenAddress;
+}
+/**
+ * Compute effects on the ledger from block effects
+ */
+export declare function computeLedgerEffect<T extends boolean, P extends boolean, W extends boolean>(options: ComputeLedgerEffectOptions<T, P, W>, effects: ComputedEffectOfBlocksByAccount, storageProvider: computeLedgerEffectStorageProvider, transaction?: any): Promise<BalanceSupplyChangeResp<T, P, W>>;
+/**
+ * A partial LedgerStorageAPI which just has the methods for "addTimeStatistics"
+ */
+type LedgerStorageAPILike = Pick<LedgerStorageAPI, 'getVotes'>;
+/**
+ * An individual update to statistics
+ */
+type StatsIncreaseRequest = Parameters<Stats['incr']>;
+/**
+ * Common method for adding a timing data point during processing of a
+ * Vote Staple to a Node Stats
+ *
+ * @param node - A running node
+ * @param blocks - Blocks being processed
+ * @param to - Ledger being processed
+ * @param storageProvider - storage provider that includes getVotes function
+ * @param transaction - Current transaction (if any)
+ * @param skipPush - Instead of adding to stats immediately, just return what would be added
+ * @returns What was added (or would be added, if skipPush is set to true)
+ */
+export declare function addTimeStatistic(node: Node | undefined, blocks: Block[], to: LedgerStorage, storageProvider: LedgerStorageAPILike, transaction?: any, skipPush?: boolean): Promise<StatsIncreaseRequest[]>;
+type AccountInfoUnparsedRow = {
+    name?: string;
+    description?: string;
+    metadata?: string;
+    supply?: bigint | string;
+    defaultBasePermission?: string | bigint | BaseSet;
+    defaultExternalPermission?: string | bigint | ExternalSet;
+};
+export declare abstract class LedgerStorageBase {
+    #private;
+    protected config: LedgerConfig | null;
+    constructor();
+    protected abstract adjustDefer(transaction: any, input: VoteStaple): Promise<void>;
+    abstract getBlockHeight(transaction: any, blockHash: BlockHash, account: GenericAccount): Promise<{
+        blockHeight: string | null;
+    } | null>;
+    abstract getHeadBlocks(transaction: any, accounts: GenericAccount[], from: LedgerSelector): Promise<{
+        [account: string]: Block | null;
+    }>;
+    abstract getVotesFromMultiplePrevious(transaction: any, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
+        [hash: string]: Vote[] | null;
+    }>;
+    preAdjust(input: VoteStaple, mayDefer?: boolean, transaction?: any): Promise<{
+        [hash: string]: bigint;
+    }>;
+    _formatAccountInfoFromRow(account: GenericAccount, row?: AccountInfoUnparsedRow | undefined): AccountInfo;
+    _validateAccountInfoKeys(account: GenericAccount, info: Partial<AccountInfo>): void;
+    getHeadBlock(transaction: any, account: GenericAccount, from: LedgerSelector): Promise<Block | null>;
+    getVotesFromPrevious(transaction: any, prevBlock: BlockHash, from: LedgerSelector, issuer?: Account): Promise<Vote[] | null>;
+}
+export declare function assertLedgerStorage(value: string): LedgerStorage;
+export {};

package/lib/ledger/db_dynamodb.d.ts

@@ -0,0 +1,129 @@
+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 type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions } from '../ledger';
+import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics } from './types';
+import { LedgerStorageBase } from './common';
+import type { ComputedEffectOfBlocks } from './effects';
+declare const dynamoDBTableNames: readonly ["votes", "voteUIDs", "permissions", "accountInfo", "accountOwners", "blocks", "balances", "weight", "heapBlocks", "heapStorage", "chain", "delegation", "serial", "kv"];
+declare const optionalDynamoDbTables: readonly ["kv"];
+type TableName = typeof dynamoDBTableNames[number];
+type OptionalTableName = typeof optionalDynamoDbTables[number];
+type DynamoDbTables = {
+    [K in TableName]: string;
+};
+type DynamoDbTablesWithOptional = Omit<DynamoDbTables, OptionalTableName> & Partial<Pick<DynamoDbTables, OptionalTableName>>;
+export interface DynamoDBConfig {
+    tables: DynamoDbTablesWithOptional;
+    transactionSize?: number;
+    batchUpdateSize?: number;
+}
+declare class DynamoDBTransaction {
+    #private;
+    readonly moment: Date;
+    constructor(config: DynamoDBConfig, ledger: Ledger, log: LedgerConfig['log'], dbDynamoDB: DBDynamoDB);
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+    delegatedWeight(rep?: Account): Promise<bigint>;
+    getBalance(account: GenericAccount, token: TokenAddress): Promise<bigint>;
+    getAllBalances(account: GenericAccount): Promise<GetAllBalancesResponse>;
+    adjustDefer(input: VoteStaple): Promise<void>;
+    adjust(input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean): Promise<BlockHash[]>;
+    addPendingVote(blocksAndVotes: VoteStaple): Promise<void>;
+    getBlock(block: BlockHash, from: LedgerSelector): Promise<Block | null>;
+    getBlockHeight(blockHash: BlockHash, account: GenericAccount): Promise<{
+        blockHeight: string | null;
+    } | null>;
+    getVotes(block: BlockHash, from: LedgerSelector, issuer?: Account, transactionAlreadyVerifiedActiveByCaller?: boolean): Promise<Vote[] | null>;
+    getVoteStaple(stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
+    getHistory(account: GenericAccount, start: VoteBlockHash | null, limit: number): Promise<VoteBlockHash[]>;
+    getVotesFromMultiplePrevious(prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
+        [hash: string]: Vote[] | null;
+    }>;
+    getBlockHashFromPrevious(prevBlock: BlockHash, from: LedgerSelector): Promise<BlockHash | null>;
+    /**
+     * Find a block whose "previous" is the value "prevBlock" -- that is,
+     * blocks that succeed this block in a chain
+     */
+    getBlockFromPrevious(prevBlock: BlockHash, from: LedgerSelector, transactionAlreadyVerifiedActiveByCaller?: boolean): Promise<Block | null>;
+    getHeadBlocks(accounts: GenericAccount[], from: LedgerSelector): Promise<{
+        [publicKey: string]: Block | null;
+    }>;
+    getAccountRep(userAccount: Account | string): Promise<Account | null>;
+    getAccountInfo(account: GenericAccount | string): Promise<AccountInfo>;
+    listOwners(identifier: IdentifierAddress): Promise<Account[]>;
+    listACLsByEntity(entity: GenericAccount): Promise<ACLRow[]>;
+    listACLsByPrincipal(principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
+    getVotesAfter(moment: Date, startKey?: string, options?: GetVotesAfterOptions): Promise<PaginatedVotes>;
+    gc(): Promise<true>;
+}
+export declare class DBDynamoDB extends LedgerStorageBase implements LedgerStorageAPI {
+    #private;
+    static Testing: {
+        deleteTables: (config: DynamoDBConfig) => Promise<void>;
+        createTables: (config: DynamoDBConfig) => Promise<void>;
+    };
+    init(config: LedgerConfig, ledger: Ledger): void;
+    beginTransaction(): Promise<DynamoDBTransaction>;
+    commitTransaction(transaction: DynamoDBTransaction): Promise<void>;
+    abortTransaction(transaction: DynamoDBTransaction): Promise<void>;
+    evaluateError(error: any): Promise<any>;
+    delegatedWeight(transaction: DynamoDBTransaction, rep?: Account): Promise<bigint>;
+    getBalance(transaction: DynamoDBTransaction, account: GenericAccount, token: TokenAddress): Promise<bigint>;
+    getAllBalances(transaction: DynamoDBTransaction, account: GenericAccount): Promise<GetAllBalancesResponse>;
+    protected adjustDefer(transaction: DynamoDBTransaction, input: VoteStaple): Promise<void>;
+    adjust(transaction: DynamoDBTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean): Promise<BlockHash[]>;
+    addPendingVote(transaction: DynamoDBTransaction, blocksAndVote: VoteStaple): Promise<void>;
+    getBlock(transaction: DynamoDBTransaction, block: BlockHash, from: LedgerSelector): Promise<Block | null>;
+    getBlockHeight(transaction: DynamoDBTransaction, blockHash: BlockHash, account: GenericAccount): Promise<{
+        blockHeight: string | null;
+    } | null>;
+    getVotes(transaction: DynamoDBTransaction, block: BlockHash, from: LedgerSelector): Promise<Vote[] | null>;
+    getVoteStaples(transaction: DynamoDBTransaction, stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
+    getHistory(transaction: DynamoDBTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
+    getVotesFromMultiplePrevious(transaction: DynamoDBTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
+        [hash: string]: Vote[] | null;
+    }>;
+    getBlockFromPrevious(transaction: DynamoDBTransaction, block: BlockHash, from: LedgerSelector): Promise<Block | null>;
+    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>;
+    listOwners(transaction: DynamoDBTransaction, identifier: IdentifierAddress): Promise<Account[]>;
+    listACLsByPrincipal(transaction: DynamoDBTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
+    listACLsByEntity(transaction: DynamoDBTransaction, entity: GenericAccount): Promise<ACLRow[]>;
+    getVotesAfter(transaction: DynamoDBTransaction, moment: Date, startKey?: string): Promise<PaginatedVotes>;
+    getNextSerialNumber(): Promise<bigint>;
+    gc(transaction: DynamoDBTransaction): Promise<true>;
+    stats(): Promise<LedgerStatistics>;
+}
+export default DBDynamoDB;
+type DynamoDBAttrTypes = 'S' | 'N' | 'B';
+type DynamoDBKey = {
+    type: DynamoDBAttrTypes;
+    name: string;
+};
+type DynamoDBKeys = {
+    hashKey: DynamoDBKey;
+    rangeKey?: DynamoDBKey;
+    gsi?: (Omit<DynamoDBKeys, 'gsi' | 'lsi'> & {
+        name: string;
+    })[];
+    lsi?: (Required<Omit<DynamoDBKeys, 'gsi' | 'lsi' | 'hashKey'>> & {
+        name: string;
+    })[];
+};
+type DynamoDBSchema = {
+    [name: string]: DynamoDBKeys;
+};
+/**
+ * Testing routines
+ */
+export declare const Testing: {
+    deleteTables(config: DynamoDBConfig): Promise<void>;
+    getSchema(names: DynamoDBConfig["tables"]): DynamoDBSchema;
+    createTables(config: DynamoDBConfig): Promise<void>;
+};

package/lib/ledger/db_memory.d.ts

@@ -0,0 +1,6 @@
+import type { Ledger, LedgerConfig } from '.';
+import DBSqlite from './db_sqlite';
+declare class DBMemory extends DBSqlite {
+    init(config: LedgerConfig, ledger: Ledger): void;
+}
+export default DBMemory;

package/lib/ledger/db_postgres.d.ts

@@ -0,0 +1,70 @@
+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, { AccountKeyAlgorithm } from '../account';
+import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions } from '../ledger';
+import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics } from './types';
+import { LedgerStorageBase } from './common';
+import type { PoolClient as PostgresPoolClient } from 'pg';
+import { Pool as PostgresPool } from 'pg';
+import type { ComputedEffectOfBlocks } from './effects';
+import LedgerRequestCache from './cache';
+interface PostgresTransaction {
+    client: PostgresPoolClient;
+    moment: Date;
+    cache: LedgerRequestCache;
+}
+interface PostgresSelectOptions {
+    forUpdate?: boolean;
+}
+export type PostgresConfig = NonNullable<ConstructorParameters<typeof PostgresPool>[0]>;
+export declare class DBPostgres extends LedgerStorageBase implements LedgerStorageAPI {
+    #private;
+    constructor();
+    init(config: LedgerConfig, ledger: Ledger): void;
+    destroy(): Promise<void>;
+    beginTransaction(): Promise<PostgresTransaction>;
+    commitTransaction(transaction: PostgresTransaction): Promise<void>;
+    abortTransaction(transaction: PostgresTransaction): Promise<void>;
+    cache(transaction: PostgresTransaction): LedgerRequestCache;
+    evaluateError(error: any): Promise<any>;
+    delegatedWeight(transaction: PostgresTransaction, rep?: Account, options?: PostgresSelectOptions): Promise<bigint>;
+    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>;
+    /**
+     * If an adjustment cannot be made right now, defer it for follow-up
+     */
+    protected adjustDefer(transaction: PostgresTransaction, input: VoteStaple): Promise<void>;
+    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>;
+    adjust(transaction: PostgresTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean): Promise<BlockHash[]>;
+    getBlock(transaction: PostgresTransaction, block: BlockHash, from: LedgerSelector): Promise<Block | null>;
+    getBlockHeight(transaction: PostgresTransaction, blockHash: BlockHash, account: GenericAccount): Promise<{
+        blockHeight: string | null;
+    } | null>;
+    getVotes(transaction: PostgresTransaction, block: BlockHash, from: LedgerSelector, issuer?: GenericAccount): Promise<Vote[] | null>;
+    getVoteStaples(transaction: PostgresTransaction, stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
+    getHistory(transaction: PostgresTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
+    getBlockFromPrevious(transaction: PostgresTransaction, prevBlock: BlockHash, from: LedgerSelector): Promise<Block | null>;
+    getVotesFromMultiplePrevious(transaction: PostgresTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
+        [hash: string]: Vote[] | null;
+    }>;
+    getHeadBlocks(transaction: PostgresTransaction, accounts: GenericAccount[], from: LedgerSelector): Promise<{
+        [publicKey: string]: Block | null;
+    }>;
+    getVoteStaplesFromBlockHash(transaction: PostgresTransaction, blocks: BlockHash[], onLedger: LedgerSelector): Promise<VoteStaple[]>;
+    getVotesAfter(transaction: PostgresTransaction, moment: Date, startKey?: string, options?: GetVotesAfterOptions): Promise<PaginatedVotes>;
+    gc(transaction: PostgresTransaction): Promise<true>;
+    getNextSerialNumber(): Promise<bigint>;
+    stats(): Promise<LedgerStatistics>;
+}
+export declare const Testing: {
+    createDatabase: (config: PostgresConfig) => Promise<void>;
+    deleteDatabase: (config: PostgresConfig) => Promise<void>;
+};
+export default DBPostgres;

package/lib/ledger/db_spanner.d.ts

@@ -0,0 +1,116 @@
+import { Vote, VoteStaple } from '../vote';
+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 type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions } from '../ledger';
+import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics } from './types';
+import type { KVStorageProviderAPI } from '../kv';
+import { LedgerStorageBase } from './common';
+import Stats from '../stats';
+import { KeetaNetLedgerError } from '../error/ledger';
+import type { Database as GoogleSpannerDatabase } from '@google-cloud/spanner';
+import type { TableColumn, FilteredResponseRow, IndexName, TableName, QueryRow as HelperQueryRow, QueryRows } from './db_spanner_helper';
+import type { ComputedEffectOfBlocks } from './effects';
+type QueryRow<T extends TableName> = HelperQueryRow<T> | QueryRows<T>;
+type ReadOptions = {
+    limit?: number;
+    skipLocalRead?: boolean;
+    all?: boolean;
+    range?: boolean;
+};
+interface ReadQueryWithOptions<T extends TableName> extends ReadOptions {
+    query: QueryRow<T>;
+}
+type ReadRequest<T extends TableName> = QueryRow<T> | ReadQueryWithOptions<T>;
+type SpannerReadResponse<T extends TableName, C extends TableColumn<T>[]> = {
+    count: number;
+    rows: FilteredResponseRow<T, C>[];
+    moment: Date;
+};
+interface SpannerTransactionOptions {
+    readOnly?: boolean;
+    strongRead?: boolean;
+}
+export declare class SpannerTransaction {
+    #private;
+    readonly moment: Date;
+    readonly options: SpannerTransactionOptions;
+    readonly statsChanges: Parameters<Stats['incr']>[];
+    constructor(database: GoogleSpannerDatabase, options?: SpannerTransactionOptions);
+    evaluateError(error: any): KeetaNetLedgerError;
+    beginTransaction(strongRead?: boolean): Promise<void>;
+    endTransaction(mode: 'COMMIT' | 'ROLLBACK'): Promise<void>;
+    insert<T extends TableName, R extends QueryRow<T>>(table: T, query: R): void;
+    upsert<T extends TableName, R extends QueryRow<T>>(table: T, query: R): void;
+    delete<T extends TableName, R extends QueryRow<T>>(table: T, query: R): void;
+    read<T extends TableName, I extends IndexName | undefined, C extends TableColumn<T>[], X extends ReadRequest<T>>(table: T, index: I, columns: C, request: X): Promise<SpannerReadResponse<T, C>>;
+    addStatsChange(...changes: Parameters<Stats['incr']>[]): void;
+}
+/**
+ * Ledger Configuration for Google Spanner
+ */
+export type SpannerConfig = {
+    projectId: string;
+    instanceId: string;
+    databaseId: string;
+    kv: KVStorageProviderAPI;
+    strongRead?: boolean;
+};
+/**
+ * Ledger Storage for Google Spanner
+ */
+export declare class DBSpanner extends LedgerStorageBase implements LedgerStorageAPI {
+    #private;
+    constructor();
+    init(config: LedgerConfig, ledger: Ledger): void;
+    destroy(): Promise<void>;
+    beginTransaction(readOnly?: boolean): Promise<SpannerTransaction>;
+    commitTransaction(transaction: SpannerTransaction): Promise<void>;
+    abortTransaction(transaction: SpannerTransaction): Promise<void>;
+    evaluateError(error: any): Promise<KeetaNetLedgerError>;
+    delegatedWeight(transaction: SpannerTransaction, rep?: Account): Promise<bigint>;
+    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>;
+    /**
+     * If an adjustment cannot be made right now, defer it for follow-up
+     */
+    protected adjustDefer(transaction: SpannerTransaction, input: VoteStaple): Promise<void>;
+    adjust(transaction: SpannerTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean): Promise<BlockHash[]>;
+    getBlock(transaction: SpannerTransaction, blockHash: BlockHash, from: LedgerSelector): Promise<Block | null>;
+    getBlockHeight(transaction: SpannerTransaction, blockHash: BlockHash, account: GenericAccount): Promise<{
+        blockHeight: string | null;
+    } | null>;
+    getVotes(transaction: SpannerTransaction, blockHash: BlockHash, from: LedgerSelector): Promise<Vote[] | null>;
+    getVoteStaples(transaction: SpannerTransaction, stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
+    getHistory(transaction: SpannerTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
+    getBlockFromPrevious(transaction: SpannerTransaction, prevBlock: BlockHash, from: LedgerSelector): Promise<Block | null>;
+    getVotesFromMultiplePrevious(transaction: SpannerTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
+        [hash: string]: Vote[] | null;
+    }>;
+    getHeadBlocks(transaction: SpannerTransaction, accounts: GenericAccount[], from: LedgerSelector): Promise<{
+        [publicKey: string]: Block | null;
+    }>;
+    getAccountInfo(transaction: SpannerTransaction, account: GenericAccount | string): Promise<AccountInfo>;
+    listOwners(transaction: SpannerTransaction, entity: IdentifierAddress): Promise<GenericAccount[]>;
+    listACLsByEntity(transaction: SpannerTransaction, entity: GenericAccount): Promise<ACLRow[]>;
+    listACLsByPrincipal(transaction: SpannerTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
+    getVotesAfter(transaction: SpannerTransaction, moment: Date, _ignore_startKey?: string, _ignored_options?: GetVotesAfterOptions): Promise<PaginatedVotes>;
+    gc(transaction: SpannerTransaction): Promise<true>;
+    getNextSerialNumber(): Promise<bigint>;
+    stats(): Promise<LedgerStatistics>;
+}
+export declare const Testing: {
+    /**
+     * Create a new Spanner Instance (if first call), new Spanner Database, and all the tables needed to use this ledger
+     */
+    createDatabase: (config: SpannerConfig, createInstance: boolean) => Promise<GoogleSpannerDatabase>;
+    /**
+     * Clean-up a Spanner Database (and if deleteInstance) delete the Spanner Instance
+     */
+    deleteDatabase: (config: SpannerConfig, deleteInstance: boolean, database: GoogleSpannerDatabase) => Promise<void>;
+};
+export default DBSpanner;