@keetanetwork/keetanet-client 0.10.4 → 0.12.0

package/lib/ledger/db_spanner_helper.d.ts

@@ -5,6 +5,7 @@ import Block, { BlockHash } from '../block';
 import Vote, { PossiblyExpiredVote, VoteBlockHash } from '../vote';
 import type { BaseSet, ExternalSet } from '../permissions';
 import type { SpannerTransaction } from './db_spanner';
+import { Certificate, CertificateBundle, CertificateHash } from '../utils/certificate';
 declare const ColumnTypes: {
     readonly LEDGER: {
         readonly dbType: "STRING";
@@ -15,7 +16,7 @@ declare const ColumnTypes: {
     };
     readonly ACCOUNT: {
         readonly fromSpanner: (pubKey: string) => Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1>;
-        readonly toSpanner: (account: Account) => import("../account").Secp256K1PublicKeyString | import("../account").ED25519PublicKeyString | import("../account").Secp256R1PublicKeyString;
+        readonly toSpanner: (account: Account) => import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
         readonly dbType: string;
         readonly dbSize: number;
         readonly toComparable: (account: string | Account) => string;
@@ -42,7 +43,7 @@ declare const ColumnTypes: {
         readonly toComparable: (str: string) => string;
     };
     readonly INFO_METADATA: {
-        readonly dbSize: 750;
+        readonly dbSize: 5464;
         readonly dbType: string;
         readonly fromSpanner: (str: string) => string;
         readonly toSpanner: (str: string) => string;
@@ -84,18 +85,25 @@ declare const ColumnTypes: {
         readonly dbSize: undefined;
     };
     readonly BLOCKHASH: {
-        readonly fromSpanner: (hash: string) => BlockHash;
-        readonly toSpanner: (blockHash: BlockHash) => string;
-        readonly toComparable: (blockHash: BlockHash | string) => string;
-        readonly dbType: string;
-        readonly dbSize: number;
+        fromSpanner: (hash: string) => BlockHash;
+        toSpanner: (constructedInput: BlockHash) => string;
+        toComparable: (input: string | BlockHash) => string;
+        dbType: string;
+        dbSize: number;
+    };
+    readonly CERTIFICATE_HASH: {
+        fromSpanner: (hash: string) => CertificateHash;
+        toSpanner: (constructedInput: CertificateHash) => string;
+        toComparable: (input: string | CertificateHash) => string;
+        dbType: string;
+        dbSize: number;
     };
     readonly VOTEBLOCKHASH: {
-        readonly fromSpanner: (hash: string) => VoteBlockHash;
-        readonly toSpanner: (blockHash: VoteBlockHash) => string;
-        readonly toComparable: (blockHash: VoteBlockHash | string) => string;
-        readonly dbType: string;
-        readonly dbSize: number;
+        fromSpanner: (hash: string) => VoteBlockHash;
+        toSpanner: (constructedInput: VoteBlockHash) => string;
+        toComparable: (input: string | VoteBlockHash) => string;
+        dbType: string;
+        dbSize: number;
     };
     readonly VOTE_UID: {
         readonly dbSize: 150;
@@ -104,6 +112,22 @@ declare const ColumnTypes: {
         readonly toSpanner: (str: string) => string;
         readonly toComparable: (str: string) => string;
     };
+    readonly CERTIFICATE: {
+        readonly fromSpanner: (certificate: Buffer) => Certificate;
+        readonly toSpanner: (certificate: Certificate) => Buffer;
+        readonly toComparable: (input: Certificate | Buffer) => string & {
+            readonly __certificateHash: never;
+        };
+        readonly dbType: string;
+        readonly dbSize: string;
+    };
+    readonly CERTIFICATE_BUNDLE: {
+        readonly fromSpanner: (bundle: Buffer) => CertificateBundle;
+        readonly toSpanner: (bundle: CertificateBundle) => Buffer;
+        readonly toComparable: (input: CertificateBundle | Buffer) => string;
+        readonly dbType: string;
+        readonly dbSize: string;
+    };
     readonly BUFFER: {
         dbType: string;
         dbSize: string;
@@ -158,7 +182,7 @@ declare const ColumnTypes: {
         dbSize: number;
         toComparable: (account: string | Account) => string;
         fromSpanner: (pubKey: string) => GenericAccount;
-        toSpanner: (account: GenericAccount) => import("../account").Secp256K1PublicKeyString | import("../account").ED25519PublicKeyString | import("../account").NetworkPublicKeyString | import("../account").TokenPublicKeyString | import("../account").StoragePublicKeyString | import("../account").Secp256R1PublicKeyString;
+        toSpanner: (account: GenericAccount) => import("../account").TokenPublicKeyString | import("../account").NetworkPublicKeyString | import("../account").StoragePublicKeyString | import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
     };
     readonly BUFFER_BIGINT: {
         dbType: string;
@@ -171,11 +195,12 @@ declare const ColumnTypes: {
 type ColumnTypeName = keyof typeof ColumnTypes;
 type ColumnOutputTypeArg<T extends ColumnTypeName> = Parameters<typeof ColumnTypes[T]['fromSpanner']>[0];
 type ColumnOutputTypeReturn<T extends ColumnTypeName> = ReturnType<typeof ColumnTypes[T]['fromSpanner']>;
-type ColumnOutputTypeInfer<X> = X extends ColumnInterface<infer TR> ? ColumnOutputTypeReturn<TR> : never;
+type IfNullable<T, I> = I extends false ? T : (T | null);
+type ColumnOutputTypeInfer<X> = X extends ColumnInterface<infer TR, infer Nullable> ? IfNullable<ColumnOutputTypeReturn<TR>, Nullable> : never;
 type ColumnInputTypeArg<T extends ColumnTypeName> = Parameters<typeof ColumnTypes[T]['toSpanner']>[0];
 type ColumnInputTypeReturn<T extends ColumnTypeName> = ReturnType<typeof ColumnTypes[T]['toSpanner']>;
-interface ColumnInterface<T extends ColumnTypeName> {
-    nullable: (nullable: boolean) => ColumnInterface<T>;
+interface ColumnInterface<T extends ColumnTypeName, Nullable extends boolean = boolean> {
+    nullable: <SetNullable extends boolean>(nullable: SetNullable) => ColumnInterface<T, SetNullable>;
     fromSpanner: (value: ColumnOutputTypeArg<T>, transaction: SpannerTransaction) => ColumnOutputTypeReturn<T>;
     toSpanner: (value: ColumnInputTypeArg<T>, transaction: SpannerTransaction) => ColumnInputTypeReturn<T>;
     toComparable: (value: any, transaction: SpannerTransaction) => any;
@@ -201,24 +226,24 @@ declare const schema: {
     readonly accountInfo: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly account: ColumnInterface<"GENERIC_ACCOUNT">;
-            readonly name: ColumnInterface<"INFO_NAME">;
-            readonly description: ColumnInterface<"INFO_DESCRIPTION">;
-            readonly metadata: ColumnInterface<"INFO_METADATA">;
-            readonly supply: ColumnInterface<"SUPPLY">;
-            readonly defaultBasePermission: ColumnInterface<"BASE_PERMISSION">;
-            readonly defaultExternalPermission: ColumnInterface<"EXTERNAL_PERMISSION">;
+            readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly name: ColumnInterface<"INFO_NAME", true>;
+            readonly description: ColumnInterface<"INFO_DESCRIPTION", true>;
+            readonly metadata: ColumnInterface<"INFO_METADATA", true>;
+            readonly supply: ColumnInterface<"SUPPLY", true>;
+            readonly defaultBasePermission: ColumnInterface<"BASE_PERMISSION", true>;
+            readonly defaultExternalPermission: ColumnInterface<"EXTERNAL_PERMISSION", true>;
         };
         readonly key: readonly [Key];
     };
     readonly permissions: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly account: ColumnInterface<"GENERIC_ACCOUNT">;
-            readonly entity: ColumnInterface<"GENERIC_ACCOUNT">;
-            readonly target: ColumnInterface<"GENERIC_ACCOUNT">;
-            readonly basePermission: ColumnInterface<"BASE_PERMISSION">;
-            readonly externalPermission: ColumnInterface<"EXTERNAL_PERMISSION">;
+            readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly entity: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly target: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly basePermission: ColumnInterface<"BASE_PERMISSION", false>;
+            readonly externalPermission: ColumnInterface<"EXTERNAL_PERMISSION", false>;
         };
         readonly key: readonly [Key, Key, Key];
         readonly interleave: Interleave;
@@ -226,10 +251,10 @@ declare const schema: {
     readonly ledger: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly account: ColumnInterface<"GENERIC_ACCOUNT">;
-            readonly token: ColumnInterface<"TOKEN_ACCOUNT">;
-            readonly onLedger: ColumnInterface<"LEDGER">;
-            readonly balance: ColumnInterface<"INT_AS_STRING">;
+            readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly token: ColumnInterface<"TOKEN_ACCOUNT", false>;
+            readonly onLedger: ColumnInterface<"LEDGER", false>;
+            readonly balance: ColumnInterface<"INT_AS_STRING", false>;
         };
         readonly key: readonly [Key, Key, Key];
         readonly interleave: Interleave;
@@ -237,9 +262,9 @@ declare const schema: {
     readonly chain: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly account: ColumnInterface<"GENERIC_ACCOUNT">;
-            readonly blockHeight: ColumnInterface<"BIGINT">;
-            readonly blockHash: ColumnInterface<"BLOCKHASH">;
+            readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly blockHeight: ColumnInterface<"BIGINT", false>;
+            readonly blockHash: ColumnInterface<"BLOCKHASH", false>;
         };
         readonly key: readonly [Key, Key];
         readonly interleave: Interleave;
@@ -247,9 +272,9 @@ declare const schema: {
     readonly history: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly account: ColumnInterface<"GENERIC_ACCOUNT">;
-            readonly voteBlockHash: ColumnInterface<"VOTEBLOCKHASH">;
-            readonly orderIndex: ColumnInterface<"BUFFER_BIGINT">;
+            readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly voteBlockHash: ColumnInterface<"VOTEBLOCKHASH", false>;
+            readonly orderIndex: ColumnInterface<"BUFFER_BIGINT", false>;
         };
         readonly key: readonly [Key, Key];
         readonly interleave: Interleave;
@@ -257,8 +282,8 @@ declare const schema: {
     readonly delegation: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly account: ColumnInterface<"ACCOUNT">;
-            readonly delegatedToRep: ColumnInterface<"ACCOUNT">;
+            readonly account: ColumnInterface<"ACCOUNT", false>;
+            readonly delegatedToRep: ColumnInterface<"ACCOUNT", false>;
         };
         readonly key: readonly [Key];
         readonly interleave: Interleave;
@@ -266,31 +291,31 @@ declare const schema: {
     readonly votes: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly voteUID: ColumnInterface<"VOTE_UID">;
-            readonly onLedger: ColumnInterface<"LEDGER">;
-            readonly vote: ColumnInterface<"VOTE">;
-            readonly timestamp: ColumnInterface<"TIMESTAMP">;
-            readonly expires: ColumnInterface<"TIMESTAMP">;
-            readonly issuer: ColumnInterface<"ACCOUNT">;
-            readonly voteBlockHash: ColumnInterface<"VOTEBLOCKHASH">;
+            readonly voteUID: ColumnInterface<"VOTE_UID", false>;
+            readonly onLedger: ColumnInterface<"LEDGER", false>;
+            readonly vote: ColumnInterface<"VOTE", false>;
+            readonly timestamp: ColumnInterface<"TIMESTAMP", false>;
+            readonly expires: ColumnInterface<"TIMESTAMP", false>;
+            readonly issuer: ColumnInterface<"ACCOUNT", false>;
+            readonly voteBlockHash: ColumnInterface<"VOTEBLOCKHASH", false>;
         };
         readonly key: readonly [Key, Key];
     };
     readonly blocks: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly blockHash: ColumnInterface<"BLOCKHASH">;
-            readonly onLedger: ColumnInterface<"LEDGER">;
-            readonly block: ColumnInterface<"BLOCK">;
-            readonly prevBlockHash: ColumnInterface<"BLOCKHASH">;
+            readonly blockHash: ColumnInterface<"BLOCKHASH", false>;
+            readonly onLedger: ColumnInterface<"LEDGER", false>;
+            readonly block: ColumnInterface<"BLOCK", false>;
+            readonly prevBlockHash: ColumnInterface<"BLOCKHASH", false>;
         };
         readonly key: readonly [Key];
     };
     readonly voteBlocks: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly blockHash: ColumnInterface<"BLOCKHASH">;
-            readonly voteUID: ColumnInterface<"VOTE_UID">;
+            readonly blockHash: ColumnInterface<"BLOCKHASH", false>;
+            readonly voteUID: ColumnInterface<"VOTE_UID", false>;
         };
         readonly key: readonly [Key, Key];
         readonly interleave: Interleave;
@@ -298,38 +323,36 @@ declare const schema: {
     readonly weight: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly repAccount: ColumnInterface<"ACCOUNT">;
-            readonly weight: ColumnInterface<"INT_AS_STRING">;
+            readonly repAccount: ColumnInterface<"ACCOUNT", false>;
+            readonly weight: ColumnInterface<"INT_AS_STRING", false>;
         };
         readonly key: readonly [Key];
     };
     readonly heapBlocks: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly prevBlockHash: ColumnInterface<"BLOCKHASH">;
-            readonly storageHash: ColumnInterface<"HASH">;
+            readonly prevBlockHash: ColumnInterface<"BLOCKHASH", false>;
+            readonly storageHash: ColumnInterface<"HASH", false>;
         };
         readonly key: readonly [Key];
     };
     readonly heapStorage: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly storageHash: ColumnInterface<"HASH">;
-            readonly data: ColumnInterface<"BUFFER">;
+            readonly storageHash: ColumnInterface<"HASH", false>;
+            readonly data: ColumnInterface<"BUFFER", false>;
         };
         readonly key: readonly [Key];
     };
-    readonly permissionsAccount: {
-        readonly type: "INDEX";
-        readonly table: "permissions";
-        readonly key: readonly [Key];
-        readonly storing: readonly [Key, Key];
-    };
-    readonly permissionsPrincipalEntity: {
-        readonly type: "INDEX";
-        readonly table: "permissions";
+    readonly accountCertificates: {
+        readonly type: "TABLE";
+        readonly columns: {
+            readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly certificateHash: ColumnInterface<"CERTIFICATE_HASH", false>;
+            readonly certificate: ColumnInterface<"CERTIFICATE", false>;
+            readonly intermediates: ColumnInterface<"CERTIFICATE_BUNDLE", true>;
+        };
         readonly key: readonly [Key, Key];
-        readonly storing: readonly [Key, Key];
     };
     readonly permissionsEntity: {
         readonly type: "INDEX";
@@ -342,30 +365,11 @@ declare const schema: {
         readonly table: "permissions";
         readonly key: readonly [Key, Key];
     };
-    readonly historyAccount: {
-        readonly type: "INDEX";
-        readonly table: "history";
-        readonly key: readonly [Key];
-        readonly storing: readonly [Key];
-    };
     readonly historyVoteBlockHash: {
         readonly type: "INDEX";
         readonly table: "history";
         readonly key: readonly [Key, Key];
     };
-    readonly historyAccountOrderIndex: {
-        readonly type: "INDEX";
-        readonly table: "history";
-        readonly key: readonly [Key, Key];
-        readonly storing: readonly [Key];
-    };
-    readonly chainAccount: {
-        readonly type: "INDEX";
-        readonly table: "chain";
-        readonly key: readonly [Key];
-        readonly interleave: Interleave;
-        readonly storing: readonly [Key];
-    };
     readonly chainAccountHash: {
         readonly type: "INDEX";
         readonly table: "chain";
@@ -377,13 +381,7 @@ declare const schema: {
         readonly type: "INDEX";
         readonly table: "blocks";
         readonly key: readonly [Key];
-        readonly storing: readonly [Key, Key];
-    };
-    readonly voteBlocksBlockhash: {
-        readonly type: "INDEX";
-        readonly table: "voteBlocks";
-        readonly key: readonly [Key];
-        readonly interleave: Interleave;
+        readonly storing: readonly [Key];
     };
     readonly votesTimestamp: {
         readonly type: "INDEX";
@@ -403,25 +401,12 @@ declare const schema: {
         readonly key: readonly [Key, Key];
         readonly storing: readonly [Key];
     };
-    readonly votesUid: {
-        readonly type: "INDEX";
-        readonly table: "votes";
-        readonly key: readonly [Key];
-        readonly storing: readonly [Key];
-    };
     readonly votesBlockHash: {
         readonly type: "INDEX";
         readonly table: "votes";
         readonly key: readonly [Key];
         readonly storing: readonly [Key];
     };
-    readonly ledgerBalanceByAccount: {
-        readonly type: "INDEX";
-        readonly table: "ledger";
-        readonly key: readonly [Key];
-        readonly storing: readonly [Key];
-        readonly interleave: Interleave;
-    };
 };
 type SchemaEntriesFilter<T extends SchemaType> = keyof {
     [K in (keyof typeof schema) as typeof schema[K]['type'] extends T ? K : never]: true;
@@ -458,7 +443,7 @@ export declare class Helper {
     static getPrimaryKeyNames<X extends TableIndexName>(table: X): string[];
     static getNameFromType(filterType: 'INDEX'): IndexName[];
     static getNameFromType(filterType: 'TABLE'): TableName[];
-    static getAllTables(): ("permissions" | "blocks" | "votes" | "ledger" | "chain" | "history" | "weight" | "accountInfo" | "heapBlocks" | "heapStorage" | "delegation" | "voteBlocks")[];
+    static getAllTables(): ("blocks" | "permissions" | "votes" | "ledger" | "chain" | "history" | "weight" | "accountInfo" | "accountCertificates" | "heapBlocks" | "heapStorage" | "delegation" | "voteBlocks")[];
     static IsTable(name: TableIndexName): name is TableName;
     static IsIndex(name: TableIndexName): name is IndexName;
     static getIndexParent(index: IndexName): TableName;

package/lib/ledger/db_sqlite.d.ts

@@ -4,14 +4,14 @@ import type { BlockHash } from '../block';
 import { Block } from '../block';
 import type { GenericAccount, IdentifierAddress, TokenAddress } from '../account';
 import Account, { AccountKeyAlgorithm } from '../account';
-import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions } 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 * as sqlite from 'sqlite';
 import type { ComputedEffectOfBlocks } from './effects';
-interface DBSqliteTransaction {
+import type { CertificateHash } from '../utils/certificate';
+interface DBSqliteTransaction extends LedgerStorageTransactionBase {
     sql: Awaited<ReturnType<typeof sqlite['open']>>;
-    moment: Date;
     release: null | ((value: null | number) => void);
     lock: null | Promise<null | number>;
 }
@@ -24,11 +24,11 @@ export declare class DBSqlite extends LedgerStorageBase implements LedgerStorage
     constructor();
     init(config: LedgerConfig, ledger: Ledger): void;
     destroy(): Promise<void>;
-    beginTransaction(): Promise<DBSqliteTransaction>;
+    beginTransaction(transactionBase: LedgerStorageTransactionBase): Promise<DBSqliteTransaction>;
     commitTransaction(transaction: DBSqliteTransaction): Promise<void>;
     abortTransaction(transaction: DBSqliteTransaction): Promise<void>;
     evaluateError(error: any): Promise<any>;
-    delegatedWeight(transaction: DBSqliteTransaction, rep?: Account): Promise<bigint>;
+    delegatedWeight(transaction: DBSqliteTransaction, rep?: Account | InstanceType<typeof Account.Set>): Promise<bigint>;
     getBalance(transaction: DBSqliteTransaction, account: GenericAccount, token: TokenAddress): Promise<bigint>;
     getAllBalances(transaction: DBSqliteTransaction, account: GenericAccount): Promise<GetAllBalancesResponse>;
     addPendingVote(transaction: DBSqliteTransaction, votesAndBlocks: VoteStaple): Promise<void>;
@@ -41,11 +41,9 @@ export declare class DBSqlite extends LedgerStorageBase implements LedgerStorage
     listACLsByEntity(transaction: DBSqliteTransaction, entity: GenericAccount): Promise<ACLRow[]>;
     listACLsByPrincipal(transaction: DBSqliteTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
     getAccountInfo(transaction: DBSqliteTransaction, account: GenericAccount | string): Promise<AccountInfo>;
-    adjust(transaction: DBSqliteTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean): Promise<BlockHash[]>;
+    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<{
-        blockHeight: string | null;
-    } | null>;
+    getBlockHeight(transaction: DBSqliteTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
     getVotes(transaction: DBSqliteTransaction, block: BlockHash, from: LedgerSelector): Promise<Vote[] | null>;
     getVoteStaples(transaction: DBSqliteTransaction, voteBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
     getHistory(transaction: DBSqliteTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
@@ -57,6 +55,8 @@ export declare class DBSqlite extends LedgerStorageBase implements LedgerStorage
         [publicKey: string]: Block | null;
     }>;
     getVotesAfter(transaction: DBSqliteTransaction, moment: Date, startKey?: string, options?: GetVotesAfterOptions): Promise<PaginatedVotes>;
+    getAccountCertificates(transaction: DBSqliteTransaction, account: GenericAccount): Promise<CertificateWithIntermediates[]>;
+    getAccountCertificateByHash(transaction: DBSqliteTransaction, account: GenericAccount, hash: CertificateHash): Promise<CertificateWithIntermediates | null>;
     protected gcBatch(transaction: DBSqliteTransaction): Promise<boolean>;
     getNextSerialNumber(transaction: DBSqliteTransaction): Promise<bigint>;
     stats(): Promise<LedgerStatistics>;

package/lib/ledger/effects.d.ts

@@ -1,9 +1,10 @@
 import type { GenericAccount, IdentifierAddress, NetworkAddress, TokenAddress } from '../account';
 import Account from '../account';
-import type { BlockHash } from '../block';
+import type { AdjustMethod, BlockHash } from '../block';
 import { Block } from '../block';
 import type { AccountInfo, ACLEntry, ACLUpdate } from '../ledger/types';
-import type { InstanceSet } from '../utils/helper';
+import type { Certificate, CertificateBundle } from '../utils/certificate';
+import { CertificateHash } from '../utils/certificate';
 interface NumericValueEntry {
     value: bigint;
 }
@@ -21,6 +22,18 @@ interface ModifyTokenBalanceEntry extends TokenNumericEntry {
     set: boolean;
     receivable: boolean;
 }
+/**
+ * Change of certificate indication
+ */
+export type CertificateUpdate = {
+    method: AdjustMethod.ADD;
+    certificateHash: CertificateHash;
+    certificate: Certificate;
+    intermediateCertificates: CertificateBundle | null;
+} | {
+    method: AdjustMethod.SUBTRACT;
+    certificateHash: CertificateHash;
+};
 type TokenEntry = ModifyTokenBalanceEntry | RequestTokenReceiveEntry;
 interface ComputedBlocksEffectTokenChangesField {
     [tokenPubKey: string]: TokenEntry[];
@@ -45,6 +58,7 @@ interface ComputedBlocksEffectFields {
     permissionRequirements?: ACLEntry[];
     createRequests?: CreateIdentifierRequest[];
     delegation?: DelegationUpdate;
+    certificate?: CertificateUpdate[];
 }
 /**
  * Which accounts and fields are affected by a set of block
@@ -61,7 +75,8 @@ export type ComputedEffectOfBlocksByAccount = {
 };
 export type ComputedEffectOfBlocks = {
     accounts: ComputedEffectOfBlocksByAccount;
-    touched: InstanceSet<GenericAccount>;
+    touched: InstanceType<typeof Account.Set>;
+    possibleNewAccounts: InstanceType<typeof Account.Set>;
     metadata: {
         operationCount: number;
         blockCount: number;
@@ -72,7 +87,7 @@ type LedgerOptions = {
     baseToken: TokenAddress;
     networkAddress: NetworkAddress;
 };
-type OnlyTouchedEffects = Pick<ComputedEffectOfBlocks, 'touched'>;
+type OnlyTouchedEffects = Pick<ComputedEffectOfBlocks, 'touched' | 'possibleNewAccounts'>;
 export declare function computeEffectOfBlocks(blocks: Block[], ledger?: undefined): OnlyTouchedEffects;
 export declare function computeEffectOfBlocks(blocks: Block[], ledger: LedgerOptions): ComputedEffectOfBlocks;
 export {};

package/lib/ledger/index.d.ts

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