Class Ledger

The core Ledger components

Implements

Omit<LedgerAtomicInterface, "commit" | "abort">

Constructors

constructor

new Ledger(
    config: LedgerConfig,
    node?: Node,
    existingStorage?: LedgerStorageAPI,
): Ledger
Parameters
- config: LedgerConfig
- Optionalnode: Node
- OptionalexistingStorage: LedgerStorageAPI
Returns Ledger

Properties

`Readonly`baseToken

baseToken: TokenAddress

`Readonly`initialTrustedAccount

initialTrustedAccount: Account

`Readonly`networkAddress

networkAddress: NetworkAddress

`Optional` `Readonly`node

node?: Node

`Static`isInstance

isInstance: (obj: any, strict?: boolean) => obj is Ledger = ...

`Static`Kind

Kind: typeof LedgerKind = LedgerKind

Accessors

ledgerWriteMode

get ledgerWriteMode(): NonNullable<
    undefined
    | "bootstrap-only"
    | "read-only"
    | "read-write"
    | "no-voting",
>
Returns NonNullable<
    undefined
    | "bootstrap-only"
    | "read-only"
    | "read-write"
    | "no-voting",
>

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>
Implementation of Omit._testingRunStorageFunction

add

add(...args: [votesAndBlocks: VoteStaple, from?: string]): Promise<VoteStaple[]>
Parameters
- ...args: [votesAndBlocks: VoteStaple, from?: string]
Returns Promise<VoteStaple[]>
Implementation of Omit.add

beginTransaction

beginTransaction(
identifier: string,
readOnly?: boolean,
): Promise<LedgerAtomicInterface>
Parameters
- identifier: string
- readOnly: boolean = false
Returns Promise<LedgerAtomicInterface>

copy

copy(newNode: Node): Ledger
Parameters
- newNode: Node
Returns Ledger

gc

gc(...args: [timeLimitMS?: number]): Promise<boolean>
Parameters
- ...args: [timeLimitMS?: number]
Returns Promise<boolean>
Implementation of Omit.gc

getAccountCertificateByHash

getAccountCertificateByHash(
...args: [account: GenericAccount, hash: CertificateHash],
): Promise<null | CertificateWithIntermediates>
Parameters
- ...args: [account: GenericAccount, hash: CertificateHash]
Returns Promise<null | CertificateWithIntermediates>
Implementation of Omit.getAccountCertificateByHash

getAccountCertificates

getAccountCertificates(
...args: [account: GenericAccount],
): Promise<CertificateWithIntermediates[]>
Parameters
- ...args: [account: GenericAccount]
Returns Promise<CertificateWithIntermediates[]>
Implementation of Omit.getAccountCertificates

getAccountInfo

getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(
account: string | Account<T>,
): Promise<AccountInfoForType<T>>
Type Parameters
- T extends AccountKeyAlgorithm = AccountKeyAlgorithm
Parameters
- account: string | Account<T>
Returns Promise<AccountInfoForType<T>>
Implementation of Omit.getAccountInfo

getAccountRep

getAccountRep(
...args: [account: string | Account<KeyPairKeyAlgorithm>],
): Promise<null | Account<KeyPairKeyAlgorithm>>
Parameters
- ...args: [account: string | Account<KeyPairKeyAlgorithm>]
Returns Promise<null | Account<KeyPairKeyAlgorithm>>
Implementation of Omit.getAccountRep

getAccountsBlockHeightInfo

getAccountsBlockHeightInfo(
    ...args: [toFetch: { account: GenericAccount; blockHash?: BlockHash }[]],
): Promise<
    {
        [account: string]: | null
        | { blockHash: BlockHash; height: null
        | bigint };
    },
>
Parameters
- ...args: [toFetch: { account: GenericAccount; blockHash?: BlockHash }[]]
Returns Promise<
    {
        [account: string]: | null
        | { blockHash: BlockHash; height: null
        | bigint };
    },
>
Implementation of Omit.getAccountsBlockHeightInfo

getAllBalances

getAllBalances(
...args: [account: GenericAccount],
): Promise<GetAllBalancesResponse>
Parameters
- ...args: [account: GenericAccount]
Returns Promise<GetAllBalancesResponse>
Implementation of Omit.getAllBalances

getBalance

getBalance(
...args: [account: GenericAccount, token: TokenAddress],
): Promise<bigint>
Parameters
- ...args: [account: GenericAccount, token: TokenAddress]
Returns Promise<bigint>
Implementation of Omit.getBalance

getBlock

getBlock(
...args: [blockhash: BlockHash, from: LedgerSelector],
): Promise<null | Block>
Parameters
- ...args: [blockhash: BlockHash, from: LedgerSelector]
Returns Promise<null | Block>
Implementation of Omit.getBlock

getBlockFromIdempotent

getBlockFromIdempotent(
    ...args: [
        account: GenericAccount,
        idempotent: string
        | Buffer,
        from: LedgerSelector,
        excludeBlockHash?: BlockHash,
    ],
): Promise<null | Block>
Parameters
- ...args: [
      account: GenericAccount,
      idempotent: string
      | Buffer,
      from: LedgerSelector,
      excludeBlockHash?: BlockHash,
  ]
Returns Promise<null | Block>
Implementation of Omit.getBlockFromIdempotent

getBlockFromPrevious

getBlockFromPrevious(
...args: [block: BlockHash, from: LedgerSelector],
): Promise<null | Block>
Parameters
- ...args: [block: BlockHash, from: LedgerSelector]
Returns Promise<null | Block>
Implementation of Omit.getBlockFromPrevious

getFee

getFee(
...args: [blocks: Block[], effectsInput?: ComputedEffectOfBlocks],
): Promise<null | FeeAmountAndToken | FeeAmountAndToken[]>
Parameters
- ...args: [blocks: Block[], effectsInput?: ComputedEffectOfBlocks]
Returns Promise<null | FeeAmountAndToken | FeeAmountAndToken[]>
Implementation of Omit.getFee

getFeePayToAndToken

getFeePayToAndToken(
accounts?: (Account<KeyPairKeyAlgorithm> | StorageAddress)[],
token?: TokenAddress,
): Partial<FeeAmountAndToken>
Parameters
- Optionalaccounts: (Account<KeyPairKeyAlgorithm> | StorageAddress)[]
- Optionaltoken: TokenAddress
Returns Partial<FeeAmountAndToken>

getHeadBlock

getHeadBlock(
...args: [account: GenericAccount, from: LedgerSelector],
): Promise<null | Block>
Parameters
- ...args: [account: GenericAccount, from: LedgerSelector]
Returns Promise<null | Block>
Implementation of Omit.getHeadBlock

getHeadBlocks

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

getHistory

getHistory(
    ...args: [
        account: null
        | GenericAccount,
        start: null | VoteBlockHash,
        limit: number,
    ],
): Promise<VoteStaple[]>
Parameters
- ...args: [account: null | GenericAccount, start: null | VoteBlockHash, limit: number]
Returns Promise<VoteStaple[]>
Implementation of Omit.getHistory

getIdempotentBlockHash

getIdempotentBlockHash(
    ...args: [
        account: GenericAccount,
        idempotent: string
        | Buffer,
        from: LedgerSelector,
        excludeBlockHash?: BlockHash,
    ],
): Promise<null | BlockHash>
Parameters
- ...args: [
      account: GenericAccount,
      idempotent: string
      | Buffer,
      from: LedgerSelector,
      excludeBlockHash?: BlockHash,
  ]
Returns Promise<null | BlockHash>
Implementation of Omit.getIdempotentBlockHash

getStaplesFromBlockHashes

getStaplesFromBlockHashes(...args: [hashes: BlockHash[]]): Promise<VoteStaple[]>
Parameters
- ...args: [hashes: BlockHash[]]
Returns Promise<VoteStaple[]>
Implementation of Omit.getStaplesFromBlockHashes

getVotes

getVotes(
...args: [block: BlockHash, from: LedgerStorage],
): Promise<null | Vote[]>
Parameters
- ...args: [block: BlockHash, from: LedgerStorage]
Returns Promise<null | Vote[]>
Implementation of Omit.getVotes

getVotesFromMultiplePrevious

getVotesFromMultiplePrevious(
    ...args: [
        prevBlocks: BlockHash[],
        from: LedgerSelector,
        issuer?: Account<KeyPairKeyAlgorithm>,
    ],
): Promise<{ [hash: string]: null | Vote[] }>
Parameters
- ...args: [
      prevBlocks: BlockHash[],
      from: LedgerSelector,
      issuer?: Account<KeyPairKeyAlgorithm>,
  ]
Returns Promise<{ [hash: string]: null | Vote[] }>
Implementation of Omit.getVotesFromMultiplePrevious

getVoteStaple

getVoteStaple(
...args: [stapleBlockHash: VoteBlockHash, from: LedgerSelector],
): Promise<null | VoteStaple>
Parameters
- ...args: [stapleBlockHash: VoteBlockHash, from: LedgerSelector]
Returns Promise<null | VoteStaple>
Implementation of Omit.getVoteStaple

getVoteStaples

getVoteStaples(
...args: [stapleBlockHashes: VoteBlockHash[], from: LedgerSelector],
): Promise<VoteBlockHashMap<null | VoteStaple>>
Parameters
- ...args: [stapleBlockHashes: VoteBlockHash[], from: LedgerSelector]
Returns Promise<VoteBlockHashMap<null | VoteStaple>>
Implementation of Omit.getVoteStaples

getVoteStaplesAfter

getVoteStaplesAfter(
...args: [moment: Date, limit: number, options: GetVotesAfterOptions],
): Promise<VoteStaple[]>
Parameters
- ...args: [moment: Date, limit: number, options: GetVotesAfterOptions]
Returns Promise<VoteStaple[]>
Implementation of Omit.getVoteStaplesAfter

listACLsByEntity

listACLsByEntity(...args: [entity: GenericAccount]): Promise<ACLRow[]>
Parameters
- ...args: [entity: GenericAccount]
Returns Promise<ACLRow[]>
Implementation of Omit.listACLsByEntity

listACLsByPrincipal

listACLsByPrincipal(
...args: [principal: GenericAccount, entityList?: GenericAccount[]],
): Promise<ACLRow[]>
Parameters
- ...args: [principal: GenericAccount, entityList?: GenericAccount[]]
Returns Promise<ACLRow[]>
Implementation of Omit.listACLsByPrincipal

quote

quote(...args: [blocks: Block[]]): Promise<VoteQuote>
Parameters
- ...args: [blocks: Block[]]
Returns Promise<VoteQuote>
Implementation of Omit.quote

run

run<T>(
    identifier: string,
    code: (transaction: LedgerAtomicInterface) => Promise<T>,
    readOnly?: boolean,
): Promise<T>
Execute some code with a transaction held, if the code fails the transaction is aborted, otherwise it is committed
Type Parameters
- T
Parameters
- identifier: string
- code: (transaction: LedgerAtomicInterface) => Promise<T>
  Code to run
- OptionalreadOnly: boolean
Returns Promise<T>
The return value from "code"

runReadOnly

runReadOnly<T>(
identifier: string,
code: (transaction: LedgerAtomicInterface) => Promise<T>,
): Promise<T>
Type Parameters
- T
Parameters
- identifier: string
- code: (transaction: LedgerAtomicInterface) => Promise<T>
Returns Promise<T>

stats

stats(): Promise<LedgerStatistics>
Returns Promise<LedgerStatistics>

vote

vote(
...args: [blocks: Block[], otherVotes?: Vote[], quote?: VoteQuote],
): Promise<Vote>
Parameters
- ...args: [blocks: Block[], otherVotes?: Vote[], quote?: VoteQuote]
Returns Promise<Vote>
Implementation of Omit.vote

votingPower

votingPower(...args: [rep?: Account<KeyPairKeyAlgorithm>]): Promise<bigint>
Parameters
- ...args: [rep?: Account<KeyPairKeyAlgorithm>]
Returns Promise<bigint>
Implementation of Omit.votingPower

Class Ledger

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns Ledger

Properties

ReadonlybaseToken

ReadonlyinitialTrustedAccount

ReadonlynetworkAddress

Optional Readonlynode

StaticisInstance

StaticKind

Accessors

ledgerWriteMode

Returns NonNullable< undefined | "bootstrap-only" | "read-only" | "read-write" | "no-voting",>

Methods

_testingRunStorageFunction

Type Parameters

Parameters

Returns Promise<T>

add

Parameters

Returns Promise<VoteStaple[]>

beginTransaction

Parameters

Returns Promise<LedgerAtomicInterface>

copy

Parameters

Returns Ledger

gc

Parameters

Returns Promise<boolean>

getAccountCertificateByHash

Parameters

Returns Promise<null | CertificateWithIntermediates>

getAccountCertificates

Parameters

Returns Promise<CertificateWithIntermediates[]>

getAccountInfo

Type Parameters

Parameters

Returns Promise<AccountInfoForType<T>>

getAccountRep

Parameters

Returns Promise<null | Account<KeyPairKeyAlgorithm>>

getAccountsBlockHeightInfo

Parameters

Returns Promise< { [account: string]: | null | { blockHash: BlockHash; height: null | bigint }; },>

getAllBalances

Parameters

Returns Promise<GetAllBalancesResponse>

getBalance

Parameters

Returns Promise<bigint>

getBlock

Parameters

Returns Promise<null | Block>

getBlockFromIdempotent

Parameters

Returns Promise<null | Block>

getBlockFromPrevious

Parameters

Returns Promise<null | Block>

getFee

Parameters

Returns Promise<null | FeeAmountAndToken | FeeAmountAndToken[]>

getFeePayToAndToken

Parameters

Returns Partial<FeeAmountAndToken>

getHeadBlock

Parameters

Returns Promise<null | Block>

getHeadBlocks

Parameters

`Readonly`baseToken

`Readonly`initialTrustedAccount

`Readonly`networkAddress

`Optional` `Readonly`node

`Static`isInstance

`Static`Kind

Returns NonNullable<
undefined
| "bootstrap-only"
| "read-only"
| "read-write"
| "no-voting",
>

Returns Promise<
{
[account: string]: | null
| { blockHash: BlockHash; height: null
| bigint };
},
>