@metaplex-foundation/amman

Other

AccountDiff

AccountDiff: Diff<Record<string, any>, Record<string, any>>[]

AmmanAccount

AmmanAccount: { pretty: any }

Type declaration

pretty:function
- pretty(): Record<string, any>
- - Defined in src/types.ts:26
  Returns Record<string, any>

AmmanAccountRendererMap

AmmanAccountRendererMap: Map<any, AmmanRenderAccount>

AmmanConfig

AmmanConfig: { assetsFolder?: string; relay?: RelayConfig; storage?: StorageConfig; streamTransactionLogs?: boolean; validator?: ValidatorConfig }

Amman Config

property: validatorConfig Validator configuration
property: relayConfig Relay configuration
property: storageConfig Mock Storage configuration
property: streamTransactionLogs if true the solana logs command is spawned and its output piped through a prettifier, defaults to run except when in a CI environment

Type declaration

Optional assetsFolder?: string
Optional relay?: RelayConfig
Optional storage?: StorageConfig
Optional streamTransactionLogs?: boolean
Optional validator?: ValidatorConfig

AmmanMockStorageDriverOptions

AmmanMockStorageDriverOptions: { costPerByte?: BN | number; logDebug?: any; logInfo?: any; logTrace?: any }

Type declaration

Optional costPerByte?: BN | number
logDebug?:function
- logDebug(...data: any[]): void
- - Defined in src/storage/mock-driver.ts:30
  Parameters
  - Rest ...data: any[]
  Returns void
logInfo?:function
- logInfo(...data: any[]): void
- - Defined in src/storage/mock-driver.ts:29
  Parameters
  - Rest ...data: any[]
  Returns void
logTrace?:function
- logTrace(...data: any[]): void
- - Defined in src/storage/mock-driver.ts:31
  Parameters
  - Rest ...data: any[]
  Returns void

AmmanRenderAccount

AmmanRenderAccount: (account: any) => string

Type declaration

- (account: any): string
- Parameters
  - account: any
  Returns string

ConfirmedTransactionAsserts

ConfirmedTransactionAsserts: { assertError: any; assertSuccess: any }

Type declaration

assertError:function
- assertError<Err>(t: Assert, errOrRx: RegExp | Err, msgRx?: RegExp): void
- - Defined in src/transactions/types.ts:47
  Type parameters
  - Err: Function
  Parameters
  - t: Assert
  - errOrRx: RegExp | Err
  - Optional msgRx: RegExp
  Returns void
assertSuccess:function
- assertSuccess(t: Assert, msgRxs?: RegExp[]): void
- - Defined in src/transactions/types.ts:52
  Parameters
  - t: Assert
  - Optional msgRxs: RegExp[]
  Returns void

MaybeErrorWithCode

MaybeErrorWithCode: ErrorWithCode | null | undefined

Possibly {@link ErrorWithCode} or None.

RelayAccountState

RelayAccountState: { account: Record<string, any>; accountDiff?: AccountDiff; rendered?: string; renderedDiff?: Change[]; slot: number; timestamp: number }

Type declaration

account: Record<string, any>
Optional accountDiff?: AccountDiff
Optional rendered?: string
Optional renderedDiff?: Change[]
slot: number
timestamp: number

assertErrorMatches

assertErrorMatches<Err>(t: Assert, err: MaybeErrorWithCode, opts?: { msgRx?: RegExp; txSignature?: string; type?: Err }): void

- Defined in src/asserts/index.ts:207
Asserts that the provided error is defined and matches the provided requirements.

If {@link opts.type} is provided the error needs to be of that type. If {@link opts.msgRx} is provided the error message needs match to it.

Type parameters
- Err: Function
Parameters
- t: Assert
- err: MaybeErrorWithCode
  
  error to verify
- opts: { msgRx?: RegExp; txSignature?: string; type?: Err } = {}
  - Optional msgRx?: RegExp
    
    a {@link RegExp} that the error message is expected to match
  - Optional txSignature?: string
  - Optional type?: Err
    
    the type of the error to expect
Returns void

assertTransactionError

assertTransactionError<Err>(t: Assert, details: Pick<ConfirmedTransactionDetails, "txSummary"> & { txSignature?: string }, errOrRx?: RegExp | Err, msgRx?: RegExp): void

- Defined in src/asserts/index.ts:124
Asserts that the provided ConfirmedTransactionDetails has an error that matches the provided requirements.

Provide either an Error to {@link errOrRx} to verify the error type or a {@link RegExp} to only verify the error message. In order to verify both provide an Error to {@link errOrRx} and the {@link RegExp} via {@link msgRx}.

Type parameters
- Err: Function
Parameters
- t: Assert
- details: Pick<ConfirmedTransactionDetails, "txSummary"> & { txSignature?: string }
  
  result of executing a transaction
- Optional errOrRx: RegExp | Err
  
  the type of the error to expect or the {@link msgRx} to match
- Optional msgRx: RegExp
  
  a {@link RegExp} that the error message is expected to match
Returns void

assertTransactionSuccess

assertTransactionSuccess(t: Assert, details: Pick<ConfirmedTransactionDetails, "txSummary"> & { txSignature?: string }, msgRxs?: RegExp[]): void

- Defined in src/asserts/index.ts:85
Asserts that a transaction completed successfully and optionally checks for messages in the transaction logs.

Parameters
- t: Assert
- details: Pick<ConfirmedTransactionDetails, "txSummary"> & { txSignature?: string }
- Optional msgRxs: RegExp[]
Returns void

identifySolanaAddress

identifySolanaAddress(maybeAddress: string): Address | null

- Defined in src/utils/address.ts:55
Parameters
- maybeAddress: string
Returns Address | null

asserts

Assert

Assert: { equal: any; fail: any; match: any; ok: any }

The minimum methods that the first argument passed to assert functions like assertConfirmedTransaction needs to have.

Type declaration

equal:function
- equal(actual: any, expected: any, msg?: string): void
- - Defined in src/asserts/index.ts:17
  Parameters
  - actual: any
  - expected: any
  - Optional msg: string
  Returns void
fail:function
- fail(msg?: string): void
- - Defined in src/asserts/index.ts:19
  Parameters
  - Optional msg: string
  Returns void
match:function
- match(actual: string, expected: RegExp, msg?: string): void
- - Defined in src/asserts/index.ts:20
  Parameters
  - actual: string
  - expected: RegExp
  - Optional msg: string
  Returns void
ok:function
- ok(value: any, msg?: string): void
- - Defined in src/asserts/index.ts:18
  Parameters
  - value: any
  - Optional msg: string
  Returns void

assertConfirmedTransaction

assertConfirmedTransaction(t: Assert, tx: TransactionResponse, args?: { fee?: number }): void

- Defined in src/asserts/index.ts:33
Asserts details about a confirmed transaction

deprecated
use assertTransactionSuccess or assertTransactionError instead

Parameters
- t: Assert
- tx: TransactionResponse
  
  the confirmed transaction to verify
- args: { fee?: number } = {}
  
  specify what details should be verified
  - Optional fee?: number
Returns void

assertError

assertError(t: Assert, err: Error, msgRxs: RegExp[]): void

- Defined in src/asserts/index.ts:157
Asserts that the provided error contains specific information as part of the error message or the attached error logs.

To check for they error type instead use assertErrorMatches instead.

Parameters
- t: Assert
- err: Error
  
  error to verify
- msgRxs: RegExp[]
  
  list of {@link RegExp} which will be matched on the error message or err.logs.
Returns void

assertTransactionSummary

assertTransactionSummary(t: Assert, summary: TransactionSummary, args?: { failed?: boolean; fee?: number; msgRxs?: RegExp[] }): void

- Defined in src/asserts/index.ts:55
Asserts details about a TransactionSummary.

deprecated
use assertTransactionSuccess or assertTransactionError instead

Parameters
- t: Assert
- summary: TransactionSummary
  
  transaction summary to verify
- args: { failed?: boolean; fee?: number; msgRxs?: RegExp[] } = {}
  
  specify what details should be verified
  - Optional failed?: boolean
  - Optional fee?: number
  - Optional msgRxs?: RegExp[]
Returns void

diagnostics

AmmanAccountProvider

AmmanAccountProvider: { byteSize: number | ((args: any) => void); fromAccountInfo: any }

The type that an account provider needs to implement so that amman can deserialize account data.

Type declaration

byteSize: number | ((args: any) => void)
fromAccountInfo:function
- fromAccountInfo(accountInfo: AccountInfo<Buffer>, offset?: number): [AmmanAccount, number]
- - Defined in src/types.ts:35
  Parameters
  - accountInfo: AccountInfo<Buffer>
  - Optional offset: number
  Returns [AmmanAccount, number]

transactions

TransactionHandler

TransactionHandler: { publicKey: PublicKey; sendAndConfirmTransaction: any }

Interface to transaction handlers that can either be backed directly by a payer or can use a wallet.

property: publicKey of payer
property: sendAndConfirmTransaction sends and confirms a transaction

Type declaration

publicKey: PublicKey
sendAndConfirmTransaction:function
- sendAndConfirmTransaction(transaction: Transaction, signers: Signer[], optionsOrLabel?: string | SendOptions, label?: string): Promise<ConfirmedTransactionDetails>
- - Defined in src/transactions/types.ts:112
  Sends and confirms the given transaction after signing it.
  
  Parameters
  - transaction: Transaction
    
    to send
  - signers: Signer[]
    
    with which the transaction should be signed
  - Optional optionsOrLabel: string | SendOptions
    
    either options used to send the transaction or the {@link label}
  - Optional label: string
    
    of the transaction in order to identify it in logs and the amman-explorer
  Returns Promise<ConfirmedTransactionDetails>

TransactionSummary

TransactionSummary: { blockTime: number; fee: number | undefined; logMessages: string[]; loggedError: MaybeErrorWithCode; slot: number; transactionError: TransactionError | null | undefined }

Derived from a {@link ConfirmedTransaction} this summary eases assertions and logging.

property: logMessages obtained from the {@link ConfirmedTransaction['meta']} property
property: fee charged for the transaction execution
property: slot same as {@link ConfirmedTransaction['slot']
property: transactionError obtained from the {@link ConfirmedTransaction['meta']} property

Type declaration

blockTime: number
fee: number | undefined
logMessages: string[]
loggedError: MaybeErrorWithCode
slot: number
transactionError: TransactionError | null | undefined

Const defaultConfirmOptions

defaultConfirmOptions: ConfirmOptions = ...

Default options for sending and confirming a transaction

utils

Const LOCALHOST

LOCALHOST: "http://127.0.0.1:8899" = 'http://127.0.0.1:8899'

URL at which a locally running solana test validator listens on by default

tmpLedgerDir

tmpLedgerDir(testLabel?: string): string

- Defined in src/utils/index.ts:30
Gets the path to a temporary directory in which to store the test validator ledger.

Parameters
- testLabel: string = 'amman-ledger'
  
  label used to name that directory
Returns string

Index

Other

asserts

diagnostics

transactions

utils

Other

AccountDiff

AmmanAccount

Type declaration

pretty:function

Returns Record<string, any>

AmmanAccountRendererMap

AmmanConfig

Type declaration

Optional assetsFolder?: string

Optional relay?: RelayConfig

Optional storage?: StorageConfig

Optional streamTransactionLogs?: boolean

Optional validator?: ValidatorConfig

AmmanMockStorageDriverOptions

Type declaration

Optional costPerByte?: BN | number

logDebug?:function

Parameters

Rest ...data: any[]

Returns void

logInfo?:function

Parameters

Rest ...data: any[]

Returns void

logTrace?:function

Parameters

Rest ...data: any[]

Returns void

AmmanRenderAccount

Type declaration

Parameters

account: any

Returns string

ConfirmedTransactionAsserts

Type declaration

assertError:function

Type parameters

Err: Function

Parameters

t: Assert

errOrRx: RegExp | Err

Optional msgRx: RegExp

Returns void

assertSuccess:function

Parameters

t: Assert

Optional msgRxs: RegExp[]

Returns void

MaybeErrorWithCode

RelayAccountState

Type declaration

account: Record<string, any>

Optional accountDiff?: AccountDiff

Optional rendered?: string

Optional renderedDiff?: Change[]

slot: number

timestamp: number

assertErrorMatches

Type parameters

Err: Function

Parameters

t: Assert

err: MaybeErrorWithCode

opts: { msgRx?: RegExp; txSignature?: string; type?: Err } = {}

Optional msgRx?: RegExp

Optional txSignature?: string

Optional type?: Err

Returns void

assertTransactionError

Type parameters

Err: Function

Parameters

t: Assert