@keetanetwork/keetanet-client 0.10.4 → 0.12.0

package/lib/kv/index.d.ts

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

package/lib/kv/kv_redis.d.ts

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

package/lib/ledger/common.d.ts

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

package/lib/ledger/db_dynamodb.d.ts

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

package/lib/ledger/db_postgres.d.ts

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

package/lib/ledger/db_spanner.d.ts

@@ -4,15 +4,16 @@ 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 { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBase } from '../ledger';
+import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } 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';
+import type Node from '../node';
+import type { CertificateHash } from '../utils/certificate';
 type QueryRow<T extends TableName> = HelperQueryRow<T> | QueryRows<T>;
 type ReadOptions = {
     limit?: number;
@@ -30,16 +31,18 @@ type SpannerReadResponse<T extends TableName, C extends TableColumn<T>[]> = {
     moment: Date;
 };
 interface SpannerTransactionOptions {
-    readOnly?: boolean;
     strongRead?: boolean;
 }
-export declare class SpannerTransaction {
+export declare class SpannerTransaction implements LedgerStorageTransactionBase {
     #private;
+    readonly node: Node | undefined;
     readonly moment: Date;
+    readonly identifier: string;
+    readonly readOnly: boolean;
     readonly options: SpannerTransactionOptions;
     readonly statsChanges: Parameters<Stats['incr']>[];
-    constructor(database: GoogleSpannerDatabase, options?: SpannerTransactionOptions);
-    evaluateError(error: any): KeetaNetLedgerError;
+    constructor(database: GoogleSpannerDatabase, options: SpannerTransactionOptions, transactionBase: LedgerStorageTransactionBase);
+    evaluateError(error: any): any;
     beginTransaction(identifier: string, strongRead?: boolean): Promise<void>;
     endTransaction(mode: 'COMMIT' | 'ROLLBACK'): Promise<void>;
     insert<T extends TableName, R extends QueryRow<T>>(table: T, query: R): void;
@@ -66,11 +69,11 @@ export declare class DBSpanner extends LedgerStorageBase implements LedgerStorag
     constructor();
     init(config: LedgerConfig, ledger: Ledger): void;
     destroy(): Promise<void>;
-    beginTransaction(identifier: string, readOnly?: boolean): Promise<SpannerTransaction>;
+    beginTransaction(transactionBase: LedgerStorageTransactionBase): Promise<SpannerTransaction>;
     commitTransaction(transaction: SpannerTransaction): Promise<void>;
     abortTransaction(transaction: SpannerTransaction): Promise<void>;
-    evaluateError(error: any): Promise<KeetaNetLedgerError>;
-    delegatedWeight(transaction: SpannerTransaction, rep?: Account): Promise<bigint>;
+    evaluateError(error: any): Promise<any>;
+    delegatedWeight(transaction: SpannerTransaction, rep?: Account | InstanceType<typeof Account.Set>): 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>;
@@ -79,11 +82,15 @@ export declare class DBSpanner extends LedgerStorageBase implements LedgerStorag
      * 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[]>;
+    adjust(transaction: SpannerTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean, completedStaples?: Set<string>): Promise<VoteStaple[]>;
     getBlock(transaction: SpannerTransaction, blockHash: BlockHash, from: LedgerSelector): Promise<Block | null>;
-    getBlockHeight(transaction: SpannerTransaction, blockHash: BlockHash, account: GenericAccount): Promise<{
-        blockHeight: string | null;
-    } | null>;
+    getBlockHeights(transaction: any, toFetch: {
+        blockHash: BlockHash;
+        account: GenericAccount;
+    }[]): Promise<{
+        [blockHash: string]: bigint | null;
+    }>;
+    getBlockHeight(transaction: SpannerTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | 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[]>;
@@ -91,6 +98,9 @@ export declare class DBSpanner extends LedgerStorageBase implements LedgerStorag
     getVotesFromMultiplePrevious(transaction: SpannerTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
         [hash: string]: Vote[] | null;
     }>;
+    getHeadBlockHashes(transaction: any, accounts: InstanceType<typeof Account.Set>): Promise<{
+        [account: string]: BlockHash | null;
+    }>;
     getHeadBlocks(transaction: SpannerTransaction, accounts: GenericAccount[], from: LedgerSelector): Promise<{
         [publicKey: string]: Block | null;
     }>;
@@ -102,6 +112,8 @@ export declare class DBSpanner extends LedgerStorageBase implements LedgerStorag
     getVotesAfter(transaction: SpannerTransaction, moment: Date, startKey?: string, options?: GetVotesAfterOptions): Promise<PaginatedVotes>;
     protected gcBatch(transaction: SpannerTransaction): Promise<boolean>;
     getNextSerialNumber(): Promise<bigint>;
+    getAccountCertificates(transaction: SpannerTransaction, account: GenericAccount): Promise<CertificateWithIntermediates[]>;
+    getAccountCertificateByHash(transaction: SpannerTransaction, account: GenericAccount, certificateHash: CertificateHash): Promise<CertificateWithIntermediates | null>;
     stats(): Promise<LedgerStatistics>;
 }
 export declare const Testing: {