Class LedgerAtomicInterface

Atomic transactional interface to a storage backend

Constructors

constructor

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

Methods

_testingRunStorageFunction

_testingRunStorageFunction<T>(
    code: (
        storage: LedgerStorageAPI,
        transaction: LedgerStorageTransactionBase,
    ) => Promise<T>,
): Promise<T>
Type Parameters
- T
Parameters
- code: (
  storage: LedgerStorageAPI,
  transaction: LedgerStorageTransactionBase,
  ) => Promise<T>
Returns Promise<T>

abort

abort(): Promise<void>
Returns Promise<void>

add

add(votesAndBlocks: VoteStaple, from?: string): Promise<VoteStaple[]>
Parameters
- votesAndBlocks: VoteStaple
- Optionalfrom: string
Returns Promise<VoteStaple[]>

commit

commit(): Promise<void>
Returns Promise<void>

gc

gc(): Promise<boolean>
Returns Promise<boolean>

getAccountCertificateByHash

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

getAccountCertificates

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

getAccountInfo

getAccountInfo(account: string | GenericAccount): Promise<AccountInfo>
Parameters
- account: string | GenericAccount
Returns Promise<AccountInfo>

getAccountRep

getAccountRep(
account: string | Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>,
): Promise<null | Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>>
Parameters
- account: string | Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>
Returns Promise<null | Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>>

getAllBalances

getAllBalances(account: GenericAccount): Promise<GetAllBalancesResponse>
Parameters
- account: GenericAccount
Returns Promise<GetAllBalancesResponse>

getBalance

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

getBlock

getBlock(blockhash: BlockHash, from?: LedgerSelector): Promise<null | Block>
Parameters
- blockhash: BlockHash
- from: LedgerSelector = 'main'
Returns Promise<null | Block>

getBlockFromPrevious

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

getHeadBlock

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

getHeadBlocks

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

getHistory

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

getStaplesFromBlockHashes

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

getVotes

getVotes(block: BlockHash, from?: LedgerStorage): Promise<null | Vote[]>
Parameters
- block: BlockHash
- from: LedgerStorage = 'main'
Returns Promise<null | Vote[]>

getVotesFromMultiplePrevious

getVotesFromMultiplePrevious(
    prevBlocks: BlockHash[],
    from?: LedgerSelector,
    issuer?: Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>,
): Promise<{ [hash: string]: null | Vote[] }>
Parameters
- prevBlocks: BlockHash[]
- from: LedgerSelector = 'main'
- Optionalissuer: Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>
Returns Promise<{ [hash: string]: null | Vote[] }>

getVoteStaple

getVoteStaple(
stapleBlockHash: VoteBlockHash,
from?: LedgerSelector,
): Promise<null | VoteStaple>
Parameters
- stapleBlockHash: VoteBlockHash
- from: LedgerSelector = 'main'
Returns Promise<null | VoteStaple>

getVoteStaples

getVoteStaples(
stapleBlockHashes: VoteBlockHash[],
from?: LedgerSelector,
): Promise<VoteBlockHashMap<null | VoteStaple>>
Parameters
- stapleBlockHashes: VoteBlockHash[]
- from: LedgerSelector = 'main'
Returns Promise<VoteBlockHashMap<null | VoteStaple>>

getVoteStaplesAfter

getVoteStaplesAfter(
    moment: Date,
    limit?: number,
    options?: GetVotesAfterOptions,
): Promise<VoteStaple[]>
Parameters
- moment: Date
- limit: number = 1000
- options: GetVotesAfterOptions = {}
Returns Promise<VoteStaple[]>

listACLsByEntity

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

listACLsByPrincipal

listACLsByPrincipal(
principal: GenericAccount,
entityList?: GenericAccount[],
): Promise<ACLRow[]>
Parameters
- principal: GenericAccount
- OptionalentityList: GenericAccount[]
Returns Promise<ACLRow[]>

vote

vote(blocks: Block[], otherVotes?: Vote[]): Promise<Vote>
Parameters
- blocks: Block[]
- OptionalotherVotes: Vote[]
Returns Promise<Vote>

votingPower

votingPower(
rep?: Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>,
): Promise<bigint>
Parameters
- Optionalrep: Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>
Returns Promise<bigint>