@keetanetwork/keetanet-client 0.12.2 → 0.14.2

package/lib/block/index.d.ts

@@ -1,15 +1,19 @@
-import type { GenericAccount } from '../account';
-import Account from '../account';
+import type { GenericAccount, MultisigAddress } from '../account';
+import Account, { AccountKeyAlgorithm } from '../account';
 import { BufferStorage } from '../utils/buffer';
 import * as ASN1 from '../utils/asn1';
 import type { ToJSONSerializable, ToJSONSerializableOptions } from '../utils/conversion';
 import * as Operations from './operations';
+export declare enum BlockPurpose {
+    GENERIC = 0,
+    FEE = 1
+}
 export declare enum AdjustMethod {
     ADD = 0,
     SUBTRACT = 1,
     SET = 2
 }
-export declare function assertAdjustMethod(value: any, bigintOkay?: boolean): AdjustMethod;
+export declare function toAdjustMethod(value: unknown): AdjustMethod;
 type BlockHashString = string & {
     readonly __blockhash: never;
 };
@@ -41,8 +45,9 @@ type BlockSignature = Buffer;
 /**
  * Representation of the block
  */
-export interface BlockJSON {
+export interface BlockV1JSON {
     version: 1;
+    purpose?: BlockPurpose.GENERIC;
     date: string | Date;
     previous: string | BlockHash;
     network: string | NetworkID;
@@ -52,16 +57,37 @@ export interface BlockJSON {
     signature: string | BlockSignature;
     operations: Operations.BlockJSONOperations[] | Operations.BlockOperations[];
 }
-export type BlockJSONIncomplete = Partial<BlockJSON>;
+export type BlockV1JSONIncomplete = Partial<BlockV1JSON>;
 /**
  * Output of block suitable to JSON serialization
  */
-export type BlockJSONOutput = ToJSONSerializable<ReturnType<Block['toJSON']>>;
-export type BlockJSONOutputIncomplete = Partial<BlockJSONOutput>;
+/**
+ * Representation of the block V2
+ */
+export interface BlockV2JSON {
+    version: 2;
+    purpose: BlockPurpose;
+    date: string | Date;
+    previous: string | BlockHash;
+    network: string | NetworkID;
+    subnet?: string | SubnetID;
+    account: string | GenericAccount;
+    signer: BlockSignerFieldJSON;
+    signatures: (string | BlockSignature)[];
+    operations: (Operations.BlockJSONOperations | Operations.BlockOperations)[];
+}
+export type BlockV2JSONIncomplete = Partial<BlockV2JSON>;
+export type BlockJSONOutput = ReturnType<Block['toJSON']>;
+export type BlockJSONOutputSerialized = ToJSONSerializable<BlockJSONOutput>;
+export type BlockJSONOutputIncomplete = Partial<BlockJSONOutputSerialized>;
+export type BlockJSON = (Omit<BlockV1JSON, 'version'> | Omit<BlockV2JSON, 'version'>) & {
+    version: number;
+};
+export type BlockJSONIncomplete = Partial<BlockJSON>;
 /**
  * Map input to our values
  */
-interface BlockUnsignedCanonical {
+interface BlockV1UnsignedCanonical {
     version: 1;
     date: Date;
     previous: BlockHash;
@@ -70,17 +96,45 @@ interface BlockUnsignedCanonical {
     operations: Operations.BlockOperations[];
     network: NetworkID;
     subnet: SubnetID | undefined;
-    signature: never;
+    signature?: never;
 }
-interface BlockCanonical extends Omit<BlockUnsignedCanonical, 'signature'> {
+interface BlockV1Canonical extends Omit<BlockV1UnsignedCanonical, 'signature'> {
     signature: BlockSignature;
 }
-type BlockASN1WithoutSignature = ASN1.ValidateASN1.SchemaMap<[typeof BlockASN1Schema[0], typeof BlockASN1Schema[1], typeof BlockASN1Schema[2], typeof BlockASN1Schema[3], typeof BlockASN1Schema[4], typeof BlockASN1Schema[5], typeof BlockASN1Schema[6], typeof BlockASN1Schema[7]]>;
+interface BlockV2UnsignedCanonical {
+    version: 2;
+    date: Date;
+    purpose: BlockPurpose;
+    previous: BlockHash;
+    account: GenericAccount;
+    signer: BlockSignerField;
+    operations: Operations.BlockOperations[];
+    network: NetworkID;
+    subnet: SubnetID | undefined;
+    signatures?: never;
+}
+interface BlockV2Canonical extends Omit<BlockV2UnsignedCanonical, 'signatures'> {
+    signatures: BlockSignature[];
+}
+type OmitLastArrayValue<T> = Required<T> extends [...infer Head, any] ? Head : never;
+type BlockV1ASN1WithoutSignature = ASN1.ValidateASN1.SchemaMap<OmitLastArrayValue<typeof BlockV1ASN1Schema>>;
+type BlockV2ASN1WithoutSignature = ASN1.ValidateASN1.SchemaMap<OmitLastArrayValue<typeof BlockV2ASN1Schema.contains>>;
+type MultisigSignerFieldJSON = [MultisigAddress | string, (MultisigSignerField | Account | string)[]];
+type BlockSignerFieldJSON = Account | string | MultisigSignerFieldJSON;
+type BlockASN1SchemaWithoutSignature = BlockV1ASN1WithoutSignature | {
+    type: 'context';
+    kind: 'explicit';
+    value: 1;
+    contains: BlockV2ASN1WithoutSignature;
+};
+type MultisigSignerField = [MultisigAddress, (MultisigSignerField | Account)[]];
+type BlockSignerField = Account | [MultisigAddress, BlockSignerField[]];
+type BlockSignatureField = [BlockSignature, ...BlockSignature[]];
 /**
  * Block:  An item which contains a number of operations (transactions) which
  * originated from an account at a particular instant
  */
-export declare class Block implements BlockCanonical {
+export declare class Block implements Omit<BlockV2Canonical, 'version'> {
     #private;
     static isInstance: (obj: any, strict?: boolean) => obj is Block;
     static Hash: typeof BlockHash;
@@ -98,32 +152,41 @@ export declare class Block implements BlockCanonical {
     };
     static NO_PREVIOUS: string;
     static AdjustMethod: typeof AdjustMethod;
+    static Purpose: typeof BlockPurpose;
     static Builder: typeof BlockBuilder;
-    readonly version: 1;
+    readonly version: 1 | 2;
+    readonly purpose: BlockPurpose;
     readonly date: Date;
     readonly previous: BlockHash;
     readonly account: GenericAccount;
-    readonly signer: Account;
-    readonly operations: BlockCanonical['operations'];
+    readonly operations: BlockV2Canonical['operations'];
     readonly network: NetworkID;
     readonly subnet: SubnetID | undefined;
-    readonly signature: BlockSignature;
-    readonly $signatureValid: boolean;
+    readonly signer: BlockSignerField;
+    readonly signatures: BlockSignatureField;
+    get principal(): Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1> | MultisigAddress;
     readonly $opening: boolean;
-    static fromUnsignedJSON(input: BlockUnsignedCanonical): Promise<Block>;
-    static isValidJSON(block: BlockJSON | BlockJSONOutput | BlockJSONIncomplete): block is BlockJSON;
-    constructor(input: Buffer | ArrayBuffer | BlockJSON | BlockJSONOutput | Block | string);
+    static fromUnsignedJSON(input: BlockV1UnsignedCanonical | BlockV2UnsignedCanonical): Promise<Block>;
+    static isValidJSON<Version extends 1 | 2>(block: unknown, version?: Version): block is ({
+        1: BlockV1JSON;
+        2: BlockV2JSON;
+    }[Version]);
+    constructor(input: Buffer | ArrayBuffer | BlockJSON | BlockJSONOutput | BlockJSONOutputSerialized | Block | string);
     static getAccountOpeningHash(account: GenericAccount): BlockHash;
-    toBytes(includeSignature?: boolean): ArrayBuffer;
-    protected static getASN1ContainerWithoutSignature(input: BlockUnsignedCanonical | BlockCanonical): BlockASN1WithoutSignature;
+    toBytes(includeSignatures?: boolean): ArrayBuffer;
+    protected static getV1ASN1ContainerWithoutSignature(input: BlockV1UnsignedCanonical | BlockV1Canonical): BlockV1ASN1WithoutSignature;
+    protected static getV2ASN1ContainerWithoutSignature(input: BlockV2UnsignedCanonical | BlockV2Canonical): BlockV2ASN1WithoutSignature;
+    protected static getASN1ContainerWithoutSignature(input: BlockV1UnsignedCanonical | BlockV1Canonical | BlockV2UnsignedCanonical | BlockV2Canonical): BlockASN1SchemaWithoutSignature;
     toJSON(options?: ToJSONSerializableOptions): {
         $binary?: string;
-        version: 1;
+        signature?: string;
+        signatures?: string[];
+        version: 1 | 2;
         date: Date;
         previous: BlockHash;
         account: GenericAccount;
-        signer: Account<import("../account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../account").AccountKeyAlgorithm.ED25519 | import("../account").AccountKeyAlgorithm.ECDSA_SECP256R1>;
-        signature: string;
+        purpose: BlockPurpose;
+        signer: Account | [MultisigAddress, any[]];
         network: bigint;
         subnet: bigint | undefined;
         operations: Operations.ExportedJSONOperation[];
@@ -140,7 +203,7 @@ export declare class Block implements BlockCanonical {
      */
     get hash(): BlockHash;
 }
-export declare class BlockBuilder implements BlockJSONIncomplete {
+export declare class BlockBuilder {
     #private;
     static isInstance: (obj: any, strict?: boolean) => obj is BlockBuilder;
     static OperationType: typeof Operations.OperationType;
@@ -157,32 +220,35 @@ export declare class BlockBuilder implements BlockJSONIncomplete {
         MANAGE_CERTIFICATE: typeof Operations.BlockOperationMANAGE_CERTIFICATE;
     };
     static NO_PREVIOUS: string;
-    constructor(block?: BlockJSONIncomplete | BlockJSON | Block | ArrayBuffer | string);
+    constructor(block?: BlockJSON | BlockJSONIncomplete | BlockJSONOutputSerialized | ReturnType<Block['toJSON']> | Block | ArrayBuffer | string);
     protected get currentBlock(): Block | BlockJSONIncomplete;
     protected get currentWIP(): BlockJSONIncomplete;
     protected get currentBlockSealed(): Block;
     toJSON(opts?: ToJSONSerializableOptions): {
         $binary?: string;
-        version: 1;
+        signature?: string;
+        signatures?: string[];
+        version: 1 | 2;
         date: Date;
         previous: BlockHash;
         account: GenericAccount;
-        signer: Account<import("../account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../account").AccountKeyAlgorithm.ED25519 | import("../account").AccountKeyAlgorithm.ECDSA_SECP256R1>;
-        signature: string;
+        purpose: BlockPurpose;
+        signer: Account | [MultisigAddress, any[]];
         network: bigint;
         subnet: bigint | undefined;
         operations: Operations.ExportedJSONOperation[];
         $hash: BlockHash;
         $opening: boolean;
     } | {
-        version: 1 | undefined;
+        version: number | undefined;
         date: Date | undefined;
         previous: BlockHash | undefined;
         account: GenericAccount | undefined;
-        signer: Account<import("../account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../account").AccountKeyAlgorithm.ED25519 | import("../account").AccountKeyAlgorithm.ECDSA_SECP256R1> | undefined;
+        signer: BlockSignerFieldJSON | undefined;
         network: bigint | undefined;
         subnet: bigint | undefined;
         operations: Operations.BlockOperations[] | undefined;
+        purpose: BlockPurpose;
         $opening: boolean | undefined;
     };
     seal(): Promise<Block>;
@@ -190,8 +256,8 @@ export declare class BlockBuilder implements BlockJSONIncomplete {
     get sealed(): boolean;
     get block(): Block | undefined;
     get hash(): BlockHash | undefined;
-    set signer(signer: string | Account | undefined);
-    get signer(): Account | undefined;
+    set signer(signer: BlockV2JSONIncomplete['signer'] | BlockV2JSON['signer']);
+    get signer(): BlockV2JSON['signer'] | undefined;
     set account(account: string | GenericAccount | undefined);
     get account(): GenericAccount | undefined;
     set previous(blockhash: string | BlockHash | undefined);
@@ -199,8 +265,10 @@ export declare class BlockBuilder implements BlockJSONIncomplete {
     get $opening(): boolean | undefined;
     set date(date: Date | string | undefined);
     get date(): Date | undefined;
-    set version(version: 1 | undefined);
-    get version(): 1 | undefined;
+    set version(version: number | undefined);
+    get version(): number | undefined;
+    set purpose(purpose: BlockPurpose | undefined);
+    get purpose(): BlockPurpose;
     set network(network: NetworkID | string | undefined);
     get network(): NetworkID | undefined;
     set subnet(subnet: SubnetID | string | undefined);

package/lib/block/operations.d.ts

@@ -1,12 +1,13 @@
 import { ValidateASN1 } from '../utils/asn1';
 import type { DeepMutable } from '../utils/helper';
-import type { GenericAccount, IdentifierAddress, TokenAddress, TokenPublicKeyString } from '../account';
-import Account from '../account';
+import type { GenericAccount, IdentifierAddress, IdentifierKeyAlgorithm, TokenAddress, TokenPublicKeyString } from '../account';
+import Account, { AccountKeyAlgorithm } from '../account';
 import type { AcceptedPermissionTypes } from '../permissions';
 import { Permissions } from '../permissions';
 import type { ToJSONSerializable } from '../utils/conversion';
 import Block, { AdjustMethod } from '.';
 import { Certificate, CertificateBundle, CertificateHash } from '../utils/certificate';
+import type { MultisigConfig } from '../ledger/types';
 /**
  * All supported operations
  */
@@ -110,6 +111,20 @@ declare const BlockOperationASN1SchemaBase: {
     readonly CREATE_IDENTIFIER: [{
         readonly name: "identifier";
         readonly schema: typeof ValidateASN1.IsOctetString;
+    }, {
+        readonly name: "createArguments";
+        readonly schema: {
+            readonly optional: {
+                readonly choice: [{
+                    readonly type: "context";
+                    readonly kind: "explicit";
+                    readonly value: 7;
+                    readonly contains: readonly [{
+                        readonly sequenceOf: typeof ValidateASN1.IsOctetString;
+                    }, typeof ValidateASN1.IsInteger];
+                }];
+            };
+        };
     }];
     readonly TOKEN_ADMIN_SUPPLY: [{
         readonly name: "amount";
@@ -264,9 +279,16 @@ declare class BlockOperationSET_REP extends BlockOperation implements BlockJSONO
 /**
  * TokenCreate Operation
  */
+interface BaseIdentifierCreateArguments<KeyType extends IdentifierKeyAlgorithm> {
+    type: KeyType;
+}
+interface MultiSigIdentifierCreateArguments extends BaseIdentifierCreateArguments<AccountKeyAlgorithm.MULTISIG>, MultisigConfig {
+}
+export type IdentifierCreateArguments = MultiSigIdentifierCreateArguments;
 export interface BlockJSONOperationCREATE_IDENTIFIER extends BlockJSONOperation {
     type: OperationType.CREATE_IDENTIFIER;
     identifier: IdentifierAddress | string;
+    createArguments?: ToJSONSerializable<IdentifierCreateArguments> | IdentifierCreateArguments;
 }
 declare class BlockOperationCREATE_IDENTIFIER extends BlockOperation implements BlockJSONOperationCREATE_IDENTIFIER {
     #private;
@@ -275,6 +297,8 @@ declare class BlockOperationCREATE_IDENTIFIER extends BlockOperation implements
     constructor(input: BlockJSONOperationCREATE_IDENTIFIER);
     set identifier(identifier: string | IdentifierAddress);
     get identifier(): IdentifierAddress;
+    set createArguments(input: IdentifierCreateArguments | ToJSONSerializable<IdentifierCreateArguments> | undefined);
+    get createArguments(): IdentifierCreateArguments | undefined;
     validate(context: BlockOperationValidateContext): void;
     toJSON(): BlockJSONOperationCREATE_IDENTIFIER;
 }
@@ -441,7 +465,11 @@ export declare function ExportBlockOperations(operations: BlockOperations[]): ((
     value: OperationType.MODIFY_PERMISSIONS;
     kind: "explicit";
 }) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
-    contains: [Buffer];
+    contains: [Buffer, (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+        contains: [Buffer[], bigint];
+        value: 7;
+        kind: "explicit";
+    }) | undefined];
     value: OperationType.CREATE_IDENTIFIER;
     kind: "explicit";
 }) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {

package/lib/error/block.d.ts

@@ -1,6 +1,6 @@
 import { KeetaNetError } from '.';
 declare const BlockErrorType: "BLOCK";
-declare const BlockErrorCodes: readonly ["INVALID_TYPE", "INVALID_VERSION", "NO_MULTIPLE_SET_REP", "IDENTIFIER_NEED_DEFAULT_PERMISSIONS", "CANNOT_SEND_NON_TOKEN", "TOKEN_RECEIVE_DIFFERS", "ONLY_TOKEN_OP", "ONLY_IDENTIFIER_OP", "NO_TOKEN_OP", "NO_IDENTIFIER_OP", "NO_MULTISIG_OP", "IDENTIFIER_INVALID", "GENERAL_FIELD_INVALID", "PERMISSIONS_INVALID_DEFAULT", "PERMISSIONS_INVALID_ENTITY", "PERMISSIONS_INVALID_PRINCIPAL", "PERMISSIONS_INVALID_TARGET", "INVALID_ACCOUNT_TYPE", "NO_ADMIN_ON_TARGET", "PREVIOUS_SELF", "NO_DELEGATE_ADMIN", "NO_MODIFY_PERMISSION_DUPE", "CANNOT_FORWARD_TO_SELF", "EXACT_TRUE_WHEN_FORWARDING", "CERTIFICATE_SUBJECT_MISMATCH", "NO_DUPLICATE_CERTIFICATE_OPERATION", "INTERMEDIATE_CERTIFICATES_ONLY_ADD", "INVALID_CERTIFICATE_VALUE", "EXTERNAL_TOO_LONG", "EXTERNAL_INVALID", "EXTERNAL_MISSING", "SUPPLY_INVALID"];
+declare const BlockErrorCodes: readonly ["INVALID_TYPE", "INVALID_VERSION", "NO_MULTIPLE_SET_REP", "IDENTIFIER_NEED_DEFAULT_PERMISSIONS", "CANNOT_SEND_NON_TOKEN", "TOKEN_RECEIVE_DIFFERS", "ONLY_TOKEN_OP", "ONLY_IDENTIFIER_OP", "NO_TOKEN_OP", "NO_IDENTIFIER_OP", "INVALID_SIGNER", "INVALID_PURPOSE_VALIDATION", "INVALID_MULTISIG_QUORUM", "INVALID_MULTISIG_SIGNER_DEPTH", "INVALID_MULTISIG_SIGNER_COUNT", "INVALID_MULTISIG_SIGNER_DUPLICATE", "INVALID_CREATE_IDENTIFIER_ARGS", "NO_MULTISIG_OP", "IDENTIFIER_INVALID", "GENERAL_FIELD_INVALID", "PERMISSIONS_INVALID_DEFAULT", "PERMISSIONS_INVALID_ENTITY", "PERMISSIONS_INVALID_PRINCIPAL", "PERMISSIONS_INVALID_TARGET", "INVALID_ACCOUNT_TYPE", "NO_ADMIN_ON_TARGET", "PREVIOUS_SELF", "NO_DELEGATE_ADMIN", "NO_MODIFY_PERMISSION_DUPE", "CANNOT_FORWARD_TO_SELF", "EXACT_TRUE_WHEN_FORWARDING", "CERTIFICATE_SUBJECT_MISMATCH", "NO_DUPLICATE_CERTIFICATE_OPERATION", "INTERMEDIATE_CERTIFICATES_ONLY_ADD", "INVALID_CERTIFICATE_VALUE", "EXTERNAL_TOO_LONG", "EXTERNAL_INVALID", "EXTERNAL_MISSING", "SUPPLY_INVALID"];
 export type BlockErrorCode = `${typeof BlockErrorType}_${typeof BlockErrorCodes[number]}`;
 export default class KeetaNetBlockError extends KeetaNetError {
     static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetBlockError;

package/lib/error/certificate.d.ts

@@ -1,6 +1,6 @@
 import { KeetaNetError } from '.';
 declare const CertificateErrorType: "CERTIFICATE";
-declare const BlockErrorCodes: readonly ["DUPLICATE_INCLUDED", "ORPHAN_FOUND", "CYCLE_FOUND", "SECONDARY_GRAPH"];
+declare const BlockErrorCodes: readonly ["DUPLICATE_INCLUDED", "ORPHAN_FOUND", "CYCLE_FOUND", "SECONDARY_GRAPH", "MISSING_FIELD", "SIGNATURE_ALGORITHM_MISMATCH", "SELF_SIGNED_VALIDATION_FAILED", "CHAIN_VERIFICATION_FAILED", "DUPLICATE_EXTENSION", "EXTENSION_NOT_PROCESSED", "INVALID_SIGNATURE_ALGORITHM", "INVALID_GRAPH_COUNT", "MOMENT_INVALID", "INVALID_VERSION"];
 export type CertificateErrorCode = `${typeof CertificateErrorType}_${typeof BlockErrorCodes[number]}`;
 export default class KeetaNetCertificateError extends KeetaNetError {
     static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetCertificateError;

package/lib/error/ledger.d.ts

@@ -1,6 +1,6 @@
 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"];
+declare const LedgerErrorCodes: readonly ["BLOCK_ALREADY_EXISTS", "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", "MISSING_BLOCKS", "FEE_AMOUNT_MISMATCH", "FEE_TOKEN_MISMATCH", "FEE_MISSING", "MISSING_REQUIRED_FEE_BLOCK", "PERM_VOTE_WITH_QUOTE", "QUOTE_MISMATCH", "REQUIRED_FEE_MISMATCH"];
 export type LedgerErrorCode = `${typeof LedgerErrorType}_${typeof LedgerErrorCodes[number]}`;
 export declare class KeetaNetLedgerError extends KeetaNetError {
     static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetLedgerError;

package/lib/error/vote.d.ts

@@ -1,6 +1,6 @@
 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_DATA", "MALFORMED_VOTE_EXTENSIONS_VALUE", "MALFORMED_VOTE_EXTENSIONS_VALUE_OID", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER", "MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE", "MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME", "MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION", "MALFORMED_VOTE_SIGNATURE_VALUE", "MALFORMED_VOTE_NO_BLOCKS_FOUND", "MALFORMED_STAPLE", "MALFORMED_STAPLE_BLOCKS", "MALFORMED_STAPLE_BLOCKS_AT_LEAST_ONE", "MALFORMED_STAPLE_VOTES", "MALFORMED_STAPLE_VOTES_AT_LEAST_ONE", "MALFORMED_FIND_RDN_INVALID_TYPE", "MALFORMED_FIND_RDN_MUST_HAVE_ONE", "MALFORMED_FIND_RDN_PART_WELL_FORMED", "MALFORMED_FIND_RDN_MUST_BE_SET", "MALFORMED_FIND_RDN_TYPE_MUST_BE_OID", "MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT", "MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE", "MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC", "MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID", "MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE", "MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE", "MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE", "MALFORMED_FEES_AMOUNT", "MALFORMED_FEES_FROM_VOTE_INVALID_INPUT", "MALFORMED_FEES_IN_PERMANENT_VOTE", "MALFORMED_FEES_PAY_TO_INVALID", "MALFORMED_FEES_TOKEN_NOT_TOKEN"];
+declare const VoteErrorCodes: readonly ["SERIAL_MISMATCH", "INVALID_VERSION", "INVALID_CONSTRUCTION", "INVALID_CONSTRUCTION_JSON", "SIGNATURE_INVALID", "EXPIRED", "INVALID_VALIDITY", "MOMENT_BEFORE_VALIDITY_FROM", "STAPLE_INVALID_CONSTRUCTION", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_COUNT", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_MISSING", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_ORDER", "STAPLE_DUPLICATE_VOTE_ISSUER", "STAPLE_PERMANENCE_MISMATCH", "BUILDER_INVALID_CONSTRUCTION", "BUILDER_INVALID_BLOCK_TYPE", "BUILDER_INVALID_SERIAL", "BUILDER_INVALID_VALID_TO_FROM", "MALFORMED_WRAPPER", "MALFORMED_VOTE_WRAPPER", "MALFORMED_VOTE_CONTENT", "MALFORMED_VOTE_CONTENT_EXTRA_DATA", "MALFORMED_VOTE_VERSION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_SIGNATURE_INFORMATION", "MALFORMED_VOTE_ISSUER_INFORMATION", "MALFORMED_VOTE_SUBJECT_INFORMATION", "MALFORMED_VOTE_VALIDITY_INFORMATION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_EXTENSIONS", "MALFORMED_VOTE_EXTENSIONS_DATA", "MALFORMED_VOTE_EXTENSIONS_VALUE", "MALFORMED_VOTE_EXTENSIONS_VALUE_OID", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER", "MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE", "MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME", "MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION", "MALFORMED_VOTE_SIGNATURE_VALUE", "MALFORMED_VOTE_NO_BLOCKS_FOUND", "MALFORMED_STAPLE", "MALFORMED_STAPLE_BLOCKS", "MALFORMED_STAPLE_BLOCKS_AT_LEAST_ONE", "MALFORMED_STAPLE_VOTES", "MALFORMED_STAPLE_VOTES_AT_LEAST_ONE", "MALFORMED_FIND_RDN_INVALID_TYPE", "MALFORMED_FIND_RDN_MUST_HAVE_ONE", "MALFORMED_FIND_RDN_PART_WELL_FORMED", "MALFORMED_FIND_RDN_MUST_BE_SET", "MALFORMED_FIND_RDN_TYPE_MUST_BE_OID", "MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT", "MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE", "MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC", "MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID", "MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE", "MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE", "MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE", "MALFORMED_FEES_AMOUNT", "MALFORMED_FEES_FROM_VOTE_INVALID_INPUT", "MALFORMED_FEES_IN_PERMANENT_VOTE", "MALFORMED_FEES_PAY_TO_INVALID", "MALFORMED_FEES_TOKEN_NOT_TOKEN", "FEE_IS_QUOTE", "FEE_QUOTE_MISSING_FEES", "FEE_NOT_QUOTE", "MALFORMED_FEES_KIND_MISSING", "MALFORMED_FEES_QUOTE_INVALID"];
 export type VoteErrorCode = `${typeof VoteErrorType}_${typeof VoteErrorCodes[number]}`;
 export default class KeetaNetVoteError extends KeetaNetError {
     static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetVoteError;

package/lib/ledger/common.d.ts

@@ -57,6 +57,8 @@ interface ComputeLedgerEffectOptions<T extends boolean, P extends boolean, W ext
     baseToken: TokenAddress;
 }
 export declare function validateSupply(amount: bigint, network: bigint): void;
+export declare function validateBlockSignerCount(amount: bigint, network: bigint): void;
+export declare function validateBlockSignerDepth(depth: bigint, network: bigint): void;
 /**
  * Compute effects on the ledger from block effects
  */
@@ -87,6 +89,7 @@ type AccountInfoUnparsedRow = {
     description?: string;
     metadata?: string;
     supply?: bigint | string;
+    multisigQuorum?: bigint | string;
     defaultBasePermission?: string | bigint | BaseSet;
     defaultExternalPermission?: string | bigint | ExternalSet;
 };
@@ -116,10 +119,20 @@ export declare abstract class LedgerStorageBase {
     }>;
     _formatAccountInfoFromRow(account: GenericAccount, row?: AccountInfoUnparsedRow | undefined): AccountInfo;
     _validateAccountInfoKeys(account: GenericAccount, info: Partial<AccountInfo>): void;
+    /**
+     * @param moment - The date to use as the base for the timestamp.
+     * @param momentBits - The number of bits to use for the timestamp
+     * @param totalLength - The total length of the generated number in bits
+     * @param randomData - A hexadecimal string to use as the random data.
+     * @param timestampFuzzMS - The number of milliseconds to fuzz the timestamp by, defaults to 1n (precise).
+     * @param optimistic - If true, the timestamp will be incremented by 1 quanta, defaults to false.
+     * @returns A bigint representing the noisy timestamp.
+     */
+    _generateNoisyTimestamp(moment: Date, momentBits: bigint, totalLength: bigint, randomData: Buffer, timestampFuzzMS?: number | bigint, optimistic?: boolean): bigint;
     getHeadBlock(transaction: any, account: GenericAccount, from: LedgerSelector): Promise<Block | null>;
     getVotesFromPrevious(transaction: any, prevBlock: BlockHash, from: LedgerSelector, issuer?: Account): Promise<Vote[] | null>;
     protected abstract gcBatch(transaction: any): Promise<boolean>;
-    gc(transaction: any): Promise<boolean>;
+    gc(transaction: any, timeLimitMS?: number): Promise<boolean>;
 }
 export declare function assertLedgerStorage(value: string): LedgerStorage;
 export {};

package/lib/ledger/db_dynamodb.d.ts

@@ -3,11 +3,11 @@ 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, LedgerStorageTransactionBase } from '../ledger';
+import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions } from '../ledger';
+import { LedgerStorageTransactionBase } from '../ledger';
 import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
 import { LedgerStorageBase } from './common';
 import type { ComputedEffectOfBlocks } from './effects';
-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"];
@@ -22,13 +22,9 @@ export interface DynamoDBConfig {
     transactionSize?: number;
     batchUpdateSize?: number;
 }
-declare class DynamoDBTransaction implements LedgerStorageTransactionBase {
+declare class DynamoDBTransaction extends LedgerStorageTransactionBase {
     #private;
-    readonly node: Node | undefined;
-    readonly moment: Date;
-    readonly identifier: string;
-    readonly readOnly: boolean;
-    constructor(config: DynamoDBConfig, ledger: Ledger, log: LedgerConfig['log'], dbDynamoDB: DBDynamoDB, transactionBase: LedgerStorageTransactionBase);
+    constructor(config: DynamoDBConfig, ledger: Ledger, log: LedgerConfig['log'], dbDynamoDB: DBDynamoDB, transactionBase: LedgerStorageTransactionBaseOptions);
     commit(): Promise<void>;
     abort(): Promise<void>;
     delegatedWeight(rep?: Account | InstanceType<typeof Account.Set>): Promise<bigint>;
@@ -41,7 +37,7 @@ declare class DynamoDBTransaction implements LedgerStorageTransactionBase {
     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[]>;
+    getHistory(account: GenericAccount | null, start: VoteBlockHash | null, limit: number): Promise<VoteBlockHash[]>;
     getVotesFromMultiplePrevious(prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
         [hash: string]: Vote[] | null;
     }>;
@@ -72,7 +68,7 @@ export declare class DBDynamoDB extends LedgerStorageBase implements LedgerStora
         createTables: (config: DynamoDBConfig) => Promise<void>;
     };
     init(config: LedgerConfig, ledger: Ledger): void;
-    beginTransaction(transactionBase: LedgerStorageTransactionBase): Promise<DynamoDBTransaction>;
+    beginTransaction(transactionBase: LedgerStorageTransactionBaseOptions): Promise<DynamoDBTransaction>;
     commitTransaction(transaction: DynamoDBTransaction): Promise<void>;
     abortTransaction(transaction: DynamoDBTransaction): Promise<void>;
     evaluateError(error: any): Promise<any>;
@@ -86,7 +82,7 @@ export declare class DBDynamoDB extends LedgerStorageBase implements LedgerStora
     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[]>;
+    getHistory(transaction: DynamoDBTransaction, account: GenericAccount | null, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
     getVotesFromMultiplePrevious(transaction: DynamoDBTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
         [hash: string]: Vote[] | null;
     }>;

package/lib/ledger/db_postgres.d.ts

@@ -3,7 +3,8 @@ 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, LedgerStorageTransactionBase } from '../ledger';
+import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions } from '../ledger';
+import { LedgerStorageTransactionBase } from '../ledger';
 import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
 import { LedgerStorageBase } from './common';
 import type { PoolClient as PostgresPoolClient } from 'pg';
@@ -11,9 +12,10 @@ import { Pool as PostgresPool } from 'pg';
 import type { ComputedEffectOfBlocks } from './effects';
 import LedgerRequestCache from './cache';
 import type { CertificateHash } from '../utils/certificate';
-interface PostgresTransaction extends LedgerStorageTransactionBase {
+declare class PostgresTransaction extends LedgerStorageTransactionBase {
     client: PostgresPoolClient;
     cache: LedgerRequestCache;
+    constructor(transactionBase: LedgerStorageTransactionBaseOptions, db: PostgresPoolClient);
 }
 interface PostgresSelectOptions {
     forUpdate?: boolean;
@@ -24,7 +26,7 @@ export declare class DBPostgres extends LedgerStorageBase implements LedgerStora
     constructor();
     init(config: LedgerConfig, ledger: Ledger): void;
     destroy(): Promise<void>;
-    beginTransaction(transactionBase: LedgerStorageTransactionBase): Promise<PostgresTransaction>;
+    beginTransaction(transactionBase: LedgerStorageTransactionBaseOptions): Promise<PostgresTransaction>;
     commitTransaction(transaction: PostgresTransaction): Promise<void>;
     abortTransaction(transaction: PostgresTransaction): Promise<void>;
     cache(transaction: PostgresTransaction): LedgerRequestCache;
@@ -45,9 +47,15 @@ export declare class DBPostgres extends LedgerStorageBase implements LedgerStora
     adjust(transaction: PostgresTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean, completedStaples?: Set<string>): Promise<VoteStaple[]>;
     getBlock(transaction: PostgresTransaction, block: BlockHash, from: LedgerSelector): Promise<Block | null>;
     getBlockHeight(transaction: PostgresTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
+    getBlockHeights(transaction: PostgresTransaction, toFetch: {
+        blockHash: BlockHash;
+        account: GenericAccount;
+    }[]): Promise<{
+        [blockHash: string]: 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[]>;
+    getHistory(transaction: PostgresTransaction, account: GenericAccount | null, 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;

package/lib/ledger/db_spanner.d.ts

@@ -4,15 +4,14 @@ 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, LedgerStorageTransactionBase } from '../ledger';
+import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions } from '../ledger';
+import { LedgerStorageTransactionBase } from '../ledger';
 import type { AccountInfo, ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates } from './types';
 import type { KVStorageProviderAPI } from '../kv';
 import { LedgerStorageBase } from './common';
-import Stats from '../stats';
 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 = {
@@ -33,15 +32,10 @@ type SpannerReadResponse<T extends TableName, C extends TableColumn<T>[]> = {
 interface SpannerTransactionOptions {
     strongRead?: boolean;
 }
-export declare class SpannerTransaction implements LedgerStorageTransactionBase {
+export declare class SpannerTransaction extends 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, transactionBase: LedgerStorageTransactionBase);
+    constructor(database: GoogleSpannerDatabase, options: SpannerTransactionOptions, transactionBase: LedgerStorageTransactionBaseOptions);
     evaluateError(error: any): any;
     beginTransaction(identifier: string, strongRead?: boolean): Promise<void>;
     endTransaction(mode: 'COMMIT' | 'ROLLBACK'): Promise<void>;
@@ -49,7 +43,6 @@ export declare class SpannerTransaction implements LedgerStorageTransactionBase
     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
@@ -69,7 +62,7 @@ export declare class DBSpanner extends LedgerStorageBase implements LedgerStorag
     constructor();
     init(config: LedgerConfig, ledger: Ledger): void;
     destroy(): Promise<void>;
-    beginTransaction(transactionBase: LedgerStorageTransactionBase): Promise<SpannerTransaction>;
+    beginTransaction(transactionBase: LedgerStorageTransactionBaseOptions): Promise<SpannerTransaction>;
     commitTransaction(transaction: SpannerTransaction): Promise<void>;
     abortTransaction(transaction: SpannerTransaction): Promise<void>;
     evaluateError(error: any): Promise<any>;
@@ -93,7 +86,7 @@ export declare class DBSpanner extends LedgerStorageBase implements LedgerStorag
     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[]>;
+    getHistory(transaction: SpannerTransaction, account: GenericAccount | null, 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;