Class LedgerAtomicInterface

new LedgerAtomicInterface(
    transaction: LedgerStorageTransactionBase,
    storage: LedgerStorageAPI,
    config: LedgerConfig,
    ledger: Ledger,
): LedgerAtomicInterface

_testingRunStorageFunction<T>(
    code: (
        storage: LedgerStorageAPI,
        transaction: LedgerStorageTransactionBase,
    ) => Promise<T>,
): Promise<T>

abort(): Promise<void>

add(votesAndBlocks: VoteStaple, from?: string): Promise<VoteStaple[]>

commit(): Promise<void>

gc(timeLimitMS?: number): Promise<boolean>

getAccountCertificateByHash(
    account: GenericAccount,
    hash: CertificateHash,
): Promise<null | CertificateWithIntermediates>

getAccountCertificates(
    account: GenericAccount,
): Promise<CertificateWithIntermediates[]>

getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(
    account: string | Account<T>,
): Promise<AccountInfoForType<T>>

getAccountRep(
    account: string | Account<KeyPairKeyAlgorithm>,
): Promise<null | Account<KeyPairKeyAlgorithm>>

getAccountsBlockHeightInfo(
    toFetch: { account: GenericAccount; blockHash?: BlockHash }[],
): Promise<
    {
        [account: string]: | null
        | { blockHash: BlockHash; height: null
        | bigint };
    },
>

getAllBalances(account: GenericAccount): Promise<GetAllBalancesResponse>

getBalance(account: GenericAccount, token: TokenAddress): Promise<bigint>

getBlock(blockhash: BlockHash, from?: LedgerSelector): Promise<null | Block>

getBlockFromIdempotent(
    account: GenericAccount,
    idempotent: string | Buffer,
    from?: LedgerSelector,
    excludeBlockHash?: BlockHash,
): Promise<null | Block>

getBlockFromPrevious(
    block: BlockHash,
    from: LedgerSelector,
): Promise<null | Block>

getFee(
    blocks: Block[],
    effectsInput?: ComputedEffectOfBlocks,
): Promise<null | FeeAmountAndToken | FeeAmountAndToken[]>

getHeadBlock(
    account: GenericAccount,
    from: LedgerSelector,
): Promise<null | Block>

getHeadBlocks(
    accounts: GenericAccount[],
    from: LedgerSelector,
): Promise<{ [account: string]: null | Block }>

getHistory(
    account: null | GenericAccount,
    start: null | VoteBlockHash,
    limit?: number,
): Promise<VoteStaple[]>

getIdempotentBlockHash(
    account: GenericAccount,
    idempotent: string | Buffer,
    from?: LedgerSelector,
    excludeBlockHash?: BlockHash,
): Promise<null | BlockHash>

getStaplesFromBlockHashes(hashes: BlockHash[]): Promise<VoteStaple[]>

getVotes(block: BlockHash, from?: LedgerStorage): Promise<null | Vote[]>

getVotesFromMultiplePrevious(
    prevBlocks: BlockHash[],
    from?: LedgerSelector,
    issuer?: Account<KeyPairKeyAlgorithm>,
): Promise<{ [hash: string]: null | Vote[] }>

getVoteStaple(
    stapleBlockHash: VoteBlockHash,
    from?: LedgerSelector,
): Promise<null | VoteStaple>

getVoteStaples(
    stapleBlockHashes: VoteBlockHash[],
    from?: LedgerSelector,
): Promise<VoteBlockHashMap<null | VoteStaple>>

getVoteStaplesAfter(
    moment: Date,
    limit?: number,
    options?: GetVotesAfterOptions,
): Promise<VoteStaple[]>

listACLsByEntity(entity: GenericAccount): Promise<ACLRow[]>

listACLsByPrincipal(
    principal: GenericAccount,
    entityList?: GenericAccount[],
): Promise<ACLRow[]>

quote(blocks: Block[]): Promise<VoteQuote>

vote(blocks: Block[], otherVotes?: Vote[], quote?: VoteQuote): Promise<Vote>

votingPower(rep?: Account<KeyPairKeyAlgorithm>): Promise<bigint>