# Automatically generated by pb2py
# fmt: off
# isort:skip_file
from trezor import protobuf
from typing import Any, TYPE_CHECKING
def __getattr__(name: str) -> Any:
try:
return protobuf.type_for_name(name)
except ValueError:
raise AttributeError(name)
if TYPE_CHECKING:
from typing import TypeGuard
from trezor.enums import AmountUnit # noqa: F401
from trezor.enums import BackupType # noqa: F401
from trezor.enums import BinanceOrderSide # noqa: F401
from trezor.enums import BinanceOrderType # noqa: F401
from trezor.enums import BinanceTimeInForce # noqa: F401
from trezor.enums import ButtonRequestType # noqa: F401
from trezor.enums import Capability # noqa: F401
from trezor.enums import CardanoAddressType # noqa: F401
from trezor.enums import CardanoCertificateType # noqa: F401
from trezor.enums import CardanoDerivationType # noqa: F401
from trezor.enums import CardanoNativeScriptHashDisplayFormat # noqa: F401
from trezor.enums import CardanoNativeScriptType # noqa: F401
from trezor.enums import CardanoPoolRelayType # noqa: F401
from trezor.enums import CardanoTxAuxiliaryDataSupplementType # noqa: F401
from trezor.enums import CardanoTxOutputSerializationFormat # noqa: F401
from trezor.enums import CardanoTxSigningMode # noqa: F401
from trezor.enums import CardanoTxWitnessType # noqa: F401
from trezor.enums import DebugButton # noqa: F401
from trezor.enums import DebugSwipeDirection # noqa: F401
from trezor.enums import DecredStakingSpendType # noqa: F401
from trezor.enums import EthereumDataType # noqa: F401
from trezor.enums import FailureType # noqa: F401
from trezor.enums import InputScriptType # noqa: F401
from trezor.enums import MessageType # noqa: F401
from trezor.enums import MoneroNetworkType # noqa: F401
from trezor.enums import NEMImportanceTransferMode # noqa: F401
from trezor.enums import NEMModificationType # noqa: F401
from trezor.enums import NEMMosaicLevy # noqa: F401
from trezor.enums import NEMSupplyChangeType # noqa: F401
from trezor.enums import OutputScriptType # noqa: F401
from trezor.enums import PinMatrixRequestType # noqa: F401
from trezor.enums import RecoveryDeviceType # noqa: F401
from trezor.enums import RequestType # noqa: F401
from trezor.enums import SafetyCheckLevel # noqa: F401
from trezor.enums import SdProtectOperationType # noqa: F401
from trezor.enums import StellarAssetType # noqa: F401
from trezor.enums import StellarMemoType # noqa: F401
from trezor.enums import StellarSignerType # noqa: F401
from trezor.enums import TezosBallotType # noqa: F401
from trezor.enums import TezosContractType # noqa: F401
from trezor.enums import WordRequestType # noqa: F401
class BinanceGetAddress(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceGetAddress"]:
return isinstance(msg, cls)
class BinanceAddress(protobuf.MessageType):
address: "str"
def __init__(
self,
*,
address: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceAddress"]:
return isinstance(msg, cls)
class BinanceGetPublicKey(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceGetPublicKey"]:
return isinstance(msg, cls)
class BinancePublicKey(protobuf.MessageType):
public_key: "bytes"
def __init__(
self,
*,
public_key: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinancePublicKey"]:
return isinstance(msg, cls)
class BinanceSignTx(protobuf.MessageType):
address_n: "list[int]"
msg_count: "int"
account_number: "int"
chain_id: "str | None"
memo: "str | None"
sequence: "int"
source: "int"
def __init__(
self,
*,
msg_count: "int",
account_number: "int",
sequence: "int",
source: "int",
address_n: "list[int] | None" = None,
chain_id: "str | None" = None,
memo: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceSignTx"]:
return isinstance(msg, cls)
class BinanceTxRequest(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceTxRequest"]:
return isinstance(msg, cls)
class BinanceTransferMsg(protobuf.MessageType):
inputs: "list[BinanceInputOutput]"
outputs: "list[BinanceInputOutput]"
def __init__(
self,
*,
inputs: "list[BinanceInputOutput] | None" = None,
outputs: "list[BinanceInputOutput] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceTransferMsg"]:
return isinstance(msg, cls)
class BinanceOrderMsg(protobuf.MessageType):
id: "str | None"
ordertype: "BinanceOrderType"
price: "int"
quantity: "int"
sender: "str | None"
side: "BinanceOrderSide"
symbol: "str | None"
timeinforce: "BinanceTimeInForce"
def __init__(
self,
*,
ordertype: "BinanceOrderType",
price: "int",
quantity: "int",
side: "BinanceOrderSide",
timeinforce: "BinanceTimeInForce",
id: "str | None" = None,
sender: "str | None" = None,
symbol: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceOrderMsg"]:
return isinstance(msg, cls)
class BinanceCancelMsg(protobuf.MessageType):
refid: "str | None"
sender: "str | None"
symbol: "str | None"
def __init__(
self,
*,
refid: "str | None" = None,
sender: "str | None" = None,
symbol: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceCancelMsg"]:
return isinstance(msg, cls)
class BinanceSignedTx(protobuf.MessageType):
signature: "bytes"
public_key: "bytes"
def __init__(
self,
*,
signature: "bytes",
public_key: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceSignedTx"]:
return isinstance(msg, cls)
class BinanceInputOutput(protobuf.MessageType):
address: "str"
coins: "list[BinanceCoin]"
def __init__(
self,
*,
address: "str",
coins: "list[BinanceCoin] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceInputOutput"]:
return isinstance(msg, cls)
class BinanceCoin(protobuf.MessageType):
amount: "int"
denom: "str"
def __init__(
self,
*,
amount: "int",
denom: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BinanceCoin"]:
return isinstance(msg, cls)
class Success(protobuf.MessageType):
message: "str"
def __init__(
self,
*,
message: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["Success"]:
return isinstance(msg, cls)
class Failure(protobuf.MessageType):
code: "FailureType | None"
message: "str | None"
def __init__(
self,
*,
code: "FailureType | None" = None,
message: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["Failure"]:
return isinstance(msg, cls)
class ButtonRequest(protobuf.MessageType):
code: "ButtonRequestType | None"
pages: "int | None"
def __init__(
self,
*,
code: "ButtonRequestType | None" = None,
pages: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["ButtonRequest"]:
return isinstance(msg, cls)
class ButtonAck(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["ButtonAck"]:
return isinstance(msg, cls)
class PinMatrixRequest(protobuf.MessageType):
type: "PinMatrixRequestType | None"
def __init__(
self,
*,
type: "PinMatrixRequestType | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PinMatrixRequest"]:
return isinstance(msg, cls)
class PinMatrixAck(protobuf.MessageType):
pin: "str"
def __init__(
self,
*,
pin: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PinMatrixAck"]:
return isinstance(msg, cls)
class PassphraseRequest(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PassphraseRequest"]:
return isinstance(msg, cls)
class PassphraseAck(protobuf.MessageType):
passphrase: "str | None"
on_device: "bool | None"
def __init__(
self,
*,
passphrase: "str | None" = None,
on_device: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PassphraseAck"]:
return isinstance(msg, cls)
class HDNodeType(protobuf.MessageType):
depth: "int"
fingerprint: "int"
child_num: "int"
chain_code: "bytes"
private_key: "bytes | None"
public_key: "bytes"
def __init__(
self,
*,
depth: "int",
fingerprint: "int",
child_num: "int",
chain_code: "bytes",
public_key: "bytes",
private_key: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["HDNodeType"]:
return isinstance(msg, cls)
class MultisigRedeemScriptType(protobuf.MessageType):
pubkeys: "list[HDNodePathType]"
signatures: "list[bytes]"
m: "int"
nodes: "list[HDNodeType]"
address_n: "list[int]"
def __init__(
self,
*,
m: "int",
pubkeys: "list[HDNodePathType] | None" = None,
signatures: "list[bytes] | None" = None,
nodes: "list[HDNodeType] | None" = None,
address_n: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MultisigRedeemScriptType"]:
return isinstance(msg, cls)
class GetPublicKey(protobuf.MessageType):
address_n: "list[int]"
ecdsa_curve_name: "str | None"
show_display: "bool | None"
coin_name: "str"
script_type: "InputScriptType"
ignore_xpub_magic: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
ecdsa_curve_name: "str | None" = None,
show_display: "bool | None" = None,
coin_name: "str | None" = None,
script_type: "InputScriptType | None" = None,
ignore_xpub_magic: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetPublicKey"]:
return isinstance(msg, cls)
class PublicKey(protobuf.MessageType):
node: "HDNodeType"
xpub: "str"
root_fingerprint: "int | None"
def __init__(
self,
*,
node: "HDNodeType",
xpub: "str",
root_fingerprint: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PublicKey"]:
return isinstance(msg, cls)
class GetAddress(protobuf.MessageType):
address_n: "list[int]"
coin_name: "str"
show_display: "bool | None"
multisig: "MultisigRedeemScriptType | None"
script_type: "InputScriptType"
ignore_xpub_magic: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
coin_name: "str | None" = None,
show_display: "bool | None" = None,
multisig: "MultisigRedeemScriptType | None" = None,
script_type: "InputScriptType | None" = None,
ignore_xpub_magic: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetAddress"]:
return isinstance(msg, cls)
class Address(protobuf.MessageType):
address: "str"
mac: "bytes | None"
def __init__(
self,
*,
address: "str",
mac: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["Address"]:
return isinstance(msg, cls)
class GetOwnershipId(protobuf.MessageType):
address_n: "list[int]"
coin_name: "str"
multisig: "MultisigRedeemScriptType | None"
script_type: "InputScriptType"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
coin_name: "str | None" = None,
multisig: "MultisigRedeemScriptType | None" = None,
script_type: "InputScriptType | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetOwnershipId"]:
return isinstance(msg, cls)
class OwnershipId(protobuf.MessageType):
ownership_id: "bytes"
def __init__(
self,
*,
ownership_id: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["OwnershipId"]:
return isinstance(msg, cls)
class SignMessage(protobuf.MessageType):
address_n: "list[int]"
message: "bytes"
coin_name: "str"
script_type: "InputScriptType"
no_script_type: "bool | None"
def __init__(
self,
*,
message: "bytes",
address_n: "list[int] | None" = None,
coin_name: "str | None" = None,
script_type: "InputScriptType | None" = None,
no_script_type: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["SignMessage"]:
return isinstance(msg, cls)
class MessageSignature(protobuf.MessageType):
address: "str"
signature: "bytes"
def __init__(
self,
*,
address: "str",
signature: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MessageSignature"]:
return isinstance(msg, cls)
class VerifyMessage(protobuf.MessageType):
address: "str"
signature: "bytes"
message: "bytes"
coin_name: "str"
def __init__(
self,
*,
address: "str",
signature: "bytes",
message: "bytes",
coin_name: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["VerifyMessage"]:
return isinstance(msg, cls)
class SignTx(protobuf.MessageType):
outputs_count: "int"
inputs_count: "int"
coin_name: "str"
version: "int"
lock_time: "int"
expiry: "int | None"
version_group_id: "int | None"
timestamp: "int | None"
branch_id: "int | None"
amount_unit: "AmountUnit"
decred_staking_ticket: "bool"
def __init__(
self,
*,
outputs_count: "int",
inputs_count: "int",
coin_name: "str | None" = None,
version: "int | None" = None,
lock_time: "int | None" = None,
expiry: "int | None" = None,
version_group_id: "int | None" = None,
timestamp: "int | None" = None,
branch_id: "int | None" = None,
amount_unit: "AmountUnit | None" = None,
decred_staking_ticket: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["SignTx"]:
return isinstance(msg, cls)
class TxRequest(protobuf.MessageType):
request_type: "RequestType | None"
details: "TxRequestDetailsType | None"
serialized: "TxRequestSerializedType | None"
def __init__(
self,
*,
request_type: "RequestType | None" = None,
details: "TxRequestDetailsType | None" = None,
serialized: "TxRequestSerializedType | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxRequest"]:
return isinstance(msg, cls)
class TxInput(protobuf.MessageType):
address_n: "list[int]"
prev_hash: "bytes"
prev_index: "int"
script_sig: "bytes | None"
sequence: "int"
script_type: "InputScriptType"
multisig: "MultisigRedeemScriptType | None"
amount: "int"
decred_tree: "int | None"
witness: "bytes | None"
ownership_proof: "bytes | None"
commitment_data: "bytes | None"
orig_hash: "bytes | None"
orig_index: "int | None"
decred_staking_spend: "DecredStakingSpendType | None"
script_pubkey: "bytes | None"
def __init__(
self,
*,
prev_hash: "bytes",
prev_index: "int",
amount: "int",
address_n: "list[int] | None" = None,
script_sig: "bytes | None" = None,
sequence: "int | None" = None,
script_type: "InputScriptType | None" = None,
multisig: "MultisigRedeemScriptType | None" = None,
decred_tree: "int | None" = None,
witness: "bytes | None" = None,
ownership_proof: "bytes | None" = None,
commitment_data: "bytes | None" = None,
orig_hash: "bytes | None" = None,
orig_index: "int | None" = None,
decred_staking_spend: "DecredStakingSpendType | None" = None,
script_pubkey: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxInput"]:
return isinstance(msg, cls)
class TxOutput(protobuf.MessageType):
address: "str | None"
address_n: "list[int]"
amount: "int"
script_type: "OutputScriptType"
multisig: "MultisigRedeemScriptType | None"
op_return_data: "bytes | None"
orig_hash: "bytes | None"
orig_index: "int | None"
payment_req_index: "int | None"
def __init__(
self,
*,
amount: "int",
address_n: "list[int] | None" = None,
address: "str | None" = None,
script_type: "OutputScriptType | None" = None,
multisig: "MultisigRedeemScriptType | None" = None,
op_return_data: "bytes | None" = None,
orig_hash: "bytes | None" = None,
orig_index: "int | None" = None,
payment_req_index: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxOutput"]:
return isinstance(msg, cls)
class PrevTx(protobuf.MessageType):
version: "int"
lock_time: "int"
inputs_count: "int"
outputs_count: "int"
extra_data_len: "int"
expiry: "int | None"
version_group_id: "int | None"
timestamp: "int | None"
branch_id: "int | None"
def __init__(
self,
*,
version: "int",
lock_time: "int",
inputs_count: "int",
outputs_count: "int",
extra_data_len: "int | None" = None,
expiry: "int | None" = None,
version_group_id: "int | None" = None,
timestamp: "int | None" = None,
branch_id: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PrevTx"]:
return isinstance(msg, cls)
class PrevInput(protobuf.MessageType):
prev_hash: "bytes"
prev_index: "int"
script_sig: "bytes"
sequence: "int"
decred_tree: "int | None"
def __init__(
self,
*,
prev_hash: "bytes",
prev_index: "int",
script_sig: "bytes",
sequence: "int",
decred_tree: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PrevInput"]:
return isinstance(msg, cls)
class PrevOutput(protobuf.MessageType):
amount: "int"
script_pubkey: "bytes"
decred_script_version: "int | None"
def __init__(
self,
*,
amount: "int",
script_pubkey: "bytes",
decred_script_version: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PrevOutput"]:
return isinstance(msg, cls)
class TxAckPaymentRequest(protobuf.MessageType):
nonce: "bytes | None"
recipient_name: "str"
memos: "list[PaymentRequestMemo]"
amount: "int | None"
signature: "bytes"
def __init__(
self,
*,
recipient_name: "str",
signature: "bytes",
memos: "list[PaymentRequestMemo] | None" = None,
nonce: "bytes | None" = None,
amount: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckPaymentRequest"]:
return isinstance(msg, cls)
class TxAckInput(protobuf.MessageType):
tx: "TxAckInputWrapper"
def __init__(
self,
*,
tx: "TxAckInputWrapper",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckInput"]:
return isinstance(msg, cls)
class TxAckOutput(protobuf.MessageType):
tx: "TxAckOutputWrapper"
def __init__(
self,
*,
tx: "TxAckOutputWrapper",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckOutput"]:
return isinstance(msg, cls)
class TxAckPrevMeta(protobuf.MessageType):
tx: "PrevTx"
def __init__(
self,
*,
tx: "PrevTx",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckPrevMeta"]:
return isinstance(msg, cls)
class TxAckPrevInput(protobuf.MessageType):
tx: "TxAckPrevInputWrapper"
def __init__(
self,
*,
tx: "TxAckPrevInputWrapper",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckPrevInput"]:
return isinstance(msg, cls)
class TxAckPrevOutput(protobuf.MessageType):
tx: "TxAckPrevOutputWrapper"
def __init__(
self,
*,
tx: "TxAckPrevOutputWrapper",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckPrevOutput"]:
return isinstance(msg, cls)
class TxAckPrevExtraData(protobuf.MessageType):
tx: "TxAckPrevExtraDataWrapper"
def __init__(
self,
*,
tx: "TxAckPrevExtraDataWrapper",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckPrevExtraData"]:
return isinstance(msg, cls)
class GetOwnershipProof(protobuf.MessageType):
address_n: "list[int]"
coin_name: "str"
script_type: "InputScriptType"
multisig: "MultisigRedeemScriptType | None"
user_confirmation: "bool"
ownership_ids: "list[bytes]"
commitment_data: "bytes"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
ownership_ids: "list[bytes] | None" = None,
coin_name: "str | None" = None,
script_type: "InputScriptType | None" = None,
multisig: "MultisigRedeemScriptType | None" = None,
user_confirmation: "bool | None" = None,
commitment_data: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetOwnershipProof"]:
return isinstance(msg, cls)
class OwnershipProof(protobuf.MessageType):
ownership_proof: "bytes"
signature: "bytes"
def __init__(
self,
*,
ownership_proof: "bytes",
signature: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["OwnershipProof"]:
return isinstance(msg, cls)
class AuthorizeCoinJoin(protobuf.MessageType):
coordinator: "str"
max_rounds: "int"
max_coordinator_fee_rate: "int"
max_fee_per_kvbyte: "int"
address_n: "list[int]"
coin_name: "str"
script_type: "InputScriptType"
amount_unit: "AmountUnit"
def __init__(
self,
*,
coordinator: "str",
max_rounds: "int",
max_coordinator_fee_rate: "int",
max_fee_per_kvbyte: "int",
address_n: "list[int] | None" = None,
coin_name: "str | None" = None,
script_type: "InputScriptType | None" = None,
amount_unit: "AmountUnit | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["AuthorizeCoinJoin"]:
return isinstance(msg, cls)
class HDNodePathType(protobuf.MessageType):
node: "HDNodeType"
address_n: "list[int]"
def __init__(
self,
*,
node: "HDNodeType",
address_n: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["HDNodePathType"]:
return isinstance(msg, cls)
class TxRequestDetailsType(protobuf.MessageType):
request_index: "int | None"
tx_hash: "bytes | None"
extra_data_len: "int | None"
extra_data_offset: "int | None"
def __init__(
self,
*,
request_index: "int | None" = None,
tx_hash: "bytes | None" = None,
extra_data_len: "int | None" = None,
extra_data_offset: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxRequestDetailsType"]:
return isinstance(msg, cls)
class TxRequestSerializedType(protobuf.MessageType):
signature_index: "int | None"
signature: "bytes | None"
serialized_tx: "bytes | None"
def __init__(
self,
*,
signature_index: "int | None" = None,
signature: "bytes | None" = None,
serialized_tx: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxRequestSerializedType"]:
return isinstance(msg, cls)
class PaymentRequestMemo(protobuf.MessageType):
text_memo: "TextMemo | None"
refund_memo: "RefundMemo | None"
coin_purchase_memo: "CoinPurchaseMemo | None"
def __init__(
self,
*,
text_memo: "TextMemo | None" = None,
refund_memo: "RefundMemo | None" = None,
coin_purchase_memo: "CoinPurchaseMemo | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PaymentRequestMemo"]:
return isinstance(msg, cls)
class TextMemo(protobuf.MessageType):
text: "str"
def __init__(
self,
*,
text: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TextMemo"]:
return isinstance(msg, cls)
class RefundMemo(protobuf.MessageType):
address: "str"
mac: "bytes"
def __init__(
self,
*,
address: "str",
mac: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["RefundMemo"]:
return isinstance(msg, cls)
class CoinPurchaseMemo(protobuf.MessageType):
coin_type: "int"
amount: "str"
address: "str"
mac: "bytes"
def __init__(
self,
*,
coin_type: "int",
amount: "str",
address: "str",
mac: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CoinPurchaseMemo"]:
return isinstance(msg, cls)
class TxAckInputWrapper(protobuf.MessageType):
input: "TxInput"
def __init__(
self,
*,
input: "TxInput",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckInputWrapper"]:
return isinstance(msg, cls)
class TxAckOutputWrapper(protobuf.MessageType):
output: "TxOutput"
def __init__(
self,
*,
output: "TxOutput",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckOutputWrapper"]:
return isinstance(msg, cls)
class TxAckPrevInputWrapper(protobuf.MessageType):
input: "PrevInput"
def __init__(
self,
*,
input: "PrevInput",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckPrevInputWrapper"]:
return isinstance(msg, cls)
class TxAckPrevOutputWrapper(protobuf.MessageType):
output: "PrevOutput"
def __init__(
self,
*,
output: "PrevOutput",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckPrevOutputWrapper"]:
return isinstance(msg, cls)
class TxAckPrevExtraDataWrapper(protobuf.MessageType):
extra_data_chunk: "bytes"
def __init__(
self,
*,
extra_data_chunk: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TxAckPrevExtraDataWrapper"]:
return isinstance(msg, cls)
class CardanoBlockchainPointerType(protobuf.MessageType):
block_index: "int"
tx_index: "int"
certificate_index: "int"
def __init__(
self,
*,
block_index: "int",
tx_index: "int",
certificate_index: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoBlockchainPointerType"]:
return isinstance(msg, cls)
class CardanoNativeScript(protobuf.MessageType):
type: "CardanoNativeScriptType"
scripts: "list[CardanoNativeScript]"
key_hash: "bytes | None"
key_path: "list[int]"
required_signatures_count: "int | None"
invalid_before: "int | None"
invalid_hereafter: "int | None"
def __init__(
self,
*,
type: "CardanoNativeScriptType",
scripts: "list[CardanoNativeScript] | None" = None,
key_path: "list[int] | None" = None,
key_hash: "bytes | None" = None,
required_signatures_count: "int | None" = None,
invalid_before: "int | None" = None,
invalid_hereafter: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoNativeScript"]:
return isinstance(msg, cls)
class CardanoGetNativeScriptHash(protobuf.MessageType):
script: "CardanoNativeScript"
display_format: "CardanoNativeScriptHashDisplayFormat"
derivation_type: "CardanoDerivationType"
def __init__(
self,
*,
script: "CardanoNativeScript",
display_format: "CardanoNativeScriptHashDisplayFormat",
derivation_type: "CardanoDerivationType",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoGetNativeScriptHash"]:
return isinstance(msg, cls)
class CardanoNativeScriptHash(protobuf.MessageType):
script_hash: "bytes"
def __init__(
self,
*,
script_hash: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoNativeScriptHash"]:
return isinstance(msg, cls)
class CardanoAddressParametersType(protobuf.MessageType):
address_type: "CardanoAddressType"
address_n: "list[int]"
address_n_staking: "list[int]"
staking_key_hash: "bytes | None"
certificate_pointer: "CardanoBlockchainPointerType | None"
script_payment_hash: "bytes | None"
script_staking_hash: "bytes | None"
def __init__(
self,
*,
address_type: "CardanoAddressType",
address_n: "list[int] | None" = None,
address_n_staking: "list[int] | None" = None,
staking_key_hash: "bytes | None" = None,
certificate_pointer: "CardanoBlockchainPointerType | None" = None,
script_payment_hash: "bytes | None" = None,
script_staking_hash: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoAddressParametersType"]:
return isinstance(msg, cls)
class CardanoGetAddress(protobuf.MessageType):
show_display: "bool"
protocol_magic: "int"
network_id: "int"
address_parameters: "CardanoAddressParametersType"
derivation_type: "CardanoDerivationType"
def __init__(
self,
*,
protocol_magic: "int",
network_id: "int",
address_parameters: "CardanoAddressParametersType",
derivation_type: "CardanoDerivationType",
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoGetAddress"]:
return isinstance(msg, cls)
class CardanoAddress(protobuf.MessageType):
address: "str"
def __init__(
self,
*,
address: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoAddress"]:
return isinstance(msg, cls)
class CardanoGetPublicKey(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
derivation_type: "CardanoDerivationType"
def __init__(
self,
*,
derivation_type: "CardanoDerivationType",
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoGetPublicKey"]:
return isinstance(msg, cls)
class CardanoPublicKey(protobuf.MessageType):
xpub: "str"
node: "HDNodeType"
def __init__(
self,
*,
xpub: "str",
node: "HDNodeType",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPublicKey"]:
return isinstance(msg, cls)
class CardanoSignTxInit(protobuf.MessageType):
signing_mode: "CardanoTxSigningMode"
protocol_magic: "int"
network_id: "int"
inputs_count: "int"
outputs_count: "int"
fee: "int"
ttl: "int | None"
certificates_count: "int"
withdrawals_count: "int"
has_auxiliary_data: "bool"
validity_interval_start: "int | None"
witness_requests_count: "int"
minting_asset_groups_count: "int"
derivation_type: "CardanoDerivationType"
include_network_id: "bool"
script_data_hash: "bytes | None"
collateral_inputs_count: "int"
required_signers_count: "int"
has_collateral_return: "bool"
total_collateral: "int | None"
reference_inputs_count: "int"
def __init__(
self,
*,
signing_mode: "CardanoTxSigningMode",
protocol_magic: "int",
network_id: "int",
inputs_count: "int",
outputs_count: "int",
fee: "int",
certificates_count: "int",
withdrawals_count: "int",
has_auxiliary_data: "bool",
witness_requests_count: "int",
minting_asset_groups_count: "int",
derivation_type: "CardanoDerivationType",
collateral_inputs_count: "int",
required_signers_count: "int",
ttl: "int | None" = None,
validity_interval_start: "int | None" = None,
include_network_id: "bool | None" = None,
script_data_hash: "bytes | None" = None,
has_collateral_return: "bool | None" = None,
total_collateral: "int | None" = None,
reference_inputs_count: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoSignTxInit"]:
return isinstance(msg, cls)
class CardanoTxInput(protobuf.MessageType):
prev_hash: "bytes"
prev_index: "int"
def __init__(
self,
*,
prev_hash: "bytes",
prev_index: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxInput"]:
return isinstance(msg, cls)
class CardanoTxOutput(protobuf.MessageType):
address: "str | None"
address_parameters: "CardanoAddressParametersType | None"
amount: "int"
asset_groups_count: "int"
datum_hash: "bytes | None"
format: "CardanoTxOutputSerializationFormat"
inline_datum_size: "int"
reference_script_size: "int"
def __init__(
self,
*,
amount: "int",
asset_groups_count: "int",
address: "str | None" = None,
address_parameters: "CardanoAddressParametersType | None" = None,
datum_hash: "bytes | None" = None,
format: "CardanoTxOutputSerializationFormat | None" = None,
inline_datum_size: "int | None" = None,
reference_script_size: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxOutput"]:
return isinstance(msg, cls)
class CardanoAssetGroup(protobuf.MessageType):
policy_id: "bytes"
tokens_count: "int"
def __init__(
self,
*,
policy_id: "bytes",
tokens_count: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoAssetGroup"]:
return isinstance(msg, cls)
class CardanoToken(protobuf.MessageType):
asset_name_bytes: "bytes"
amount: "int | None"
mint_amount: "int | None"
def __init__(
self,
*,
asset_name_bytes: "bytes",
amount: "int | None" = None,
mint_amount: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoToken"]:
return isinstance(msg, cls)
class CardanoTxInlineDatumChunk(protobuf.MessageType):
data: "bytes"
def __init__(
self,
*,
data: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxInlineDatumChunk"]:
return isinstance(msg, cls)
class CardanoTxReferenceScriptChunk(protobuf.MessageType):
data: "bytes"
def __init__(
self,
*,
data: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxReferenceScriptChunk"]:
return isinstance(msg, cls)
class CardanoPoolOwner(protobuf.MessageType):
staking_key_path: "list[int]"
staking_key_hash: "bytes | None"
def __init__(
self,
*,
staking_key_path: "list[int] | None" = None,
staking_key_hash: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPoolOwner"]:
return isinstance(msg, cls)
class CardanoPoolRelayParameters(protobuf.MessageType):
type: "CardanoPoolRelayType"
ipv4_address: "bytes | None"
ipv6_address: "bytes | None"
host_name: "str | None"
port: "int | None"
def __init__(
self,
*,
type: "CardanoPoolRelayType",
ipv4_address: "bytes | None" = None,
ipv6_address: "bytes | None" = None,
host_name: "str | None" = None,
port: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPoolRelayParameters"]:
return isinstance(msg, cls)
class CardanoPoolMetadataType(protobuf.MessageType):
url: "str"
hash: "bytes"
def __init__(
self,
*,
url: "str",
hash: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPoolMetadataType"]:
return isinstance(msg, cls)
class CardanoPoolParametersType(protobuf.MessageType):
pool_id: "bytes"
vrf_key_hash: "bytes"
pledge: "int"
cost: "int"
margin_numerator: "int"
margin_denominator: "int"
reward_account: "str"
metadata: "CardanoPoolMetadataType | None"
owners_count: "int"
relays_count: "int"
def __init__(
self,
*,
pool_id: "bytes",
vrf_key_hash: "bytes",
pledge: "int",
cost: "int",
margin_numerator: "int",
margin_denominator: "int",
reward_account: "str",
owners_count: "int",
relays_count: "int",
metadata: "CardanoPoolMetadataType | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoPoolParametersType"]:
return isinstance(msg, cls)
class CardanoTxCertificate(protobuf.MessageType):
type: "CardanoCertificateType"
path: "list[int]"
pool: "bytes | None"
pool_parameters: "CardanoPoolParametersType | None"
script_hash: "bytes | None"
key_hash: "bytes | None"
def __init__(
self,
*,
type: "CardanoCertificateType",
path: "list[int] | None" = None,
pool: "bytes | None" = None,
pool_parameters: "CardanoPoolParametersType | None" = None,
script_hash: "bytes | None" = None,
key_hash: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxCertificate"]:
return isinstance(msg, cls)
class CardanoTxWithdrawal(protobuf.MessageType):
path: "list[int]"
amount: "int"
script_hash: "bytes | None"
key_hash: "bytes | None"
def __init__(
self,
*,
amount: "int",
path: "list[int] | None" = None,
script_hash: "bytes | None" = None,
key_hash: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxWithdrawal"]:
return isinstance(msg, cls)
class CardanoCatalystRegistrationParametersType(protobuf.MessageType):
voting_public_key: "bytes"
staking_path: "list[int]"
reward_address_parameters: "CardanoAddressParametersType"
nonce: "int"
def __init__(
self,
*,
voting_public_key: "bytes",
reward_address_parameters: "CardanoAddressParametersType",
nonce: "int",
staking_path: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoCatalystRegistrationParametersType"]:
return isinstance(msg, cls)
class CardanoTxAuxiliaryData(protobuf.MessageType):
catalyst_registration_parameters: "CardanoCatalystRegistrationParametersType | None"
hash: "bytes | None"
def __init__(
self,
*,
catalyst_registration_parameters: "CardanoCatalystRegistrationParametersType | None" = None,
hash: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxAuxiliaryData"]:
return isinstance(msg, cls)
class CardanoTxMint(protobuf.MessageType):
asset_groups_count: "int"
def __init__(
self,
*,
asset_groups_count: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxMint"]:
return isinstance(msg, cls)
class CardanoTxCollateralInput(protobuf.MessageType):
prev_hash: "bytes"
prev_index: "int"
def __init__(
self,
*,
prev_hash: "bytes",
prev_index: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxCollateralInput"]:
return isinstance(msg, cls)
class CardanoTxRequiredSigner(protobuf.MessageType):
key_hash: "bytes | None"
key_path: "list[int]"
def __init__(
self,
*,
key_path: "list[int] | None" = None,
key_hash: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxRequiredSigner"]:
return isinstance(msg, cls)
class CardanoTxReferenceInput(protobuf.MessageType):
prev_hash: "bytes"
prev_index: "int"
def __init__(
self,
*,
prev_hash: "bytes",
prev_index: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxReferenceInput"]:
return isinstance(msg, cls)
class CardanoTxItemAck(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxItemAck"]:
return isinstance(msg, cls)
class CardanoTxAuxiliaryDataSupplement(protobuf.MessageType):
type: "CardanoTxAuxiliaryDataSupplementType"
auxiliary_data_hash: "bytes | None"
catalyst_signature: "bytes | None"
def __init__(
self,
*,
type: "CardanoTxAuxiliaryDataSupplementType",
auxiliary_data_hash: "bytes | None" = None,
catalyst_signature: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxAuxiliaryDataSupplement"]:
return isinstance(msg, cls)
class CardanoTxWitnessRequest(protobuf.MessageType):
path: "list[int]"
def __init__(
self,
*,
path: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxWitnessRequest"]:
return isinstance(msg, cls)
class CardanoTxWitnessResponse(protobuf.MessageType):
type: "CardanoTxWitnessType"
pub_key: "bytes"
signature: "bytes"
chain_code: "bytes | None"
def __init__(
self,
*,
type: "CardanoTxWitnessType",
pub_key: "bytes",
signature: "bytes",
chain_code: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxWitnessResponse"]:
return isinstance(msg, cls)
class CardanoTxHostAck(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxHostAck"]:
return isinstance(msg, cls)
class CardanoTxBodyHash(protobuf.MessageType):
tx_hash: "bytes"
def __init__(
self,
*,
tx_hash: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoTxBodyHash"]:
return isinstance(msg, cls)
class CardanoSignTxFinished(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CardanoSignTxFinished"]:
return isinstance(msg, cls)
class CipherKeyValue(protobuf.MessageType):
address_n: "list[int]"
key: "str"
value: "bytes"
encrypt: "bool | None"
ask_on_encrypt: "bool | None"
ask_on_decrypt: "bool | None"
iv: "bytes | None"
def __init__(
self,
*,
key: "str",
value: "bytes",
address_n: "list[int] | None" = None,
encrypt: "bool | None" = None,
ask_on_encrypt: "bool | None" = None,
ask_on_decrypt: "bool | None" = None,
iv: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CipherKeyValue"]:
return isinstance(msg, cls)
class CipheredKeyValue(protobuf.MessageType):
value: "bytes"
def __init__(
self,
*,
value: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CipheredKeyValue"]:
return isinstance(msg, cls)
class IdentityType(protobuf.MessageType):
proto: "str | None"
user: "str | None"
host: "str | None"
port: "str | None"
path: "str | None"
index: "int"
def __init__(
self,
*,
proto: "str | None" = None,
user: "str | None" = None,
host: "str | None" = None,
port: "str | None" = None,
path: "str | None" = None,
index: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["IdentityType"]:
return isinstance(msg, cls)
class SignIdentity(protobuf.MessageType):
identity: "IdentityType"
challenge_hidden: "bytes"
challenge_visual: "str"
ecdsa_curve_name: "str | None"
def __init__(
self,
*,
identity: "IdentityType",
challenge_hidden: "bytes | None" = None,
challenge_visual: "str | None" = None,
ecdsa_curve_name: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["SignIdentity"]:
return isinstance(msg, cls)
class SignedIdentity(protobuf.MessageType):
address: "str | None"
public_key: "bytes"
signature: "bytes"
def __init__(
self,
*,
public_key: "bytes",
signature: "bytes",
address: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["SignedIdentity"]:
return isinstance(msg, cls)
class GetECDHSessionKey(protobuf.MessageType):
identity: "IdentityType"
peer_public_key: "bytes"
ecdsa_curve_name: "str | None"
def __init__(
self,
*,
identity: "IdentityType",
peer_public_key: "bytes",
ecdsa_curve_name: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetECDHSessionKey"]:
return isinstance(msg, cls)
class ECDHSessionKey(protobuf.MessageType):
session_key: "bytes"
public_key: "bytes | None"
def __init__(
self,
*,
session_key: "bytes",
public_key: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["ECDHSessionKey"]:
return isinstance(msg, cls)
class CosiCommit(protobuf.MessageType):
address_n: "list[int]"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CosiCommit"]:
return isinstance(msg, cls)
class CosiCommitment(protobuf.MessageType):
commitment: "bytes | None"
pubkey: "bytes | None"
def __init__(
self,
*,
commitment: "bytes | None" = None,
pubkey: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CosiCommitment"]:
return isinstance(msg, cls)
class CosiSign(protobuf.MessageType):
address_n: "list[int]"
data: "bytes | None"
global_commitment: "bytes | None"
global_pubkey: "bytes | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
data: "bytes | None" = None,
global_commitment: "bytes | None" = None,
global_pubkey: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CosiSign"]:
return isinstance(msg, cls)
class CosiSignature(protobuf.MessageType):
signature: "bytes"
def __init__(
self,
*,
signature: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CosiSignature"]:
return isinstance(msg, cls)
class Initialize(protobuf.MessageType):
session_id: "bytes | None"
derive_cardano: "bool | None"
def __init__(
self,
*,
session_id: "bytes | None" = None,
derive_cardano: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["Initialize"]:
return isinstance(msg, cls)
class GetFeatures(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetFeatures"]:
return isinstance(msg, cls)
class Features(protobuf.MessageType):
vendor: "str | None"
major_version: "int"
minor_version: "int"
patch_version: "int"
bootloader_mode: "bool | None"
device_id: "str | None"
pin_protection: "bool | None"
passphrase_protection: "bool | None"
language: "str | None"
label: "str | None"
initialized: "bool | None"
revision: "bytes | None"
bootloader_hash: "bytes | None"
imported: "bool | None"
unlocked: "bool | None"
firmware_present: "bool | None"
needs_backup: "bool | None"
flags: "int | None"
model: "str | None"
fw_major: "int | None"
fw_minor: "int | None"
fw_patch: "int | None"
fw_vendor: "str | None"
unfinished_backup: "bool | None"
no_backup: "bool | None"
recovery_mode: "bool | None"
capabilities: "list[Capability]"
backup_type: "BackupType | None"
sd_card_present: "bool | None"
sd_protection: "bool | None"
wipe_code_protection: "bool | None"
session_id: "bytes | None"
passphrase_always_on_device: "bool | None"
safety_checks: "SafetyCheckLevel | None"
auto_lock_delay_ms: "int | None"
display_rotation: "int | None"
experimental_features: "bool | None"
busy: "bool | None"
def __init__(
self,
*,
major_version: "int",
minor_version: "int",
patch_version: "int",
capabilities: "list[Capability] | None" = None,
vendor: "str | None" = None,
bootloader_mode: "bool | None" = None,
device_id: "str | None" = None,
pin_protection: "bool | None" = None,
passphrase_protection: "bool | None" = None,
language: "str | None" = None,
label: "str | None" = None,
initialized: "bool | None" = None,
revision: "bytes | None" = None,
bootloader_hash: "bytes | None" = None,
imported: "bool | None" = None,
unlocked: "bool | None" = None,
firmware_present: "bool | None" = None,
needs_backup: "bool | None" = None,
flags: "int | None" = None,
model: "str | None" = None,
fw_major: "int | None" = None,
fw_minor: "int | None" = None,
fw_patch: "int | None" = None,
fw_vendor: "str | None" = None,
unfinished_backup: "bool | None" = None,
no_backup: "bool | None" = None,
recovery_mode: "bool | None" = None,
backup_type: "BackupType | None" = None,
sd_card_present: "bool | None" = None,
sd_protection: "bool | None" = None,
wipe_code_protection: "bool | None" = None,
session_id: "bytes | None" = None,
passphrase_always_on_device: "bool | None" = None,
safety_checks: "SafetyCheckLevel | None" = None,
auto_lock_delay_ms: "int | None" = None,
display_rotation: "int | None" = None,
experimental_features: "bool | None" = None,
busy: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["Features"]:
return isinstance(msg, cls)
class LockDevice(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["LockDevice"]:
return isinstance(msg, cls)
class SetBusy(protobuf.MessageType):
expiry_ms: "int | None"
def __init__(
self,
*,
expiry_ms: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["SetBusy"]:
return isinstance(msg, cls)
class EndSession(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EndSession"]:
return isinstance(msg, cls)
class ApplySettings(protobuf.MessageType):
language: "str | None"
label: "str | None"
use_passphrase: "bool | None"
homescreen: "bytes | None"
auto_lock_delay_ms: "int | None"
display_rotation: "int | None"
passphrase_always_on_device: "bool | None"
safety_checks: "SafetyCheckLevel | None"
experimental_features: "bool | None"
def __init__(
self,
*,
language: "str | None" = None,
label: "str | None" = None,
use_passphrase: "bool | None" = None,
homescreen: "bytes | None" = None,
auto_lock_delay_ms: "int | None" = None,
display_rotation: "int | None" = None,
passphrase_always_on_device: "bool | None" = None,
safety_checks: "SafetyCheckLevel | None" = None,
experimental_features: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["ApplySettings"]:
return isinstance(msg, cls)
class ApplyFlags(protobuf.MessageType):
flags: "int"
def __init__(
self,
*,
flags: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["ApplyFlags"]:
return isinstance(msg, cls)
class ChangePin(protobuf.MessageType):
remove: "bool | None"
def __init__(
self,
*,
remove: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["ChangePin"]:
return isinstance(msg, cls)
class ChangeWipeCode(protobuf.MessageType):
remove: "bool | None"
def __init__(
self,
*,
remove: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["ChangeWipeCode"]:
return isinstance(msg, cls)
class SdProtect(protobuf.MessageType):
operation: "SdProtectOperationType"
def __init__(
self,
*,
operation: "SdProtectOperationType",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["SdProtect"]:
return isinstance(msg, cls)
class Ping(protobuf.MessageType):
message: "str"
button_protection: "bool | None"
def __init__(
self,
*,
message: "str | None" = None,
button_protection: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["Ping"]:
return isinstance(msg, cls)
class Cancel(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["Cancel"]:
return isinstance(msg, cls)
class GetEntropy(protobuf.MessageType):
size: "int"
def __init__(
self,
*,
size: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetEntropy"]:
return isinstance(msg, cls)
class Entropy(protobuf.MessageType):
entropy: "bytes"
def __init__(
self,
*,
entropy: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["Entropy"]:
return isinstance(msg, cls)
class GetFirmwareHash(protobuf.MessageType):
challenge: "bytes | None"
def __init__(
self,
*,
challenge: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetFirmwareHash"]:
return isinstance(msg, cls)
class FirmwareHash(protobuf.MessageType):
hash: "bytes"
def __init__(
self,
*,
hash: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["FirmwareHash"]:
return isinstance(msg, cls)
class WipeDevice(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["WipeDevice"]:
return isinstance(msg, cls)
class LoadDevice(protobuf.MessageType):
mnemonics: "list[str]"
pin: "str | None"
passphrase_protection: "bool | None"
language: "str"
label: "str | None"
skip_checksum: "bool | None"
u2f_counter: "int | None"
needs_backup: "bool | None"
no_backup: "bool | None"
def __init__(
self,
*,
mnemonics: "list[str] | None" = None,
pin: "str | None" = None,
passphrase_protection: "bool | None" = None,
language: "str | None" = None,
label: "str | None" = None,
skip_checksum: "bool | None" = None,
u2f_counter: "int | None" = None,
needs_backup: "bool | None" = None,
no_backup: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["LoadDevice"]:
return isinstance(msg, cls)
class ResetDevice(protobuf.MessageType):
display_random: "bool | None"
strength: "int"
passphrase_protection: "bool | None"
pin_protection: "bool | None"
language: "str"
label: "str | None"
u2f_counter: "int | None"
skip_backup: "bool | None"
no_backup: "bool | None"
backup_type: "BackupType"
def __init__(
self,
*,
display_random: "bool | None" = None,
strength: "int | None" = None,
passphrase_protection: "bool | None" = None,
pin_protection: "bool | None" = None,
language: "str | None" = None,
label: "str | None" = None,
u2f_counter: "int | None" = None,
skip_backup: "bool | None" = None,
no_backup: "bool | None" = None,
backup_type: "BackupType | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["ResetDevice"]:
return isinstance(msg, cls)
class BackupDevice(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["BackupDevice"]:
return isinstance(msg, cls)
class EntropyRequest(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EntropyRequest"]:
return isinstance(msg, cls)
class EntropyAck(protobuf.MessageType):
entropy: "bytes"
def __init__(
self,
*,
entropy: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EntropyAck"]:
return isinstance(msg, cls)
class RecoveryDevice(protobuf.MessageType):
word_count: "int | None"
passphrase_protection: "bool | None"
pin_protection: "bool | None"
language: "str | None"
label: "str | None"
enforce_wordlist: "bool | None"
type: "RecoveryDeviceType | None"
u2f_counter: "int | None"
dry_run: "bool | None"
def __init__(
self,
*,
word_count: "int | None" = None,
passphrase_protection: "bool | None" = None,
pin_protection: "bool | None" = None,
language: "str | None" = None,
label: "str | None" = None,
enforce_wordlist: "bool | None" = None,
type: "RecoveryDeviceType | None" = None,
u2f_counter: "int | None" = None,
dry_run: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["RecoveryDevice"]:
return isinstance(msg, cls)
class WordRequest(protobuf.MessageType):
type: "WordRequestType"
def __init__(
self,
*,
type: "WordRequestType",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["WordRequest"]:
return isinstance(msg, cls)
class WordAck(protobuf.MessageType):
word: "str"
def __init__(
self,
*,
word: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["WordAck"]:
return isinstance(msg, cls)
class SetU2FCounter(protobuf.MessageType):
u2f_counter: "int"
def __init__(
self,
*,
u2f_counter: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["SetU2FCounter"]:
return isinstance(msg, cls)
class GetNextU2FCounter(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetNextU2FCounter"]:
return isinstance(msg, cls)
class NextU2FCounter(protobuf.MessageType):
u2f_counter: "int"
def __init__(
self,
*,
u2f_counter: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NextU2FCounter"]:
return isinstance(msg, cls)
class DoPreauthorized(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DoPreauthorized"]:
return isinstance(msg, cls)
class PreauthorizedRequest(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["PreauthorizedRequest"]:
return isinstance(msg, cls)
class CancelAuthorization(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["CancelAuthorization"]:
return isinstance(msg, cls)
class RebootToBootloader(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["RebootToBootloader"]:
return isinstance(msg, cls)
class GetNonce(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["GetNonce"]:
return isinstance(msg, cls)
class Nonce(protobuf.MessageType):
nonce: "bytes"
def __init__(
self,
*,
nonce: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["Nonce"]:
return isinstance(msg, cls)
class UnlockPath(protobuf.MessageType):
address_n: "list[int]"
mac: "bytes | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
mac: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["UnlockPath"]:
return isinstance(msg, cls)
class UnlockedPathRequest(protobuf.MessageType):
mac: "bytes | None"
def __init__(
self,
*,
mac: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["UnlockedPathRequest"]:
return isinstance(msg, cls)
class DebugLinkDecision(protobuf.MessageType):
button: "DebugButton | None"
swipe: "DebugSwipeDirection | None"
input: "str | None"
x: "int | None"
y: "int | None"
wait: "bool | None"
hold_ms: "int | None"
def __init__(
self,
*,
button: "DebugButton | None" = None,
swipe: "DebugSwipeDirection | None" = None,
input: "str | None" = None,
x: "int | None" = None,
y: "int | None" = None,
wait: "bool | None" = None,
hold_ms: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkDecision"]:
return isinstance(msg, cls)
class DebugLinkLayout(protobuf.MessageType):
lines: "list[str]"
def __init__(
self,
*,
lines: "list[str] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkLayout"]:
return isinstance(msg, cls)
class DebugLinkReseedRandom(protobuf.MessageType):
value: "int | None"
def __init__(
self,
*,
value: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkReseedRandom"]:
return isinstance(msg, cls)
class DebugLinkRecordScreen(protobuf.MessageType):
target_directory: "str | None"
def __init__(
self,
*,
target_directory: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkRecordScreen"]:
return isinstance(msg, cls)
class DebugLinkGetState(protobuf.MessageType):
wait_word_list: "bool | None"
wait_word_pos: "bool | None"
wait_layout: "bool | None"
def __init__(
self,
*,
wait_word_list: "bool | None" = None,
wait_word_pos: "bool | None" = None,
wait_layout: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkGetState"]:
return isinstance(msg, cls)
class DebugLinkState(protobuf.MessageType):
layout: "bytes | None"
pin: "str | None"
matrix: "str | None"
mnemonic_secret: "bytes | None"
node: "HDNodeType | None"
passphrase_protection: "bool | None"
reset_word: "str | None"
reset_entropy: "bytes | None"
recovery_fake_word: "str | None"
recovery_word_pos: "int | None"
reset_word_pos: "int | None"
mnemonic_type: "BackupType | None"
layout_lines: "list[str]"
def __init__(
self,
*,
layout_lines: "list[str] | None" = None,
layout: "bytes | None" = None,
pin: "str | None" = None,
matrix: "str | None" = None,
mnemonic_secret: "bytes | None" = None,
node: "HDNodeType | None" = None,
passphrase_protection: "bool | None" = None,
reset_word: "str | None" = None,
reset_entropy: "bytes | None" = None,
recovery_fake_word: "str | None" = None,
recovery_word_pos: "int | None" = None,
reset_word_pos: "int | None" = None,
mnemonic_type: "BackupType | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkState"]:
return isinstance(msg, cls)
class DebugLinkStop(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkStop"]:
return isinstance(msg, cls)
class DebugLinkLog(protobuf.MessageType):
level: "int | None"
bucket: "str | None"
text: "str | None"
def __init__(
self,
*,
level: "int | None" = None,
bucket: "str | None" = None,
text: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkLog"]:
return isinstance(msg, cls)
class DebugLinkMemoryRead(protobuf.MessageType):
address: "int | None"
length: "int | None"
def __init__(
self,
*,
address: "int | None" = None,
length: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkMemoryRead"]:
return isinstance(msg, cls)
class DebugLinkMemory(protobuf.MessageType):
memory: "bytes | None"
def __init__(
self,
*,
memory: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkMemory"]:
return isinstance(msg, cls)
class DebugLinkMemoryWrite(protobuf.MessageType):
address: "int | None"
memory: "bytes | None"
flash: "bool | None"
def __init__(
self,
*,
address: "int | None" = None,
memory: "bytes | None" = None,
flash: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkMemoryWrite"]:
return isinstance(msg, cls)
class DebugLinkFlashErase(protobuf.MessageType):
sector: "int | None"
def __init__(
self,
*,
sector: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkFlashErase"]:
return isinstance(msg, cls)
class DebugLinkEraseSdCard(protobuf.MessageType):
format: "bool | None"
def __init__(
self,
*,
format: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkEraseSdCard"]:
return isinstance(msg, cls)
class DebugLinkWatchLayout(protobuf.MessageType):
watch: "bool | None"
def __init__(
self,
*,
watch: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugLinkWatchLayout"]:
return isinstance(msg, cls)
class EosGetPublicKey(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosGetPublicKey"]:
return isinstance(msg, cls)
class EosPublicKey(protobuf.MessageType):
wif_public_key: "str"
raw_public_key: "bytes"
def __init__(
self,
*,
wif_public_key: "str",
raw_public_key: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosPublicKey"]:
return isinstance(msg, cls)
class EosSignTx(protobuf.MessageType):
address_n: "list[int]"
chain_id: "bytes"
header: "EosTxHeader"
num_actions: "int"
def __init__(
self,
*,
chain_id: "bytes",
header: "EosTxHeader",
num_actions: "int",
address_n: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosSignTx"]:
return isinstance(msg, cls)
class EosTxActionRequest(protobuf.MessageType):
data_size: "int | None"
def __init__(
self,
*,
data_size: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosTxActionRequest"]:
return isinstance(msg, cls)
class EosTxActionAck(protobuf.MessageType):
common: "EosActionCommon"
transfer: "EosActionTransfer | None"
delegate: "EosActionDelegate | None"
undelegate: "EosActionUndelegate | None"
refund: "EosActionRefund | None"
buy_ram: "EosActionBuyRam | None"
buy_ram_bytes: "EosActionBuyRamBytes | None"
sell_ram: "EosActionSellRam | None"
vote_producer: "EosActionVoteProducer | None"
update_auth: "EosActionUpdateAuth | None"
delete_auth: "EosActionDeleteAuth | None"
link_auth: "EosActionLinkAuth | None"
unlink_auth: "EosActionUnlinkAuth | None"
new_account: "EosActionNewAccount | None"
unknown: "EosActionUnknown | None"
def __init__(
self,
*,
common: "EosActionCommon",
transfer: "EosActionTransfer | None" = None,
delegate: "EosActionDelegate | None" = None,
undelegate: "EosActionUndelegate | None" = None,
refund: "EosActionRefund | None" = None,
buy_ram: "EosActionBuyRam | None" = None,
buy_ram_bytes: "EosActionBuyRamBytes | None" = None,
sell_ram: "EosActionSellRam | None" = None,
vote_producer: "EosActionVoteProducer | None" = None,
update_auth: "EosActionUpdateAuth | None" = None,
delete_auth: "EosActionDeleteAuth | None" = None,
link_auth: "EosActionLinkAuth | None" = None,
unlink_auth: "EosActionUnlinkAuth | None" = None,
new_account: "EosActionNewAccount | None" = None,
unknown: "EosActionUnknown | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosTxActionAck"]:
return isinstance(msg, cls)
class EosSignedTx(protobuf.MessageType):
signature: "str"
def __init__(
self,
*,
signature: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosSignedTx"]:
return isinstance(msg, cls)
class EosTxHeader(protobuf.MessageType):
expiration: "int"
ref_block_num: "int"
ref_block_prefix: "int"
max_net_usage_words: "int"
max_cpu_usage_ms: "int"
delay_sec: "int"
def __init__(
self,
*,
expiration: "int",
ref_block_num: "int",
ref_block_prefix: "int",
max_net_usage_words: "int",
max_cpu_usage_ms: "int",
delay_sec: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosTxHeader"]:
return isinstance(msg, cls)
class EosAsset(protobuf.MessageType):
amount: "int"
symbol: "int"
def __init__(
self,
*,
amount: "int",
symbol: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosAsset"]:
return isinstance(msg, cls)
class EosPermissionLevel(protobuf.MessageType):
actor: "int"
permission: "int"
def __init__(
self,
*,
actor: "int",
permission: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosPermissionLevel"]:
return isinstance(msg, cls)
class EosAuthorizationKey(protobuf.MessageType):
type: "int"
key: "bytes | None"
address_n: "list[int]"
weight: "int"
def __init__(
self,
*,
type: "int",
weight: "int",
address_n: "list[int] | None" = None,
key: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosAuthorizationKey"]:
return isinstance(msg, cls)
class EosAuthorizationAccount(protobuf.MessageType):
account: "EosPermissionLevel"
weight: "int"
def __init__(
self,
*,
account: "EosPermissionLevel",
weight: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosAuthorizationAccount"]:
return isinstance(msg, cls)
class EosAuthorizationWait(protobuf.MessageType):
wait_sec: "int"
weight: "int"
def __init__(
self,
*,
wait_sec: "int",
weight: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosAuthorizationWait"]:
return isinstance(msg, cls)
class EosAuthorization(protobuf.MessageType):
threshold: "int"
keys: "list[EosAuthorizationKey]"
accounts: "list[EosAuthorizationAccount]"
waits: "list[EosAuthorizationWait]"
def __init__(
self,
*,
threshold: "int",
keys: "list[EosAuthorizationKey] | None" = None,
accounts: "list[EosAuthorizationAccount] | None" = None,
waits: "list[EosAuthorizationWait] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosAuthorization"]:
return isinstance(msg, cls)
class EosActionCommon(protobuf.MessageType):
account: "int"
name: "int"
authorization: "list[EosPermissionLevel]"
def __init__(
self,
*,
account: "int",
name: "int",
authorization: "list[EosPermissionLevel] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionCommon"]:
return isinstance(msg, cls)
class EosActionTransfer(protobuf.MessageType):
sender: "int"
receiver: "int"
quantity: "EosAsset"
memo: "str"
def __init__(
self,
*,
sender: "int",
receiver: "int",
quantity: "EosAsset",
memo: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionTransfer"]:
return isinstance(msg, cls)
class EosActionDelegate(protobuf.MessageType):
sender: "int"
receiver: "int"
net_quantity: "EosAsset"
cpu_quantity: "EosAsset"
transfer: "bool"
def __init__(
self,
*,
sender: "int",
receiver: "int",
net_quantity: "EosAsset",
cpu_quantity: "EosAsset",
transfer: "bool",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionDelegate"]:
return isinstance(msg, cls)
class EosActionUndelegate(protobuf.MessageType):
sender: "int"
receiver: "int"
net_quantity: "EosAsset"
cpu_quantity: "EosAsset"
def __init__(
self,
*,
sender: "int",
receiver: "int",
net_quantity: "EosAsset",
cpu_quantity: "EosAsset",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionUndelegate"]:
return isinstance(msg, cls)
class EosActionRefund(protobuf.MessageType):
owner: "int"
def __init__(
self,
*,
owner: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionRefund"]:
return isinstance(msg, cls)
class EosActionBuyRam(protobuf.MessageType):
payer: "int"
receiver: "int"
quantity: "EosAsset"
def __init__(
self,
*,
payer: "int",
receiver: "int",
quantity: "EosAsset",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionBuyRam"]:
return isinstance(msg, cls)
class EosActionBuyRamBytes(protobuf.MessageType):
payer: "int"
receiver: "int"
bytes: "int"
def __init__(
self,
*,
payer: "int",
receiver: "int",
bytes: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionBuyRamBytes"]:
return isinstance(msg, cls)
class EosActionSellRam(protobuf.MessageType):
account: "int"
bytes: "int"
def __init__(
self,
*,
account: "int",
bytes: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionSellRam"]:
return isinstance(msg, cls)
class EosActionVoteProducer(protobuf.MessageType):
voter: "int"
proxy: "int"
producers: "list[int]"
def __init__(
self,
*,
voter: "int",
proxy: "int",
producers: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionVoteProducer"]:
return isinstance(msg, cls)
class EosActionUpdateAuth(protobuf.MessageType):
account: "int"
permission: "int"
parent: "int"
auth: "EosAuthorization"
def __init__(
self,
*,
account: "int",
permission: "int",
parent: "int",
auth: "EosAuthorization",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionUpdateAuth"]:
return isinstance(msg, cls)
class EosActionDeleteAuth(protobuf.MessageType):
account: "int"
permission: "int"
def __init__(
self,
*,
account: "int",
permission: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionDeleteAuth"]:
return isinstance(msg, cls)
class EosActionLinkAuth(protobuf.MessageType):
account: "int"
code: "int"
type: "int"
requirement: "int"
def __init__(
self,
*,
account: "int",
code: "int",
type: "int",
requirement: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionLinkAuth"]:
return isinstance(msg, cls)
class EosActionUnlinkAuth(protobuf.MessageType):
account: "int"
code: "int"
type: "int"
def __init__(
self,
*,
account: "int",
code: "int",
type: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionUnlinkAuth"]:
return isinstance(msg, cls)
class EosActionNewAccount(protobuf.MessageType):
creator: "int"
name: "int"
owner: "EosAuthorization"
active: "EosAuthorization"
def __init__(
self,
*,
creator: "int",
name: "int",
owner: "EosAuthorization",
active: "EosAuthorization",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionNewAccount"]:
return isinstance(msg, cls)
class EosActionUnknown(protobuf.MessageType):
data_size: "int"
data_chunk: "bytes"
def __init__(
self,
*,
data_size: "int",
data_chunk: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EosActionUnknown"]:
return isinstance(msg, cls)
class EthereumSignTypedData(protobuf.MessageType):
address_n: "list[int]"
primary_type: "str"
metamask_v4_compat: "bool"
def __init__(
self,
*,
primary_type: "str",
address_n: "list[int] | None" = None,
metamask_v4_compat: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumSignTypedData"]:
return isinstance(msg, cls)
class EthereumTypedDataStructRequest(protobuf.MessageType):
name: "str"
def __init__(
self,
*,
name: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumTypedDataStructRequest"]:
return isinstance(msg, cls)
class EthereumTypedDataStructAck(protobuf.MessageType):
members: "list[EthereumStructMember]"
def __init__(
self,
*,
members: "list[EthereumStructMember] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumTypedDataStructAck"]:
return isinstance(msg, cls)
class EthereumTypedDataValueRequest(protobuf.MessageType):
member_path: "list[int]"
def __init__(
self,
*,
member_path: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumTypedDataValueRequest"]:
return isinstance(msg, cls)
class EthereumTypedDataValueAck(protobuf.MessageType):
value: "bytes"
def __init__(
self,
*,
value: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumTypedDataValueAck"]:
return isinstance(msg, cls)
class EthereumStructMember(protobuf.MessageType):
type: "EthereumFieldType"
name: "str"
def __init__(
self,
*,
type: "EthereumFieldType",
name: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumStructMember"]:
return isinstance(msg, cls)
class EthereumFieldType(protobuf.MessageType):
data_type: "EthereumDataType"
size: "int | None"
entry_type: "EthereumFieldType | None"
struct_name: "str | None"
def __init__(
self,
*,
data_type: "EthereumDataType",
size: "int | None" = None,
entry_type: "EthereumFieldType | None" = None,
struct_name: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumFieldType"]:
return isinstance(msg, cls)
class EthereumGetPublicKey(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumGetPublicKey"]:
return isinstance(msg, cls)
class EthereumPublicKey(protobuf.MessageType):
node: "HDNodeType"
xpub: "str"
def __init__(
self,
*,
node: "HDNodeType",
xpub: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumPublicKey"]:
return isinstance(msg, cls)
class EthereumGetAddress(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumGetAddress"]:
return isinstance(msg, cls)
class EthereumAddress(protobuf.MessageType):
address: "str | None"
def __init__(
self,
*,
address: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumAddress"]:
return isinstance(msg, cls)
class EthereumSignTx(protobuf.MessageType):
address_n: "list[int]"
nonce: "bytes"
gas_price: "bytes"
gas_limit: "bytes"
to: "str"
value: "bytes"
data_initial_chunk: "bytes"
data_length: "int"
chain_id: "int"
tx_type: "int | None"
def __init__(
self,
*,
gas_price: "bytes",
gas_limit: "bytes",
chain_id: "int",
address_n: "list[int] | None" = None,
nonce: "bytes | None" = None,
to: "str | None" = None,
value: "bytes | None" = None,
data_initial_chunk: "bytes | None" = None,
data_length: "int | None" = None,
tx_type: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumSignTx"]:
return isinstance(msg, cls)
class EthereumSignTxEIP1559(protobuf.MessageType):
address_n: "list[int]"
nonce: "bytes"
max_gas_fee: "bytes"
max_priority_fee: "bytes"
gas_limit: "bytes"
to: "str"
value: "bytes"
data_initial_chunk: "bytes"
data_length: "int"
chain_id: "int"
access_list: "list[EthereumAccessList]"
def __init__(
self,
*,
nonce: "bytes",
max_gas_fee: "bytes",
max_priority_fee: "bytes",
gas_limit: "bytes",
value: "bytes",
data_length: "int",
chain_id: "int",
address_n: "list[int] | None" = None,
access_list: "list[EthereumAccessList] | None" = None,
to: "str | None" = None,
data_initial_chunk: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumSignTxEIP1559"]:
return isinstance(msg, cls)
class EthereumTxRequest(protobuf.MessageType):
data_length: "int | None"
signature_v: "int | None"
signature_r: "bytes | None"
signature_s: "bytes | None"
def __init__(
self,
*,
data_length: "int | None" = None,
signature_v: "int | None" = None,
signature_r: "bytes | None" = None,
signature_s: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumTxRequest"]:
return isinstance(msg, cls)
class EthereumTxAck(protobuf.MessageType):
data_chunk: "bytes"
def __init__(
self,
*,
data_chunk: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumTxAck"]:
return isinstance(msg, cls)
class EthereumSignMessage(protobuf.MessageType):
address_n: "list[int]"
message: "bytes"
def __init__(
self,
*,
message: "bytes",
address_n: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumSignMessage"]:
return isinstance(msg, cls)
class EthereumMessageSignature(protobuf.MessageType):
signature: "bytes"
address: "str"
def __init__(
self,
*,
signature: "bytes",
address: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumMessageSignature"]:
return isinstance(msg, cls)
class EthereumVerifyMessage(protobuf.MessageType):
signature: "bytes"
message: "bytes"
address: "str"
def __init__(
self,
*,
signature: "bytes",
message: "bytes",
address: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumVerifyMessage"]:
return isinstance(msg, cls)
class EthereumSignTypedHash(protobuf.MessageType):
address_n: "list[int]"
domain_separator_hash: "bytes"
message_hash: "bytes | None"
def __init__(
self,
*,
domain_separator_hash: "bytes",
address_n: "list[int] | None" = None,
message_hash: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumSignTypedHash"]:
return isinstance(msg, cls)
class EthereumTypedDataSignature(protobuf.MessageType):
signature: "bytes"
address: "str"
def __init__(
self,
*,
signature: "bytes",
address: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumTypedDataSignature"]:
return isinstance(msg, cls)
class EthereumAccessList(protobuf.MessageType):
address: "str"
storage_keys: "list[bytes]"
def __init__(
self,
*,
address: "str",
storage_keys: "list[bytes] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["EthereumAccessList"]:
return isinstance(msg, cls)
class MoneroTransactionSourceEntry(protobuf.MessageType):
outputs: "list[MoneroOutputEntry]"
real_output: "int | None"
real_out_tx_key: "bytes | None"
real_out_additional_tx_keys: "list[bytes]"
real_output_in_tx_index: "int | None"
amount: "int | None"
rct: "bool | None"
mask: "bytes | None"
multisig_kLRki: "MoneroMultisigKLRki | None"
subaddr_minor: "int | None"
def __init__(
self,
*,
outputs: "list[MoneroOutputEntry] | None" = None,
real_out_additional_tx_keys: "list[bytes] | None" = None,
real_output: "int | None" = None,
real_out_tx_key: "bytes | None" = None,
real_output_in_tx_index: "int | None" = None,
amount: "int | None" = None,
rct: "bool | None" = None,
mask: "bytes | None" = None,
multisig_kLRki: "MoneroMultisigKLRki | None" = None,
subaddr_minor: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionSourceEntry"]:
return isinstance(msg, cls)
class MoneroTransactionDestinationEntry(protobuf.MessageType):
amount: "int | None"
addr: "MoneroAccountPublicAddress | None"
is_subaddress: "bool | None"
original: "bytes | None"
is_integrated: "bool | None"
def __init__(
self,
*,
amount: "int | None" = None,
addr: "MoneroAccountPublicAddress | None" = None,
is_subaddress: "bool | None" = None,
original: "bytes | None" = None,
is_integrated: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionDestinationEntry"]:
return isinstance(msg, cls)
class MoneroTransactionRsigData(protobuf.MessageType):
rsig_type: "int | None"
offload_type: "int | None"
grouping: "list[int]"
mask: "bytes | None"
rsig: "bytes | None"
rsig_parts: "list[bytes]"
bp_version: "int | None"
def __init__(
self,
*,
grouping: "list[int] | None" = None,
rsig_parts: "list[bytes] | None" = None,
rsig_type: "int | None" = None,
offload_type: "int | None" = None,
mask: "bytes | None" = None,
rsig: "bytes | None" = None,
bp_version: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionRsigData"]:
return isinstance(msg, cls)
class MoneroGetAddress(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
network_type: "MoneroNetworkType"
account: "int | None"
minor: "int | None"
payment_id: "bytes | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
network_type: "MoneroNetworkType | None" = None,
account: "int | None" = None,
minor: "int | None" = None,
payment_id: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroGetAddress"]:
return isinstance(msg, cls)
class MoneroAddress(protobuf.MessageType):
address: "bytes | None"
def __init__(
self,
*,
address: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroAddress"]:
return isinstance(msg, cls)
class MoneroGetWatchKey(protobuf.MessageType):
address_n: "list[int]"
network_type: "MoneroNetworkType"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
network_type: "MoneroNetworkType | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroGetWatchKey"]:
return isinstance(msg, cls)
class MoneroWatchKey(protobuf.MessageType):
watch_key: "bytes | None"
address: "bytes | None"
def __init__(
self,
*,
watch_key: "bytes | None" = None,
address: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroWatchKey"]:
return isinstance(msg, cls)
class MoneroTransactionInitRequest(protobuf.MessageType):
version: "int | None"
address_n: "list[int]"
network_type: "MoneroNetworkType"
tsx_data: "MoneroTransactionData | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
version: "int | None" = None,
network_type: "MoneroNetworkType | None" = None,
tsx_data: "MoneroTransactionData | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionInitRequest"]:
return isinstance(msg, cls)
class MoneroTransactionInitAck(protobuf.MessageType):
hmacs: "list[bytes]"
rsig_data: "MoneroTransactionRsigData | None"
def __init__(
self,
*,
hmacs: "list[bytes] | None" = None,
rsig_data: "MoneroTransactionRsigData | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionInitAck"]:
return isinstance(msg, cls)
class MoneroTransactionSetInputRequest(protobuf.MessageType):
src_entr: "MoneroTransactionSourceEntry | None"
def __init__(
self,
*,
src_entr: "MoneroTransactionSourceEntry | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionSetInputRequest"]:
return isinstance(msg, cls)
class MoneroTransactionSetInputAck(protobuf.MessageType):
vini: "bytes | None"
vini_hmac: "bytes | None"
pseudo_out: "bytes | None"
pseudo_out_hmac: "bytes | None"
pseudo_out_alpha: "bytes | None"
spend_key: "bytes | None"
def __init__(
self,
*,
vini: "bytes | None" = None,
vini_hmac: "bytes | None" = None,
pseudo_out: "bytes | None" = None,
pseudo_out_hmac: "bytes | None" = None,
pseudo_out_alpha: "bytes | None" = None,
spend_key: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionSetInputAck"]:
return isinstance(msg, cls)
class MoneroTransactionInputViniRequest(protobuf.MessageType):
src_entr: "MoneroTransactionSourceEntry | None"
vini: "bytes | None"
vini_hmac: "bytes | None"
pseudo_out: "bytes | None"
pseudo_out_hmac: "bytes | None"
orig_idx: "int | None"
def __init__(
self,
*,
src_entr: "MoneroTransactionSourceEntry | None" = None,
vini: "bytes | None" = None,
vini_hmac: "bytes | None" = None,
pseudo_out: "bytes | None" = None,
pseudo_out_hmac: "bytes | None" = None,
orig_idx: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionInputViniRequest"]:
return isinstance(msg, cls)
class MoneroTransactionInputViniAck(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionInputViniAck"]:
return isinstance(msg, cls)
class MoneroTransactionAllInputsSetRequest(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionAllInputsSetRequest"]:
return isinstance(msg, cls)
class MoneroTransactionAllInputsSetAck(protobuf.MessageType):
rsig_data: "MoneroTransactionRsigData | None"
def __init__(
self,
*,
rsig_data: "MoneroTransactionRsigData | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionAllInputsSetAck"]:
return isinstance(msg, cls)
class MoneroTransactionSetOutputRequest(protobuf.MessageType):
dst_entr: "MoneroTransactionDestinationEntry | None"
dst_entr_hmac: "bytes | None"
rsig_data: "MoneroTransactionRsigData | None"
is_offloaded_bp: "bool | None"
def __init__(
self,
*,
dst_entr: "MoneroTransactionDestinationEntry | None" = None,
dst_entr_hmac: "bytes | None" = None,
rsig_data: "MoneroTransactionRsigData | None" = None,
is_offloaded_bp: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionSetOutputRequest"]:
return isinstance(msg, cls)
class MoneroTransactionSetOutputAck(protobuf.MessageType):
tx_out: "bytes | None"
vouti_hmac: "bytes | None"
rsig_data: "MoneroTransactionRsigData | None"
out_pk: "bytes | None"
ecdh_info: "bytes | None"
def __init__(
self,
*,
tx_out: "bytes | None" = None,
vouti_hmac: "bytes | None" = None,
rsig_data: "MoneroTransactionRsigData | None" = None,
out_pk: "bytes | None" = None,
ecdh_info: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionSetOutputAck"]:
return isinstance(msg, cls)
class MoneroTransactionAllOutSetRequest(protobuf.MessageType):
rsig_data: "MoneroTransactionRsigData | None"
def __init__(
self,
*,
rsig_data: "MoneroTransactionRsigData | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionAllOutSetRequest"]:
return isinstance(msg, cls)
class MoneroTransactionAllOutSetAck(protobuf.MessageType):
extra: "bytes | None"
tx_prefix_hash: "bytes | None"
rv: "MoneroRingCtSig | None"
full_message_hash: "bytes | None"
def __init__(
self,
*,
extra: "bytes | None" = None,
tx_prefix_hash: "bytes | None" = None,
rv: "MoneroRingCtSig | None" = None,
full_message_hash: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionAllOutSetAck"]:
return isinstance(msg, cls)
class MoneroTransactionSignInputRequest(protobuf.MessageType):
src_entr: "MoneroTransactionSourceEntry | None"
vini: "bytes | None"
vini_hmac: "bytes | None"
pseudo_out: "bytes | None"
pseudo_out_hmac: "bytes | None"
pseudo_out_alpha: "bytes | None"
spend_key: "bytes | None"
orig_idx: "int | None"
def __init__(
self,
*,
src_entr: "MoneroTransactionSourceEntry | None" = None,
vini: "bytes | None" = None,
vini_hmac: "bytes | None" = None,
pseudo_out: "bytes | None" = None,
pseudo_out_hmac: "bytes | None" = None,
pseudo_out_alpha: "bytes | None" = None,
spend_key: "bytes | None" = None,
orig_idx: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionSignInputRequest"]:
return isinstance(msg, cls)
class MoneroTransactionSignInputAck(protobuf.MessageType):
signature: "bytes | None"
pseudo_out: "bytes | None"
def __init__(
self,
*,
signature: "bytes | None" = None,
pseudo_out: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionSignInputAck"]:
return isinstance(msg, cls)
class MoneroTransactionFinalRequest(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionFinalRequest"]:
return isinstance(msg, cls)
class MoneroTransactionFinalAck(protobuf.MessageType):
cout_key: "bytes | None"
salt: "bytes | None"
rand_mult: "bytes | None"
tx_enc_keys: "bytes | None"
opening_key: "bytes | None"
def __init__(
self,
*,
cout_key: "bytes | None" = None,
salt: "bytes | None" = None,
rand_mult: "bytes | None" = None,
tx_enc_keys: "bytes | None" = None,
opening_key: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionFinalAck"]:
return isinstance(msg, cls)
class MoneroKeyImageExportInitRequest(protobuf.MessageType):
num: "int"
hash: "bytes"
address_n: "list[int]"
network_type: "MoneroNetworkType"
subs: "list[MoneroSubAddressIndicesList]"
def __init__(
self,
*,
num: "int",
hash: "bytes",
address_n: "list[int] | None" = None,
subs: "list[MoneroSubAddressIndicesList] | None" = None,
network_type: "MoneroNetworkType | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroKeyImageExportInitRequest"]:
return isinstance(msg, cls)
class MoneroKeyImageExportInitAck(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroKeyImageExportInitAck"]:
return isinstance(msg, cls)
class MoneroKeyImageSyncStepRequest(protobuf.MessageType):
tdis: "list[MoneroTransferDetails]"
def __init__(
self,
*,
tdis: "list[MoneroTransferDetails] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroKeyImageSyncStepRequest"]:
return isinstance(msg, cls)
class MoneroKeyImageSyncStepAck(protobuf.MessageType):
kis: "list[MoneroExportedKeyImage]"
def __init__(
self,
*,
kis: "list[MoneroExportedKeyImage] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroKeyImageSyncStepAck"]:
return isinstance(msg, cls)
class MoneroKeyImageSyncFinalRequest(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroKeyImageSyncFinalRequest"]:
return isinstance(msg, cls)
class MoneroKeyImageSyncFinalAck(protobuf.MessageType):
enc_key: "bytes | None"
def __init__(
self,
*,
enc_key: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroKeyImageSyncFinalAck"]:
return isinstance(msg, cls)
class MoneroGetTxKeyRequest(protobuf.MessageType):
address_n: "list[int]"
network_type: "MoneroNetworkType"
salt1: "bytes"
salt2: "bytes"
tx_enc_keys: "bytes"
tx_prefix_hash: "bytes"
reason: "int | None"
view_public_key: "bytes | None"
def __init__(
self,
*,
salt1: "bytes",
salt2: "bytes",
tx_enc_keys: "bytes",
tx_prefix_hash: "bytes",
address_n: "list[int] | None" = None,
network_type: "MoneroNetworkType | None" = None,
reason: "int | None" = None,
view_public_key: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroGetTxKeyRequest"]:
return isinstance(msg, cls)
class MoneroGetTxKeyAck(protobuf.MessageType):
salt: "bytes | None"
tx_keys: "bytes | None"
tx_derivations: "bytes | None"
def __init__(
self,
*,
salt: "bytes | None" = None,
tx_keys: "bytes | None" = None,
tx_derivations: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroGetTxKeyAck"]:
return isinstance(msg, cls)
class MoneroLiveRefreshStartRequest(protobuf.MessageType):
address_n: "list[int]"
network_type: "MoneroNetworkType"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
network_type: "MoneroNetworkType | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroLiveRefreshStartRequest"]:
return isinstance(msg, cls)
class MoneroLiveRefreshStartAck(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroLiveRefreshStartAck"]:
return isinstance(msg, cls)
class MoneroLiveRefreshStepRequest(protobuf.MessageType):
out_key: "bytes"
recv_deriv: "bytes"
real_out_idx: "int"
sub_addr_major: "int"
sub_addr_minor: "int"
def __init__(
self,
*,
out_key: "bytes",
recv_deriv: "bytes",
real_out_idx: "int",
sub_addr_major: "int",
sub_addr_minor: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroLiveRefreshStepRequest"]:
return isinstance(msg, cls)
class MoneroLiveRefreshStepAck(protobuf.MessageType):
salt: "bytes | None"
key_image: "bytes | None"
def __init__(
self,
*,
salt: "bytes | None" = None,
key_image: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroLiveRefreshStepAck"]:
return isinstance(msg, cls)
class MoneroLiveRefreshFinalRequest(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroLiveRefreshFinalRequest"]:
return isinstance(msg, cls)
class MoneroLiveRefreshFinalAck(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroLiveRefreshFinalAck"]:
return isinstance(msg, cls)
class DebugMoneroDiagRequest(protobuf.MessageType):
ins: "int | None"
p1: "int | None"
p2: "int | None"
pd: "list[int]"
data1: "bytes | None"
data2: "bytes | None"
def __init__(
self,
*,
pd: "list[int] | None" = None,
ins: "int | None" = None,
p1: "int | None" = None,
p2: "int | None" = None,
data1: "bytes | None" = None,
data2: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugMoneroDiagRequest"]:
return isinstance(msg, cls)
class DebugMoneroDiagAck(protobuf.MessageType):
ins: "int | None"
p1: "int | None"
p2: "int | None"
pd: "list[int]"
data1: "bytes | None"
data2: "bytes | None"
def __init__(
self,
*,
pd: "list[int] | None" = None,
ins: "int | None" = None,
p1: "int | None" = None,
p2: "int | None" = None,
data1: "bytes | None" = None,
data2: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["DebugMoneroDiagAck"]:
return isinstance(msg, cls)
class MoneroOutputEntry(protobuf.MessageType):
idx: "int | None"
key: "MoneroRctKeyPublic | None"
def __init__(
self,
*,
idx: "int | None" = None,
key: "MoneroRctKeyPublic | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroOutputEntry"]:
return isinstance(msg, cls)
class MoneroMultisigKLRki(protobuf.MessageType):
K: "bytes | None"
L: "bytes | None"
R: "bytes | None"
ki: "bytes | None"
def __init__(
self,
*,
K: "bytes | None" = None,
L: "bytes | None" = None,
R: "bytes | None" = None,
ki: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroMultisigKLRki"]:
return isinstance(msg, cls)
class MoneroRctKeyPublic(protobuf.MessageType):
dest: "bytes"
commitment: "bytes"
def __init__(
self,
*,
dest: "bytes",
commitment: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroRctKeyPublic"]:
return isinstance(msg, cls)
class MoneroAccountPublicAddress(protobuf.MessageType):
spend_public_key: "bytes | None"
view_public_key: "bytes | None"
def __init__(
self,
*,
spend_public_key: "bytes | None" = None,
view_public_key: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroAccountPublicAddress"]:
return isinstance(msg, cls)
class MoneroTransactionData(protobuf.MessageType):
version: "int | None"
payment_id: "bytes | None"
unlock_time: "int | None"
outputs: "list[MoneroTransactionDestinationEntry]"
change_dts: "MoneroTransactionDestinationEntry | None"
num_inputs: "int | None"
mixin: "int | None"
fee: "int | None"
account: "int | None"
minor_indices: "list[int]"
rsig_data: "MoneroTransactionRsigData | None"
integrated_indices: "list[int]"
client_version: "int | None"
hard_fork: "int | None"
monero_version: "bytes | None"
def __init__(
self,
*,
outputs: "list[MoneroTransactionDestinationEntry] | None" = None,
minor_indices: "list[int] | None" = None,
integrated_indices: "list[int] | None" = None,
version: "int | None" = None,
payment_id: "bytes | None" = None,
unlock_time: "int | None" = None,
change_dts: "MoneroTransactionDestinationEntry | None" = None,
num_inputs: "int | None" = None,
mixin: "int | None" = None,
fee: "int | None" = None,
account: "int | None" = None,
rsig_data: "MoneroTransactionRsigData | None" = None,
client_version: "int | None" = None,
hard_fork: "int | None" = None,
monero_version: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransactionData"]:
return isinstance(msg, cls)
class MoneroRingCtSig(protobuf.MessageType):
txn_fee: "int | None"
message: "bytes | None"
rv_type: "int | None"
def __init__(
self,
*,
txn_fee: "int | None" = None,
message: "bytes | None" = None,
rv_type: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroRingCtSig"]:
return isinstance(msg, cls)
class MoneroSubAddressIndicesList(protobuf.MessageType):
account: "int"
minor_indices: "list[int]"
def __init__(
self,
*,
account: "int",
minor_indices: "list[int] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroSubAddressIndicesList"]:
return isinstance(msg, cls)
class MoneroTransferDetails(protobuf.MessageType):
out_key: "bytes"
tx_pub_key: "bytes"
additional_tx_pub_keys: "list[bytes]"
internal_output_index: "int"
sub_addr_major: "int | None"
sub_addr_minor: "int | None"
def __init__(
self,
*,
out_key: "bytes",
tx_pub_key: "bytes",
internal_output_index: "int",
additional_tx_pub_keys: "list[bytes] | None" = None,
sub_addr_major: "int | None" = None,
sub_addr_minor: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroTransferDetails"]:
return isinstance(msg, cls)
class MoneroExportedKeyImage(protobuf.MessageType):
iv: "bytes | None"
blob: "bytes | None"
def __init__(
self,
*,
iv: "bytes | None" = None,
blob: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["MoneroExportedKeyImage"]:
return isinstance(msg, cls)
class NEMGetAddress(protobuf.MessageType):
address_n: "list[int]"
network: "int"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
network: "int | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMGetAddress"]:
return isinstance(msg, cls)
class NEMAddress(protobuf.MessageType):
address: "str"
def __init__(
self,
*,
address: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMAddress"]:
return isinstance(msg, cls)
class NEMSignTx(protobuf.MessageType):
transaction: "NEMTransactionCommon"
multisig: "NEMTransactionCommon | None"
transfer: "NEMTransfer | None"
cosigning: "bool | None"
provision_namespace: "NEMProvisionNamespace | None"
mosaic_creation: "NEMMosaicCreation | None"
supply_change: "NEMMosaicSupplyChange | None"
aggregate_modification: "NEMAggregateModification | None"
importance_transfer: "NEMImportanceTransfer | None"
def __init__(
self,
*,
transaction: "NEMTransactionCommon",
multisig: "NEMTransactionCommon | None" = None,
transfer: "NEMTransfer | None" = None,
cosigning: "bool | None" = None,
provision_namespace: "NEMProvisionNamespace | None" = None,
mosaic_creation: "NEMMosaicCreation | None" = None,
supply_change: "NEMMosaicSupplyChange | None" = None,
aggregate_modification: "NEMAggregateModification | None" = None,
importance_transfer: "NEMImportanceTransfer | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMSignTx"]:
return isinstance(msg, cls)
class NEMSignedTx(protobuf.MessageType):
data: "bytes"
signature: "bytes"
def __init__(
self,
*,
data: "bytes",
signature: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMSignedTx"]:
return isinstance(msg, cls)
class NEMDecryptMessage(protobuf.MessageType):
address_n: "list[int]"
network: "int | None"
public_key: "bytes | None"
payload: "bytes | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
network: "int | None" = None,
public_key: "bytes | None" = None,
payload: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMDecryptMessage"]:
return isinstance(msg, cls)
class NEMDecryptedMessage(protobuf.MessageType):
payload: "bytes"
def __init__(
self,
*,
payload: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMDecryptedMessage"]:
return isinstance(msg, cls)
class NEMTransactionCommon(protobuf.MessageType):
address_n: "list[int]"
network: "int"
timestamp: "int"
fee: "int"
deadline: "int"
signer: "bytes | None"
def __init__(
self,
*,
timestamp: "int",
fee: "int",
deadline: "int",
address_n: "list[int] | None" = None,
network: "int | None" = None,
signer: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMTransactionCommon"]:
return isinstance(msg, cls)
class NEMTransfer(protobuf.MessageType):
recipient: "str"
amount: "int"
payload: "bytes"
public_key: "bytes | None"
mosaics: "list[NEMMosaic]"
def __init__(
self,
*,
recipient: "str",
amount: "int",
mosaics: "list[NEMMosaic] | None" = None,
payload: "bytes | None" = None,
public_key: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMTransfer"]:
return isinstance(msg, cls)
class NEMProvisionNamespace(protobuf.MessageType):
namespace: "str"
parent: "str | None"
sink: "str"
fee: "int"
def __init__(
self,
*,
namespace: "str",
sink: "str",
fee: "int",
parent: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMProvisionNamespace"]:
return isinstance(msg, cls)
class NEMMosaicCreation(protobuf.MessageType):
definition: "NEMMosaicDefinition"
sink: "str"
fee: "int"
def __init__(
self,
*,
definition: "NEMMosaicDefinition",
sink: "str",
fee: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMMosaicCreation"]:
return isinstance(msg, cls)
class NEMMosaicSupplyChange(protobuf.MessageType):
namespace: "str"
mosaic: "str"
type: "NEMSupplyChangeType"
delta: "int"
def __init__(
self,
*,
namespace: "str",
mosaic: "str",
type: "NEMSupplyChangeType",
delta: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMMosaicSupplyChange"]:
return isinstance(msg, cls)
class NEMAggregateModification(protobuf.MessageType):
modifications: "list[NEMCosignatoryModification]"
relative_change: "int | None"
def __init__(
self,
*,
modifications: "list[NEMCosignatoryModification] | None" = None,
relative_change: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMAggregateModification"]:
return isinstance(msg, cls)
class NEMImportanceTransfer(protobuf.MessageType):
mode: "NEMImportanceTransferMode"
public_key: "bytes"
def __init__(
self,
*,
mode: "NEMImportanceTransferMode",
public_key: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMImportanceTransfer"]:
return isinstance(msg, cls)
class NEMMosaic(protobuf.MessageType):
namespace: "str"
mosaic: "str"
quantity: "int"
def __init__(
self,
*,
namespace: "str",
mosaic: "str",
quantity: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMMosaic"]:
return isinstance(msg, cls)
class NEMMosaicDefinition(protobuf.MessageType):
name: "str | None"
ticker: "str | None"
namespace: "str"
mosaic: "str"
divisibility: "int | None"
levy: "NEMMosaicLevy | None"
fee: "int | None"
levy_address: "str | None"
levy_namespace: "str | None"
levy_mosaic: "str | None"
supply: "int | None"
mutable_supply: "bool | None"
transferable: "bool | None"
description: "str"
networks: "list[int]"
def __init__(
self,
*,
namespace: "str",
mosaic: "str",
description: "str",
networks: "list[int] | None" = None,
name: "str | None" = None,
ticker: "str | None" = None,
divisibility: "int | None" = None,
levy: "NEMMosaicLevy | None" = None,
fee: "int | None" = None,
levy_address: "str | None" = None,
levy_namespace: "str | None" = None,
levy_mosaic: "str | None" = None,
supply: "int | None" = None,
mutable_supply: "bool | None" = None,
transferable: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMMosaicDefinition"]:
return isinstance(msg, cls)
class NEMCosignatoryModification(protobuf.MessageType):
type: "NEMModificationType"
public_key: "bytes"
def __init__(
self,
*,
type: "NEMModificationType",
public_key: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["NEMCosignatoryModification"]:
return isinstance(msg, cls)
class RippleGetAddress(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["RippleGetAddress"]:
return isinstance(msg, cls)
class RippleAddress(protobuf.MessageType):
address: "str"
def __init__(
self,
*,
address: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["RippleAddress"]:
return isinstance(msg, cls)
class RippleSignTx(protobuf.MessageType):
address_n: "list[int]"
fee: "int"
flags: "int"
sequence: "int"
last_ledger_sequence: "int | None"
payment: "RipplePayment"
def __init__(
self,
*,
fee: "int",
sequence: "int",
payment: "RipplePayment",
address_n: "list[int] | None" = None,
flags: "int | None" = None,
last_ledger_sequence: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["RippleSignTx"]:
return isinstance(msg, cls)
class RippleSignedTx(protobuf.MessageType):
signature: "bytes"
serialized_tx: "bytes"
def __init__(
self,
*,
signature: "bytes",
serialized_tx: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["RippleSignedTx"]:
return isinstance(msg, cls)
class RipplePayment(protobuf.MessageType):
amount: "int"
destination: "str"
destination_tag: "int | None"
def __init__(
self,
*,
amount: "int",
destination: "str",
destination_tag: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["RipplePayment"]:
return isinstance(msg, cls)
class StellarAsset(protobuf.MessageType):
type: "StellarAssetType"
code: "str | None"
issuer: "str | None"
def __init__(
self,
*,
type: "StellarAssetType",
code: "str | None" = None,
issuer: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarAsset"]:
return isinstance(msg, cls)
class StellarGetAddress(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarGetAddress"]:
return isinstance(msg, cls)
class StellarAddress(protobuf.MessageType):
address: "str"
def __init__(
self,
*,
address: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarAddress"]:
return isinstance(msg, cls)
class StellarSignTx(protobuf.MessageType):
address_n: "list[int]"
network_passphrase: "str"
source_account: "str"
fee: "int"
sequence_number: "int"
timebounds_start: "int"
timebounds_end: "int"
memo_type: "StellarMemoType"
memo_text: "str | None"
memo_id: "int | None"
memo_hash: "bytes | None"
num_operations: "int"
def __init__(
self,
*,
network_passphrase: "str",
source_account: "str",
fee: "int",
sequence_number: "int",
timebounds_start: "int",
timebounds_end: "int",
memo_type: "StellarMemoType",
num_operations: "int",
address_n: "list[int] | None" = None,
memo_text: "str | None" = None,
memo_id: "int | None" = None,
memo_hash: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarSignTx"]:
return isinstance(msg, cls)
class StellarTxOpRequest(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarTxOpRequest"]:
return isinstance(msg, cls)
class StellarPaymentOp(protobuf.MessageType):
source_account: "str | None"
destination_account: "str"
asset: "StellarAsset"
amount: "int"
def __init__(
self,
*,
destination_account: "str",
asset: "StellarAsset",
amount: "int",
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarPaymentOp"]:
return isinstance(msg, cls)
class StellarCreateAccountOp(protobuf.MessageType):
source_account: "str | None"
new_account: "str"
starting_balance: "int"
def __init__(
self,
*,
new_account: "str",
starting_balance: "int",
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarCreateAccountOp"]:
return isinstance(msg, cls)
class StellarPathPaymentStrictReceiveOp(protobuf.MessageType):
source_account: "str | None"
send_asset: "StellarAsset"
send_max: "int"
destination_account: "str"
destination_asset: "StellarAsset"
destination_amount: "int"
paths: "list[StellarAsset]"
def __init__(
self,
*,
send_asset: "StellarAsset",
send_max: "int",
destination_account: "str",
destination_asset: "StellarAsset",
destination_amount: "int",
paths: "list[StellarAsset] | None" = None,
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarPathPaymentStrictReceiveOp"]:
return isinstance(msg, cls)
class StellarPathPaymentStrictSendOp(protobuf.MessageType):
source_account: "str | None"
send_asset: "StellarAsset"
send_amount: "int"
destination_account: "str"
destination_asset: "StellarAsset"
destination_min: "int"
paths: "list[StellarAsset]"
def __init__(
self,
*,
send_asset: "StellarAsset",
send_amount: "int",
destination_account: "str",
destination_asset: "StellarAsset",
destination_min: "int",
paths: "list[StellarAsset] | None" = None,
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarPathPaymentStrictSendOp"]:
return isinstance(msg, cls)
class StellarManageSellOfferOp(protobuf.MessageType):
source_account: "str | None"
selling_asset: "StellarAsset"
buying_asset: "StellarAsset"
amount: "int"
price_n: "int"
price_d: "int"
offer_id: "int"
def __init__(
self,
*,
selling_asset: "StellarAsset",
buying_asset: "StellarAsset",
amount: "int",
price_n: "int",
price_d: "int",
offer_id: "int",
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarManageSellOfferOp"]:
return isinstance(msg, cls)
class StellarManageBuyOfferOp(protobuf.MessageType):
source_account: "str | None"
selling_asset: "StellarAsset"
buying_asset: "StellarAsset"
amount: "int"
price_n: "int"
price_d: "int"
offer_id: "int"
def __init__(
self,
*,
selling_asset: "StellarAsset",
buying_asset: "StellarAsset",
amount: "int",
price_n: "int",
price_d: "int",
offer_id: "int",
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarManageBuyOfferOp"]:
return isinstance(msg, cls)
class StellarCreatePassiveSellOfferOp(protobuf.MessageType):
source_account: "str | None"
selling_asset: "StellarAsset"
buying_asset: "StellarAsset"
amount: "int"
price_n: "int"
price_d: "int"
def __init__(
self,
*,
selling_asset: "StellarAsset",
buying_asset: "StellarAsset",
amount: "int",
price_n: "int",
price_d: "int",
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarCreatePassiveSellOfferOp"]:
return isinstance(msg, cls)
class StellarSetOptionsOp(protobuf.MessageType):
source_account: "str | None"
inflation_destination_account: "str | None"
clear_flags: "int | None"
set_flags: "int | None"
master_weight: "int | None"
low_threshold: "int | None"
medium_threshold: "int | None"
high_threshold: "int | None"
home_domain: "str | None"
signer_type: "StellarSignerType | None"
signer_key: "bytes | None"
signer_weight: "int | None"
def __init__(
self,
*,
source_account: "str | None" = None,
inflation_destination_account: "str | None" = None,
clear_flags: "int | None" = None,
set_flags: "int | None" = None,
master_weight: "int | None" = None,
low_threshold: "int | None" = None,
medium_threshold: "int | None" = None,
high_threshold: "int | None" = None,
home_domain: "str | None" = None,
signer_type: "StellarSignerType | None" = None,
signer_key: "bytes | None" = None,
signer_weight: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarSetOptionsOp"]:
return isinstance(msg, cls)
class StellarChangeTrustOp(protobuf.MessageType):
source_account: "str | None"
asset: "StellarAsset"
limit: "int"
def __init__(
self,
*,
asset: "StellarAsset",
limit: "int",
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarChangeTrustOp"]:
return isinstance(msg, cls)
class StellarAllowTrustOp(protobuf.MessageType):
source_account: "str | None"
trusted_account: "str"
asset_type: "StellarAssetType"
asset_code: "str | None"
is_authorized: "bool"
def __init__(
self,
*,
trusted_account: "str",
asset_type: "StellarAssetType",
is_authorized: "bool",
source_account: "str | None" = None,
asset_code: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarAllowTrustOp"]:
return isinstance(msg, cls)
class StellarAccountMergeOp(protobuf.MessageType):
source_account: "str | None"
destination_account: "str"
def __init__(
self,
*,
destination_account: "str",
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarAccountMergeOp"]:
return isinstance(msg, cls)
class StellarManageDataOp(protobuf.MessageType):
source_account: "str | None"
key: "str"
value: "bytes | None"
def __init__(
self,
*,
key: "str",
source_account: "str | None" = None,
value: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarManageDataOp"]:
return isinstance(msg, cls)
class StellarBumpSequenceOp(protobuf.MessageType):
source_account: "str | None"
bump_to: "int"
def __init__(
self,
*,
bump_to: "int",
source_account: "str | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarBumpSequenceOp"]:
return isinstance(msg, cls)
class StellarSignedTx(protobuf.MessageType):
public_key: "bytes"
signature: "bytes"
def __init__(
self,
*,
public_key: "bytes",
signature: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["StellarSignedTx"]:
return isinstance(msg, cls)
class TezosGetAddress(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosGetAddress"]:
return isinstance(msg, cls)
class TezosAddress(protobuf.MessageType):
address: "str"
def __init__(
self,
*,
address: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosAddress"]:
return isinstance(msg, cls)
class TezosGetPublicKey(protobuf.MessageType):
address_n: "list[int]"
show_display: "bool | None"
def __init__(
self,
*,
address_n: "list[int] | None" = None,
show_display: "bool | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosGetPublicKey"]:
return isinstance(msg, cls)
class TezosPublicKey(protobuf.MessageType):
public_key: "str"
def __init__(
self,
*,
public_key: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosPublicKey"]:
return isinstance(msg, cls)
class TezosSignTx(protobuf.MessageType):
address_n: "list[int]"
branch: "bytes"
reveal: "TezosRevealOp | None"
transaction: "TezosTransactionOp | None"
origination: "TezosOriginationOp | None"
delegation: "TezosDelegationOp | None"
proposal: "TezosProposalOp | None"
ballot: "TezosBallotOp | None"
def __init__(
self,
*,
branch: "bytes",
address_n: "list[int] | None" = None,
reveal: "TezosRevealOp | None" = None,
transaction: "TezosTransactionOp | None" = None,
origination: "TezosOriginationOp | None" = None,
delegation: "TezosDelegationOp | None" = None,
proposal: "TezosProposalOp | None" = None,
ballot: "TezosBallotOp | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosSignTx"]:
return isinstance(msg, cls)
class TezosSignedTx(protobuf.MessageType):
signature: "str"
sig_op_contents: "bytes"
operation_hash: "str"
def __init__(
self,
*,
signature: "str",
sig_op_contents: "bytes",
operation_hash: "str",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosSignedTx"]:
return isinstance(msg, cls)
class TezosContractID(protobuf.MessageType):
tag: "TezosContractType"
hash: "bytes"
def __init__(
self,
*,
tag: "TezosContractType",
hash: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosContractID"]:
return isinstance(msg, cls)
class TezosRevealOp(protobuf.MessageType):
source: "bytes"
fee: "int"
counter: "int"
gas_limit: "int"
storage_limit: "int"
public_key: "bytes"
def __init__(
self,
*,
source: "bytes",
fee: "int",
counter: "int",
gas_limit: "int",
storage_limit: "int",
public_key: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosRevealOp"]:
return isinstance(msg, cls)
class TezosTransactionOp(protobuf.MessageType):
source: "bytes"
fee: "int"
counter: "int"
gas_limit: "int"
storage_limit: "int"
amount: "int"
destination: "TezosContractID"
parameters: "bytes | None"
parameters_manager: "TezosParametersManager | None"
def __init__(
self,
*,
source: "bytes",
fee: "int",
counter: "int",
gas_limit: "int",
storage_limit: "int",
amount: "int",
destination: "TezosContractID",
parameters: "bytes | None" = None,
parameters_manager: "TezosParametersManager | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosTransactionOp"]:
return isinstance(msg, cls)
class TezosOriginationOp(protobuf.MessageType):
source: "bytes"
fee: "int"
counter: "int"
gas_limit: "int"
storage_limit: "int"
manager_pubkey: "bytes | None"
balance: "int"
spendable: "bool | None"
delegatable: "bool | None"
delegate: "bytes | None"
script: "bytes"
def __init__(
self,
*,
source: "bytes",
fee: "int",
counter: "int",
gas_limit: "int",
storage_limit: "int",
balance: "int",
script: "bytes",
manager_pubkey: "bytes | None" = None,
spendable: "bool | None" = None,
delegatable: "bool | None" = None,
delegate: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosOriginationOp"]:
return isinstance(msg, cls)
class TezosDelegationOp(protobuf.MessageType):
source: "bytes"
fee: "int"
counter: "int"
gas_limit: "int"
storage_limit: "int"
delegate: "bytes"
def __init__(
self,
*,
source: "bytes",
fee: "int",
counter: "int",
gas_limit: "int",
storage_limit: "int",
delegate: "bytes",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosDelegationOp"]:
return isinstance(msg, cls)
class TezosProposalOp(protobuf.MessageType):
source: "bytes"
period: "int"
proposals: "list[bytes]"
def __init__(
self,
*,
source: "bytes",
period: "int",
proposals: "list[bytes] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosProposalOp"]:
return isinstance(msg, cls)
class TezosBallotOp(protobuf.MessageType):
source: "bytes"
period: "int"
proposal: "bytes"
ballot: "TezosBallotType"
def __init__(
self,
*,
source: "bytes",
period: "int",
proposal: "bytes",
ballot: "TezosBallotType",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosBallotOp"]:
return isinstance(msg, cls)
class TezosParametersManager(protobuf.MessageType):
set_delegate: "bytes | None"
cancel_delegate: "bool | None"
transfer: "TezosManagerTransfer | None"
def __init__(
self,
*,
set_delegate: "bytes | None" = None,
cancel_delegate: "bool | None" = None,
transfer: "TezosManagerTransfer | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosParametersManager"]:
return isinstance(msg, cls)
class TezosManagerTransfer(protobuf.MessageType):
destination: "TezosContractID"
amount: "int"
def __init__(
self,
*,
destination: "TezosContractID",
amount: "int",
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["TezosManagerTransfer"]:
return isinstance(msg, cls)
class WebAuthnListResidentCredentials(protobuf.MessageType):
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["WebAuthnListResidentCredentials"]:
return isinstance(msg, cls)
class WebAuthnAddResidentCredential(protobuf.MessageType):
credential_id: "bytes | None"
def __init__(
self,
*,
credential_id: "bytes | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["WebAuthnAddResidentCredential"]:
return isinstance(msg, cls)
class WebAuthnRemoveResidentCredential(protobuf.MessageType):
index: "int | None"
def __init__(
self,
*,
index: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["WebAuthnRemoveResidentCredential"]:
return isinstance(msg, cls)
class WebAuthnCredentials(protobuf.MessageType):
credentials: "list[WebAuthnCredential]"
def __init__(
self,
*,
credentials: "list[WebAuthnCredential] | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["WebAuthnCredentials"]:
return isinstance(msg, cls)
class WebAuthnCredential(protobuf.MessageType):
index: "int | None"
id: "bytes | None"
rp_id: "str | None"
rp_name: "str | None"
user_id: "bytes | None"
user_name: "str | None"
user_display_name: "str | None"
creation_time: "int | None"
hmac_secret: "bool | None"
use_sign_count: "bool | None"
algorithm: "int | None"
curve: "int | None"
def __init__(
self,
*,
index: "int | None" = None,
id: "bytes | None" = None,
rp_id: "str | None" = None,
rp_name: "str | None" = None,
user_id: "bytes | None" = None,
user_name: "str | None" = None,
user_display_name: "str | None" = None,
creation_time: "int | None" = None,
hmac_secret: "bool | None" = None,
use_sign_count: "bool | None" = None,
algorithm: "int | None" = None,
curve: "int | None" = None,
) -> None:
pass
@classmethod
def is_type_of(cls, msg: protobuf.MessageType) -> TypeGuard["WebAuthnCredential"]:
return isinstance(msg, cls)