Struct Signed 

pub struct Signed<T>
where
    T: Encodable,
{
    pub payload: T,
    pub signature: SignatureType,
    pub hash: OnceLock<FixedBytes<32>>,
}

A transaction with a signature and hash seal.

Fields

payload: T

The payload is the raw transaction that submitted by the user.

signature: SignatureType

The signature(s) - either single or multi-sig

hash: OnceLock<FixedBytes<32>>

The hash of the transaction, which is used to identify the transaction. And it’s calculated by the payload and the signature, and no need to be serialized and stored in the database.

Implementations

impl<T> Signed<T>

where T: Encodable,

pub fn is_multi_sig(&self) -> bool

Check if this is a multi-sig transaction

pub fn multi_sig_info(&self) -> Option<(Address, &[MultiSigSignatureEntry])>

Get the multi-sig account and signatures if this is a multi-sig transaction

pub fn signature_count(&self) -> usize

Get the number of signatures in this transaction

impl<T> Signed<T>

where T: Encodable + TxHashable,

pub fn new(payload: T, signature: Signature) -> Signed<T>

Creates a new signed transaction with a single signature.

The transaction hash is computed immediately and cached in OnceLock.

pub fn new_multi_sig( payload: T, multisig_account: Address, signatures: Vec<MultiSigSignatureEntry>, ) -> Signed<T>

Creates a new multi-sig transaction with multiple signatures.

The transaction hash includes all signatures to ensure uniqueness.

Arguments

• payload - The transaction payload
• multisig_account - The multi-sig account address (sender)
• signatures - The list of signatures from authorized signers

pub fn new_unchecked( payload: T, signature: Signature, hash: FixedBytes<32>, ) -> Signed<T>

Creates a new signed transaction with the given payload and signature, and the hash of the transaction is already calculated. The function will not calculate the hash again, so the caller should ensure the hash is correct.

It’s mainly used for testing.

pub fn new_unhashed(payload: T, signature: Signature) -> Signed<T>

Creates a new signed transaction with the given payload and signature, but without hashing the transaction. And when getting the hash at the first time, it will be calculated.

pub fn payload(&self) -> &T

Returns the payload of the signed transaction.

pub fn signature(&self) -> &SignatureType

Returns the signature(s) of the signed transaction.

pub fn signature_type(&self) -> &SignatureType

Returns the signature(s) of the signed transaction. Alias for signature() for backwards compatibility.

pub fn hash(&self) -> &FixedBytes<32>

Returns the hash of the signed transaction, the hash is calculated when first time called (for deserialized transactions), and cached in OnceLock.

pub fn slow_hash(&self) -> FixedBytes<32>

Returns the hash of the raw transaction with signature. This is slower than hash() as it recalculates every time.

Trait Implementations

impl<T> AsRef<T> for Signed<T>

where T: Encodable,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clone for Signed<T>

where T: Clone + Encodable,

fn clone(&self) -> Signed<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Signed<T>

where T: Debug + Encodable,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Signed<T>

where T: Encodable + Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Signed<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Signed<PaymentPayload>> for RawTransactionEnvelope

fn from(signed: Signed<PaymentPayload>) -> RawTransactionEnvelope

Converts to this type from the input type.

impl From<Signed<TokenAuthorityPayload>> for RawTransactionEnvelope

fn from(signed: Signed<TokenAuthorityPayload>) -> RawTransactionEnvelope

Converts to this type from the input type.

impl From<Signed<TokenBlacklistPayload>> for RawTransactionEnvelope

fn from(signed: Signed<TokenBlacklistPayload>) -> RawTransactionEnvelope

Converts to this type from the input type.

impl From<Signed<TokenBurnPayload>> for RawTransactionEnvelope

fn from(signed: Signed<TokenBurnPayload>) -> RawTransactionEnvelope

Converts to this type from the input type.

impl From<Signed<TokenClawbackPayload>> for RawTransactionEnvelope

fn from(signed: Signed<TokenClawbackPayload>) -> RawTransactionEnvelope

Converts to this type from the input type.

impl From<Signed<TokenMetadataUpdatePayload>> for RawTransactionEnvelope

fn from(signed: Signed<TokenMetadataUpdatePayload>) -> RawTransactionEnvelope

Converts to this type from the input type.

impl From<Signed<TokenMintPayload>> for RawTransactionEnvelope

fn from(signed: Signed<TokenMintPayload>) -> RawTransactionEnvelope

Converts to this type from the input type.

impl From<Signed<TokenPausePayload>> for RawTransactionEnvelope

fn from(signed: Signed<TokenPausePayload>) -> RawTransactionEnvelope

Converts to this type from the input type.

impl From<Signed<TokenWhitelistPayload>> for RawTransactionEnvelope

fn from(signed: Signed<TokenWhitelistPayload>) -> RawTransactionEnvelope

Converts to this type from the input type.

impl<T> Hash for Signed<T>

where T: Hash + Encodable + TxHashable,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for Signed<T>

where T: PartialEq + Encodable,

fn eq(&self, other: &Signed<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for Signed<T>

where T: Encodable + Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> SignerRecoverable for Signed<T>

where T: Signable + Encodable,

fn recover_signer(&self) -> Result<Address, SigError>

Recover the signer from the transaction payload and the signature.

For single-sig transactions: recovers the single signer. For multi-sig transactions: returns the multi-sig account address (not individual signers).

impl<T> Eq for Signed<T>

where T: Eq + Encodable,

impl<T> StructuralPartialEq for Signed<T>

where T: Encodable,