@cardano-foundation/ledgerjs-hw-app-cardano

Index

Main

Addresses

Shelley

Mary

Errors

Other

Scripts

Main

GetVersionResponse

GetVersionResponse: { version: Version; compatibility: DeviceCompatibility }

Response to Ada.getVersion call

Type declaration

version: Version
compatibility: DeviceCompatibility

GetExtendedPublicKeysRequest

GetExtendedPublicKeysRequest: { paths: BIP32Path[] }

Get multiple public keys (Ada.getExtendedPublicKeys) request data

see: GetExtendedPublicKeysResponse

Type declaration

paths: BIP32Path[]

Paths to public keys which should be derived by the device

GetExtendedPublicKeysResponse

GetExtendedPublicKeysResponse: ExtendedPublicKey[]

Ada.getExtendedPublicKeys response data

see: GetExtendedPublicKeysRequest

GetExtendedPublicKeyRequest

GetExtendedPublicKeyRequest: { path: BIP32Path }

Get single public keys (Ada.getExtendedPublicKey) request data

see: GetExtendedPublicKeysResponse

Type declaration

path: BIP32Path

Path to public key which should be derived

GetExtendedPublicKeyResponse

GetExtendedPublicKeyResponse: ExtendedPublicKey

Get single public key (Ada.getExtendedPublicKey) response data

see: GetExtendedPublicKeysResponse

DeriveAddressRequest

DeriveAddressRequest: { network: Network; address: DeviceOwnedAddress }

Derive address (Ada.deriveAddress) request data

see: DeriveAddressResponse

Type declaration

network: Network
address: DeviceOwnedAddress

DeriveAddressResponse

DeriveAddressResponse: DerivedAddress

Derive address (Ada.deriveAddress) response data

see: DeriveAddressRequest

ShowAddressRequest

ShowAddressRequest: DeriveAddressRequest

Show address on derivce (Ada.showAddress) request data

GetSerialResponse

GetSerialResponse: Serial

Get device serial number (Ada.getSerial) response data

SignTransactionResponse

SignTransactionResponse: SignedTransactionData

Sign transaction (Ada.signTransaction) response data

see: SignTransactionRequest

SignOperationalCertificateRequest

SignOperationalCertificateRequest: OperationalCertificate

Sign operational certificate (Ada.signOperationalCertificate) request data

see: SignOperationalCertificateResponse

SignOperationalCertificateResponse

SignOperationalCertificateResponse: OperationalCertificateSignature

Sign operational certificate (Ada.signOperationalCertificate) response data

see: SignOperationalCertificateRequest

DeriveNativeScriptHashRequest

DeriveNativeScriptHashRequest: { script: NativeScript; displayFormat: NativeScriptHashDisplayFormat }

Derive native script hash (Ada.deriveNativeScriptHash) request data

see: DeriveNativeScriptHashResponse

Type declaration

script: NativeScript
displayFormat: NativeScriptHashDisplayFormat

DeriveNativeScriptHashResponse

DeriveNativeScriptHashResponse: NativeScriptHash

Derive native script hash (Ada.deriveNativeScriptHash) response data

see: DeriveNativeScriptHashRequest

Basic types

bigint_like

bigint_like: number | bigint | string

Type for 64-bit integers.

We accept either

Number (if it is less than Number.MAX_SAFE_INTEGER)
String (representing 64-bit number)
BigInt (if platform supports it natively)

BIP32Path

BIP32Path: number[]

Represents BIP 32 path.

example

 const HD = HARDENED
 const ByronAccount0 = [44 + HD, 1815 + HD, 0 + HD];
 const ShelleyChangeAddress0 = [1852 + HD, 1815 + HD, 0 + HD, 1, 0];

see

HARDENED

Network

Network: { protocolMagic: number; networkId: number }

Cardano network magic constants

Type declaration

protocolMagic: number

byron protocol id
networkId: number

shelley network id

OperationalCertificate

OperationalCertificate: { kesPublicKeyHex: string; kesPeriod: bigint_like; issueCounter: bigint_like; coldKeyPath: BIP32Path }

Operational certificate

Type declaration

kesPublicKeyHex: string
kesPeriod: bigint_like
issueCounter: bigint_like
coldKeyPath: BIP32Path

TxInput

TxInput: { txHashHex: string; outputIndex: number; path: BIP32Path | null }

Describes single transaction input (i.e. UTxO)

see: Transaction

Type declaration

txHashHex: string

UTxO's hash of the transaction
outputIndex: number

UTxO's transaction output index
path: BIP32Path | null

Describes path used for witnessing this UTxO. The API will sign transaction with this path.

Note: null indicates we don't want to sign this utxo. This is highly non-standard and the only usecase so far is pool registration as owner. We therefore don't mark it as optional so that people won't forget specifying it

Note: Device has no ability to really check whether path is correct witnessing path for this UTxO.

TxOutput

TxOutput: { destination: TxOutputDestination; amount: bigint_like; tokenBundle?: AssetGroup[] | null; datumHashHex?: string | null }

Transaction output

see: Transaction

Type declaration

destination: TxOutputDestination

Destination address of the output
amount: bigint_like

Output amount. Specified in Lovelace
Optional tokenBundle?: AssetGroup[] | null

Additional assets sent to the output. If not null, the entries' keys (policyIds) must be unique and sorted to reflect a canonical CBOR as described in the CBOR RFC), i.e. the key with the lower value in lexical order sorts earlier.
Optional datumHashHex?: string | null

Optional datum hash

Flags

Flags: { isDebug: boolean }

Device app flags

see: Version

Type declaration

isDebug: boolean

Version

Version: { major: number; minor: number; patch: number; flags: Flags }

Device app version

see: Ada.getVersion
see: DeviceCompatibility

Type declaration

major: number
minor: number
patch: number
flags: Flags

DeviceCompatibility

DeviceCompatibility: { isCompatible: boolean; recommendedVersion: string | null; supportsMary: boolean; supportsCatalystRegistration: boolean; supportsZeroTtl: boolean; supportsPoolRegistrationAsOperator: boolean; supportsPoolRetirement: boolean; supportsNativeScriptHashDerivation: boolean; supportsMultisigTransaction: boolean; supportsMint: boolean; supportsAlonzo: boolean }

Describes compatibility of device with current SDK

see: Ada.getVersion

Type declaration

isCompatible: boolean
Overall compatibility.
- true if SDK supports the device with given firmware version (to the extent of the features supported by the firmware itself)
- false if SDK refuses to communicate with current device version
recommendedVersion: string | null

In case there are some compatibility problem, SDK recommended version. Clients of SDK should check whether this is null and if not, urge users to upgrade.
supportsMary: boolean

Whether we support Mary features
supportsCatalystRegistration: boolean

Whether we support Catalyst registration
supportsZeroTtl: boolean

Whether we support transactions with zero TTL (useful for dummy transactions to ensure invalidity)
supportsPoolRegistrationAsOperator: boolean

Whether we support operational certificate signing
supportsPoolRetirement: boolean

Whether we support pool retirement certificate
supportsNativeScriptHashDerivation: boolean

Whether we support script hash derivation
supportsMultisigTransaction: boolean

Whether we support multisig transaction
supportsMint: boolean

Whether we support mint
supportsAlonzo: boolean

Whether we support Alonzo and Plutus

Serial

Serial: { serialHex: string }

Response to Ada.getSerial call

Type declaration

serialHex: string

Serial is a Ledger device identifier. It is 7 bytes long, which is represented here as 14-character hex string

DerivedAddress

DerivedAddress: { addressHex: string }

Response to Ada.deriveAddress call

see: DeriveAddressRequest

Type declaration

addressHex: string

ExtendedPublicKey

ExtendedPublicKey: { publicKeyHex: string; chainCodeHex: string }

Derived extended public key

see: Ada.getExtendedPublicKey

Type declaration

publicKeyHex: string
chainCodeHex: string

OperationalCertificateSignature

OperationalCertificateSignature: { signatureHex: string }

Operational certificate signature

see: Ada.signOperationalCertificate

Type declaration

signatureHex: string

Witness

Witness: { path: BIP32Path; witnessSignatureHex: string }

Transaction witness.

see: SignedTransactionData

Type declaration

path: BIP32Path

Witnessed path
witnessSignatureHex: string

Note: this is only a signature. You need to add proper extended public key to form a full witness

TxAuxiliaryDataSupplement

TxAuxiliaryDataSupplement: { type: CATALYST_REGISTRATION; auxiliaryDataHashHex: string; catalystRegistrationSignatureHex: string }

Transaction auxiliary data supplementary information.

see: TxAuxiliaryDataSupplementType
see: SignedTransactionData

Type declaration

type: CATALYST_REGISTRATION
auxiliaryDataHashHex: string

Hash of the auxiliary data including the Catalyst registration
catalystRegistrationSignatureHex: string

Signature of the Catalyst registration payload by the staking key that was supplied

SignedTransactionData

SignedTransactionData: { txHashHex: string; witnesses: Witness[]; auxiliaryDataSupplement: TxAuxiliaryDataSupplement | null }

Result of signing a transaction.

see: Ada.signTransaction

Type declaration

txHashHex: string

Hash of signed transaction. Callers should check that they serialize tx the same way
witnesses: Witness[]

List of witnesses. Caller should assemble full transaction to be submitted to the network.
auxiliaryDataSupplement: TxAuxiliaryDataSupplement | null

Additional information about auxiliary data serialized into the transaction, providing the caller with information needed to assemble the transation containing these auxiliary data.

TxAuxiliaryData

TxAuxiliaryData: { type: ARBITRARY_HASH; params: TxAuxiliaryDataArbitraryHashParams } | { type: CATALYST_REGISTRATION; params: CatalystRegistrationParams }

Specifies transaction auxiliary data. Auxiliary data can be supplied to Ledger possibly in multiple forms.

see: TxAuxiliaryDataType

Transaction

Transaction: { network: Network; inputs: TxInput[]; outputs: TxOutput[]; fee: bigint_like; ttl?: bigint_like | null; certificates?: Certificate[] | null; withdrawals?: Withdrawal[] | null; auxiliaryData?: TxAuxiliaryData | null; validityIntervalStart?: bigint_like | null; mint?: AssetGroup[] | null; scriptDataHashHex?: string | null; collaterals?: TxInput[] | null; requiredSigners?: RequiredSigner[] | null; includeNetworkId?: boolean }

Represents transaction to be signed by the device. Note that this represents a superset of what Ledger can sign due to certain hardware app/security limitations.

see: TransactionSigningMode for a details on further restrictions
see: Ada.signTransaction

Type declaration

network: Network

Cardano network the transaction is supposed to be submitted to.
inputs: TxInput[]

Transaction inputs (UTxOs)
outputs: TxOutput[]

Transaction outputs
fee: bigint_like

Transaction fee (in Lovelace). Note that transaction is valid only if inputs + fee === outputs.
Optional ttl?: bigint_like | null

"Time-to-live" (block height). Transaction will become invalid at this block height.
Optional certificates?: Certificate[] | null

Transaction certificates (if any).
Optional withdrawals?: Withdrawal[] | null

Withdrawals (if any) from rewards accounts If not null, the entries' keys (reward addresses derived from the given stake credentials) must be unique and sorted ascending to reflect a canonical CBOR as described in the CBOR RFC), i.e. the key with the lower value in lexical order sorts earlier.
Optional auxiliaryData?: TxAuxiliaryData | null

Transaction auxiliary data (if any)
Optional validityIntervalStart?: bigint_like | null

Validity start (block height) if any. Transaction becomes valid only starting from this block height.
Optional mint?: AssetGroup[] | null

Mint or burn instructions (if any). Assets to be minted (token amount positive) or burned (token amount negative) with the transaction. If not null, the entries' keys (policyIds) must be unique and sorted to reflect a canonical CBOR as described in the CBOR RFC), i.e. the key with the lower value in lexical order sorts earlier.
Optional scriptDataHashHex?: string | null

Script Data hash (if any)
Optional collaterals?: TxInput[] | null

Collaterals (if any)
Optional requiredSigners?: RequiredSigner[] | null

Required Signers by key (if any)
Optional includeNetworkId?: boolean

True if network id should be included in the transaction body; false or not given otherwise

SignTransactionRequest

SignTransactionRequest: { signingMode: TransactionSigningMode; tx: Transaction; additionalWitnessPaths?: BIP32Path[] }

Transaction signing request. This represents the transaction user wants to sign. Due to certain Ledger limitation, we also require user to specify a "mode" in which he/she wants to sign the transaction.

Type declaration

signingMode: TransactionSigningMode

Mode in which we want to sign the transaction. Ledger has certain limitations (see TransactionSigningMode in detail) due to which it cannot sign arbitrary combination of all transaction features. The mode specifies which use-case the user want to use and triggers additional validation on tx field.
tx: Transaction

Transaction to be signed
Optional additionalWitnessPaths?: BIP32Path[]

Additional witness paths that are not gathered from the transaction body, eg. mint witnesses

Addresses

DeviceOwnedAddress

DeviceOwnedAddress: { type: BYRON; params: AddressParamsByron } | { type: BASE_PAYMENT_KEY_STAKE_KEY | BASE_PAYMENT_SCRIPT_STAKE_KEY | BASE_PAYMENT_KEY_STAKE_SCRIPT | BASE_PAYMENT_SCRIPT_STAKE_SCRIPT; params: AddressParamsBase } | { type: ENTERPRISE_KEY | ENTERPRISE_SCRIPT; params: AddressParamsEnterprise } | { type: POINTER_KEY | POINTER_SCRIPT; params: AddressParamsPointer } | { type: REWARD_KEY | REWARD_SCRIPT; params: AddressParamsReward }

Describes address owned by the Ledger device. Outputs with these addresses are not shown to the user during transaction signing

see: AddressType

AddressParamsByron

AddressParamsByron: { spendingPath: BIP32Path }

Byron address parameters

see: DeviceOwnedAddress

Type declaration

spendingPath: BIP32Path

AddressParamsBase

AddressParamsBase: SpendingParams & ({ stakingPath: BIP32Path } | { stakingKeyHashHex: string } | { stakingScriptHashHex: string })

Shelley base address parameters. The API allows for using device staking key, or supplying third-party staking key.

see: DeviceOwnedAddress

AddressParamsEnterprise

AddressParamsEnterprise: SpendingParams

Shelley enterprise address parameters

see: DeviceOwnedAddress

AddressParamsPointer

AddressParamsPointer: SpendingParams & { stakingBlockchainPointer: BlockchainPointer }

Shelley pointer address parameters

see: DeviceOwnedAddress

AddressParamsReward

AddressParamsReward: { stakingPath: BIP32Path } | { stakingScriptHashHex: string }

Shelley reward address parameters.

see: DeviceOwnedAddress

ThirdPartyAddressParams

ThirdPartyAddressParams: { addressHex: string }

Address now owned by the device. Device will show it during transaction review

see: TxOutputDestination

Type declaration

addressHex: string

Byron or Shelley address in raw hex format (without bech32/base58 encoding)

TxOutputDestination

TxOutputDestination: { type: THIRD_PARTY; params: ThirdPartyAddressParams } | { type: DEVICE_OWNED; params: DeviceOwnedAddress }

Represents output address.

see: TxOutputDestinationType
see: Transaction

BlockchainPointer

BlockchainPointer: { blockIndex: number; txIndex: number; certificateIndex: number }

Blockchain pointer for Pointer addresses

see: AddressParamsPointer

Type declaration

blockIndex: number
txIndex: number
certificateIndex: number

Shelley

PoolRetirementParams

PoolRetirementParams: { poolKeyPath: BIP32Path; retirementEpoch: bigint_like }

Pool retirement certificate parameters

see: Certificate

Type declaration

poolKeyPath: BIP32Path

Path to the pool key
retirementEpoch: bigint_like

Epoch after which the pool should be retired

StakeRegistrationParams

StakeRegistrationParams: { stakeCredential: StakeCredentialParams }

Stake key registration certificate parameters

see: Certificate

Type declaration

stakeCredential: StakeCredentialParams

Id to be registered

StakeDeregistrationParams

StakeDeregistrationParams: { stakeCredential: StakeCredentialParams }

Stake key deregistration certificate parameters

see: Certificate

Type declaration

stakeCredential: StakeCredentialParams

Id to be deregistered

StakeDelegationParams

StakeDelegationParams: { stakeCredential: StakeCredentialParams; poolKeyHashHex: string }

Stake delegation certificate parameters

see: Certificate

Type declaration

stakeCredential: StakeCredentialParams

Id of the staking entity / reward account that wants to delegate
poolKeyHashHex: string

Pool ID user wants to delegate to

Certificate

Certificate: { type: STAKE_REGISTRATION; params: StakeRegistrationParams } | { type: STAKE_DEREGISTRATION; params: StakeDeregistrationParams } | { type: STAKE_DELEGATION; params: StakeDelegationParams } | { type: STAKE_POOL_REGISTRATION; params: PoolRegistrationParams } | { type: STAKE_POOL_RETIREMENT; params: PoolRetirementParams }

Certificate. Can be one of multiple options.

see: CertificateType
see: Transaction

Withdrawal

Withdrawal: { stakeCredential: StakeCredentialParams; amount: bigint_like }

Rewards account withdwaral operation

see: Transaction

Type declaration

stakeCredential: StakeCredentialParams

Path to rewards account being withdrawn
amount: bigint_like

Amount (in Lovelace) being withdrawn. Note that Amount must be all accumulated rewards.

Mary

Token

Token: { assetNameHex: string; amount: bigint_like }

Describes a single token within a multiasset structure.

see: AssetGroup

Type declaration

assetNameHex: string
amount: bigint_like

Note: can be signed or unsigned, depending on the context. device does not know the number of decimal places the token uses.

AssetGroup

AssetGroup: { policyIdHex: string; tokens: Token[] }

Describes a group of assets belonging to the same policy in a multiasset structure. The asset names of tokens must be unique and sorted lowest value to highest to reflect a canonical CBOR. The sorting rules (as described in the CBOR RFC) are:

if two keys have different lengths, the shorter one sorts earlier;
if two keys have the same length, the one with the lower value in lexical order sorts earlier.

see: TxOutput

Type declaration

policyIdHex: string
tokens: Token[]

Errors

DeviceStatusCodes

DeviceStatusCodes: { ERR_STILL_IN_CALL: 28164; ERR_INVALID_DATA: 28167; ERR_INVALID_BIP_PATH: 28168; ERR_REJECTED_BY_USER: 28169; ERR_REJECTED_BY_POLICY: 28176; ERR_DEVICE_LOCKED: 28177; ERR_UNSUPPORTED_ADDRESS_TYPE: 28178; ERR_CLA_NOT_SUPPORTED: 28160 } = ...

Raw error codes returned by APDU protocol. Note that this is not an exhaustive list.

Type declaration

ERR_STILL_IN_CALL: 28164
ERR_INVALID_DATA: 28167
ERR_INVALID_BIP_PATH: 28168
ERR_REJECTED_BY_USER: 28169
ERR_REJECTED_BY_POLICY: 28176
ERR_DEVICE_LOCKED: 28177
ERR_UNSUPPORTED_ADDRESS_TYPE: 28178
ERR_CLA_NOT_SUPPORTED: 28160

Other

default

Renames and re-exports Ada

Networks

Networks: { Mainnet: Network; Testnet: Network } = ...

Default Cardano networks

see: Network

Type declaration

Mainnet: Network
Testnet: Network

DeviceStatusMessages

DeviceStatusMessages: Record<number, string> = ...

HARDENED

HARDENED: 2147483648 = 0x80000000

Hardened derivation

example

const accountId = 0 + HARDENED

see

BIP32Path

SpendingParams

SpendingParams: { spendingPath: BIP32Path } | { spendingScriptHashHex: string }

KeyPathStakeCredentialParams

KeyPathStakeCredentialParams: { type: KEY_PATH; keyPath: BIP32Path }

Type declaration

type: KEY_PATH
keyPath: BIP32Path

KeyHashStakeCredentialParams

KeyHashStakeCredentialParams: { type: KEY_HASH; keyHashHex: string }

Type declaration

type: KEY_HASH
keyHashHex: string

ScriptStakeCredentialParams

ScriptStakeCredentialParams: { type: SCRIPT_HASH; scriptHashHex: string }

Type declaration

type: SCRIPT_HASH
scriptHashHex: string

StakeCredentialParams

StakeCredentialParams: KeyPathStakeCredentialParams | KeyHashStakeCredentialParams | ScriptStakeCredentialParams

TxAuxiliaryDataArbitraryHashParams

TxAuxiliaryDataArbitraryHashParams: { hashHex: string }

Auxiliary data is supplied as raw hash. Ledger will just display this hash to the user

see: TxAuxiliaryData

Type declaration

hashHex: string

Hash of the transaction auxiliary data

CatalystRegistrationParams

CatalystRegistrationParams: { votingPublicKeyHex: string; stakingPath: BIP32Path; rewardsDestination: DeviceOwnedAddress; nonce: bigint_like }

Parameters needed for Ledger to assemble and sign the Catalyst voting registration metadata. Ledger will display the voting registration parameters and overall metadata hash.

see: TxAuxiliaryData

Type declaration

votingPublicKeyHex: string

Voting key to be registered given in hex
stakingPath: BIP32Path

Path to the staking key to which voting rights would be associated
rewardsDestination: DeviceOwnedAddress

Address for receiving voting rewards, Byron-era addresses not supported
nonce: bigint_like

Nonce value

RequiredSigner

RequiredSigner: { type: PATH; path: BIP32Path } | { type: HASH; hashHex: string }

utils

utils: { hex_to_buf: (data: any) => Buffer; buf_to_hex: (data: any) => string; path_to_buf: (data: any) => Buffer; uint32_to_buf: (data: any) => Buffer; assert: (cond: boolean, errMsg: string) => asserts cond; str_to_path: (data: string) => number[]; base58_encode: (data: Buffer) => string; base58_decode: (data: string) => Buffer; bech32_encodeAddress: (data: Buffer) => string; bech32_decodeAddress: (data: string) => Buffer; chunkBy: (data: Buffer, chunkLengths: number[]) => Buffer[]; stripRetcodeFromResponse: (response: Buffer) => Buffer }

Type declaration

hex_to_buf: (data: any) => Buffer
- - (data: any): Buffer
  - Parameters
    - data: any
    Returns Buffer
buf_to_hex: (data: any) => string
- - (data: any): string
  - Parameters
    - data: any
    Returns string
path_to_buf: (data: any) => Buffer
- - (data: any): Buffer
  - Parameters
    - data: any
    Returns Buffer
uint32_to_buf: (data: any) => Buffer
- - (data: any): Buffer
  - Parameters
    - data: any
    Returns Buffer
assert: (cond: boolean, errMsg: string) => asserts cond
- - (cond: boolean, errMsg: string): asserts cond
  - Parameters
    - cond: boolean
    - errMsg: string
    Returns asserts cond
str_to_path: (data: string) => number[]
- - (data: string): number[]
  - Parameters
    - data: string
    Returns number[]
base58_encode: (data: Buffer) => string
- - (data: Buffer): string
  - Parameters
    - data: Buffer
    Returns string
base58_decode: (data: string) => Buffer
- - (data: string): Buffer
  - Parameters
    - data: string
    Returns Buffer
bech32_encodeAddress: (data: Buffer) => string
- - (data: Buffer): string
  - Parameters
    - data: Buffer
    Returns string
bech32_decodeAddress: (data: string) => Buffer
- - (data: string): Buffer
  - Parameters
    - data: string
    Returns Buffer
chunkBy: (data: Buffer, chunkLengths: number[]) => Buffer[]
- - (data: Buffer, chunkLengths: number[]): Buffer[]
  - Parameters
    - data: Buffer
    - chunkLengths: number[]
    Returns Buffer[]
stripRetcodeFromResponse: (response: Buffer) => Buffer
- - (response: Buffer): Buffer
  - Parameters
    - response: Buffer
    Returns Buffer

Pool registration certificate

PoolKey

PoolKey: { type: THIRD_PARTY; params: PoolKeyThirdPartyParams } | { type: DEVICE_OWNED; params: PoolKeyDeviceOwnedParams }

Represents pool cold key.

see: PoolRegistrationParams

PoolKeyThirdPartyParams

PoolKeyThirdPartyParams: { keyHashHex: string }

Pool key is owned by an external party

see: PoolKey
see: PoolKeyType

Type declaration

keyHashHex: string

PoolKeyDeviceOwnedParams

PoolKeyDeviceOwnedParams: { path: BIP32Path }

Pool key is owned by the Ledger device

see: PoolKey
see: PoolKeyType

Type declaration

path: BIP32Path

PoolOwner

PoolOwner: { type: THIRD_PARTY; params: PoolOwnerThirdPartyParams } | { type: DEVICE_OWNED; params: PoolOwnerDeviceOwnedParams }

Represents pool owner.

see: PoolRegistrationParams

PoolOwnerThirdPartyParams

PoolOwnerThirdPartyParams: { stakingKeyHashHex: string }

Pool owner is an external party

see: PoolOwner
see: PoolOwnerType

Type declaration

stakingKeyHashHex: string

PoolOwnerDeviceOwnedParams

PoolOwnerDeviceOwnedParams: { stakingPath: BIP32Path }

Pool owner is the Ledger device. Supply staking key path which should sign the certificate

see: PoolOwner
see: PoolOwnerType

Type declaration

stakingPath: BIP32Path

PoolRewardAccount

PoolRewardAccount: { type: THIRD_PARTY; params: PoolRewardAccountThirdPartyParams } | { type: DEVICE_OWNED; params: PoolRewardAccountDeviceOwnedParams }

Represents pool reward account.

see: PoolRegistrationParams

PoolRewardAccountThirdPartyParams

PoolRewardAccountThirdPartyParams: { rewardAccountHex: string }

Pool reward account is owned by an external party

see: PoolRewardAccount
see: PoolRewardAccountType

Type declaration

rewardAccountHex: string

PoolRewardAccountDeviceOwnedParams

PoolRewardAccountDeviceOwnedParams: { path: BIP32Path }

Pool reward account is owned by the Ledger device. Supply staking key path for reward account

see: PoolRewardAccount
see: PoolRewardAccountType

Type declaration

path: BIP32Path

SingleHostIpAddrRelayParams

SingleHostIpAddrRelayParams: { portNumber?: number | null; ipv4?: string | null; ipv6?: string | null }

Represents pool relay. Note that at least one of ipv4 and ipv6 must be supplied

see: Relay

Type declaration

Optional portNumber?: number | null

TCP port of the relay. Should be 0..65535
Optional ipv4?: string | null

IPv4 address of the relay. Should be in string format, e.g. "192.168.0.1"
Optional ipv6?: string | null

IPv6 address of the relay. Should be in fully expanded string format, e.g. "2001:0db8:85a3:0000:0000:8a2e:0370:7334"

SingleHostHostnameRelayParams

SingleHostHostnameRelayParams: { portNumber?: number | null; dnsName: string }

see: Relay

Type declaration

Optional portNumber?: number | null
dnsName: string

MultiHostRelayParams

MultiHostRelayParams: { dnsName: string }

see: Relay

Type declaration

dnsName: string

Relay

Relay: { type: SINGLE_HOST_IP_ADDR; params: SingleHostIpAddrRelayParams } | { type: SINGLE_HOST_HOSTNAME; params: SingleHostHostnameRelayParams } | { type: MULTI_HOST; params: MultiHostRelayParams }

see: RelayType
see: PoolRegistrationParams

PoolMetadataParams

PoolMetadataParams: { metadataUrl: string; metadataHashHex: string }

Pool registration metadata

see: PoolRegistrationParams

Type declaration

metadataUrl: string
metadataHashHex: string

Margin

Margin: { numerator: bigint_like; denominator: bigint_like }

Pool margin represented as fraction (numerator/denominator)

see: PoolRegistrationParams

Type declaration

numerator: bigint_like

Numerator Must be <= denominator
denominator: bigint_like

Denominator. Limited to maximum value of 1e18

PoolRegistrationParams

PoolRegistrationParams: { poolKey: PoolKey; vrfKeyHashHex: string; pledge: bigint_like; cost: bigint_like; margin: Margin; rewardAccount: PoolRewardAccount; poolOwners: PoolOwner[]; relays: Relay[]; metadata?: PoolMetadataParams | null }

Pool registration certificate

see: Certificate

Type declaration

poolKey: PoolKey
vrfKeyHashHex: string

Pool vrf key
pledge: bigint_like

Owner pledge
cost: bigint_like
margin: Margin
rewardAccount: PoolRewardAccount
poolOwners: PoolOwner[]
relays: Relay[]
Optional metadata?: PoolMetadataParams | null

Scripts

NativeScript

NativeScript: { type: PUBKEY_DEVICE_OWNED; params: NativeScriptParamsDeviceOwnedPubkey } | { type: PUBKEY_THIRD_PARTY; params: NativeScriptParamsThirdPartyPubkey } | { type: ALL; params: NativeScriptParamsAll } | { type: ANY; params: NativeScriptParamsAny } | { type: N_OF_K; params: NativeScriptParamsNofK } | { type: INVALID_BEFORE; params: NativeScriptParamsInvalidBefore } | { type: INVALID_HEREAFTER; params: NativeScriptParamsInvalidHereafter }

Describes a native script, that can be passed to a Ledger device, to generate it's hash.

see: NativeScriptType

NativeScriptParamsDeviceOwnedPubkey

NativeScriptParamsDeviceOwnedPubkey: { path: BIP32Path }

Native script of type pubkey parameters. Pubkey is owned by the device, it is specified by key path

see: NativeScriptType.PUBKEY_DEVICE_OWNED
see: NativeScript

Type declaration

path: BIP32Path

NativeScriptParamsThirdPartyPubkey

NativeScriptParamsThirdPartyPubkey: { keyHashHex: string }

Native script of type pubkey parameters. Pubkey is third party, it is specified by a key hash in hex format

see: NativeScriptType.PUBKEY_THIRD_PARTY
see: NativeScript

Type declaration

keyHashHex: string

NativeScriptParamsAll

NativeScriptParamsAll: { scripts: NativeScript[] }

Native script of type all parameters.

see: NativeScriptType.ALL
see: NativeScript

Type declaration

scripts: NativeScript[]

NativeScriptParamsAny

NativeScriptParamsAny: { scripts: NativeScript[] }

Native script of type any parameters.

see: NativeScriptType.ANY
see: NativeScript

Type declaration

scripts: NativeScript[]

NativeScriptParamsNofK

NativeScriptParamsNofK: { requiredCount: bigint_like; scripts: NativeScript[] }

Native script of type n_of_k parameters.

see: NativeScriptType.N_OF_K
see: NativeScript

Type declaration

requiredCount: bigint_like
scripts: NativeScript[]

NativeScriptParamsInvalidBefore

NativeScriptParamsInvalidBefore: { slot: bigint_like }

Native script of type invalid_before parameters.

see: NativeScriptType.INVALID_BEFORE
see: NativeScript

Type declaration

slot: bigint_like

NativeScriptParamsInvalidHereafter

NativeScriptParamsInvalidHereafter: { slot: bigint_like }

Native script of type invalid_hereafter parameters.

see: NativeScriptType.INVALID_HEREAFTER
see: NativeScript

Type declaration

slot: bigint_like

NativeScriptHash

NativeScriptHash: { scriptHashHex: string }

Response to Ada.deriveNativeScriptHash call

see: DeriveNativeScriptHashRequest

Type declaration

scriptHashHex: string

Index

Main

Basic types

Addresses

Shelley

Mary

Errors

Other

Pool registration certificate

Scripts

Main

GetVersionResponse

Type declaration

version: Version

compatibility: DeviceCompatibility

GetExtendedPublicKeysRequest

Type declaration

paths: BIP32Path[]

GetExtendedPublicKeysResponse

GetExtendedPublicKeyRequest

Type declaration

path: BIP32Path

GetExtendedPublicKeyResponse

DeriveAddressRequest

Type declaration

network: Network

address: DeviceOwnedAddress

DeriveAddressResponse

ShowAddressRequest

GetSerialResponse

SignTransactionResponse

SignOperationalCertificateRequest

SignOperationalCertificateResponse

DeriveNativeScriptHashRequest

Type declaration

script: NativeScript

displayFormat: NativeScriptHashDisplayFormat

DeriveNativeScriptHashResponse

Basic types

bigint_like

BIP32Path

Network

Type declaration

protocolMagic: number

networkId: number

OperationalCertificate

Type declaration

kesPublicKeyHex: string

kesPeriod: bigint_like

issueCounter: bigint_like

coldKeyPath: BIP32Path

TxInput

Type declaration

txHashHex: string

outputIndex: number

path: BIP32Path | null

TxOutput

Type declaration

destination: TxOutputDestination

amount: bigint_like

Optional tokenBundle?: AssetGroup[] | null

Optional datumHashHex?: string | null

Flags

Type declaration

isDebug: boolean

Version

Type declaration

major: number

minor: number

patch: number

flags: Flags

DeviceCompatibility

Type declaration

isCompatible: boolean

recommendedVersion: string | null

supportsMary: boolean

supportsCatalystRegistration: boolean

supportsZeroTtl: boolean

supportsPoolRegistrationAsOperator: boolean

supportsPoolRetirement: boolean