Enum PlatformAddress 

pub enum PlatformAddress {
    P2pkh([u8; 20]),
    P2sh([u8; 20]),
}

Variants

P2pkh([u8; 20])

Pay to pubkey hash

• bech32m encoding type byte: 0xb0
• storage key type byte: 0x00

P2sh([u8; 20])

Pay to script hash

• bech32m encoding type byte: 0x80
• storage key type byte: 0x01

Implementations

impl PlatformAddress

pub const P2PKH_TYPE: u8 = 0xb0

Type byte for P2PKH addresses in bech32m encoding (user-facing)

pub const P2SH_TYPE: u8 = 0x80

Type byte for P2SH addresses in bech32m encoding (user-facing)

pub fn hrp_for_network(network: Network) -> &'static str

Returns the appropriate HRP (Human-Readable Part) for the given network.

Per DIP-0018:

• Mainnet: “dash”
• Testnet/Devnet/Regtest: “tdash”

pub fn to_bech32m_string(&self, network: Network) -> String

Encodes the PlatformAddress as a bech32m string for the specified network.

The encoding follows DIP-0018:

• Format: <HRP>1<data-part>
• Data: type_byte (0xb0 for P2PKH, 0x80 for P2SH) || 20-byte hash
• Checksum: bech32m (BIP-350)

NOTE: This uses bech32m type bytes (0xb0/0x80) for user-facing addresses, NOT the storage type bytes (0x00/0x01) used in GroveDB keys.

Example

let address = PlatformAddress::P2pkh([0xf7, 0xda, ...]);
let encoded = address.to_bech32m_string(Network::Mainnet);
// Returns something like "dash1k..."

pub fn from_bech32m_string(s: &str) -> Result<(Self, Network), ProtocolError>

Decodes a bech32m-encoded Platform address string per DIP-0018.

NOTE: This expects bech32m type bytes (0xb0/0x80) in the encoded string, NOT the storage type bytes (0x00/0x01) used in GroveDB keys.

Returns

• Ok((PlatformAddress, Network)) - The decoded address and its network
• Err(ProtocolError) - If the address is invalid

pub fn to_address_with_network(&self, network: Network) -> Address

Converts the PlatformAddress to a dashcore Address with the specified network.

pub fn to_bytes(&self) -> Vec<u8>

Converts the PlatformAddress to bytes for storage keys. Format: [variant_index (1 byte)] + [hash (20 bytes)]

Uses bincode serialization which produces: 0x00 for P2pkh, 0x01 for P2sh. These bytes are used as keys in GroveDB.

pub fn base64_string_with_nonce(&self, nonce: AddressNonce) -> String

Gets a base64 string of the PlatformAddress concatenated with the nonce. This creates a unique identifier for address-based state transition inputs.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, ProtocolError>

Creates a PlatformAddress from storage bytes. Format: [variant_index (1 byte)] + [hash (20 bytes)]

Uses bincode deserialization which expects: 0x00 for P2pkh, 0x01 for P2sh.

pub fn hash(&self) -> &[u8; 20]

Returns the hash portion of the address (20 bytes)

pub fn is_p2pkh(&self) -> bool

Returns true if this is a P2PKH address

pub fn is_p2sh(&self) -> bool

Returns true if this is a P2SH address

pub fn verify_bytes_against_witness( &self, witness: &AddressWitness, signable_bytes: &[u8], ) -> Result<AddressWitnessVerificationOperations, ProtocolError>

Verifies that the provided witness matches this address and that signatures are valid.

For P2PKH addresses:

• The witness must be AddressWitness::P2pkh
• The public key must hash to this address
• The signature must be valid for the signable bytes

For P2SH addresses:

• The witness must be AddressWitness::P2sh
• The redeem script must hash to this address
• For multisig scripts: M valid signatures must be provided for the signable bytes

Arguments

• witness - The witness containing signature(s) and either a public key (P2PKH) or redeem script (P2SH)
• signable_bytes - The data that was signed (will be double-SHA256 hashed internally)

Returns

• Ok(AddressWitnessVerificationOperations) - Operations performed if verification succeeds
• Err(ProtocolError) if verification fails

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for PlatformAddress

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Clone for PlatformAddress

fn clone(&self) -> PlatformAddress

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlatformAddress

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for PlatformAddress

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl Default for PlatformAddress

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PlatformAddress

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PlatformAddress

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

Formats the value using the given formatter.

impl Encode for PlatformAddress

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl From<&PrivateKey> for PlatformAddress

fn from(private_key: &PrivateKey) -> Self

Derives a P2PKH Platform address from a private key.

The address is derived as: P2PKH(Hash160(compressed_public_key)) where Hash160 = RIPEMD160(SHA256(x)), which is the standard Bitcoin P2PKH derivation.

impl FromStr for PlatformAddress

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a bech32m-encoded Platform address string.

This accepts addresses with either mainnet (“dash”) or testnet (“tdash”) HRP. The network information is discarded; use from_bech32m_string if you need to preserve the network.

Example

let address: PlatformAddress = "dash1k...".parse()?;

type Err = PlatformAddressParseError

The associated error which can be returned from parsing.

impl Hash for PlatformAddress

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

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 Ord for PlatformAddress

fn cmp(&self, other: &PlatformAddress) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for PlatformAddress

fn eq(&self, other: &PlatformAddress) -> 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 PartialOrd for PlatformAddress

fn partial_cmp(&self, other: &PlatformAddress) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PlatformDeserializable for PlatformAddress

fn deserialize_from_bytes(data: &[u8]) -> Result<Self, ProtocolError>

where Self: Sized,

fn deserialize_from_bytes_no_limit(data: &[u8]) -> Result<Self, ProtocolError>

where Self: Sized,

impl PlatformSerializable for PlatformAddress

type Error = ProtocolError

fn serialize_to_bytes(&self) -> Result<Vec<u8>, Self::Error>

fn serialize_consume_to_bytes(self) -> Result<Vec<u8>, Self::Error>

If the trait is not used just do a simple serialize

impl PlatformVersionEncode for PlatformAddress

fn platform_encode<__E: Encoder>( &self, encoder: &mut __E, platform_version: &PlatformVersion, ) -> Result<(), EncodeError>

Encode a given type.

impl<'__de> PlatformVersionedBorrowDecode<'__de> for PlatformAddress

fn platform_versioned_borrow_decode<__D: BorrowDecoder<'__de, Context = BincodeContext>>( decoder: &mut __D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl PlatformVersionedDecode for PlatformAddress

fn platform_versioned_decode<__D: Decoder<Context = BincodeContext>>( decoder: &mut __D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl Serialize for PlatformAddress

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Address> for PlatformAddress

type Error = ProtocolError

The type returned in the event of a conversion error.

fn try_from(address: Address) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for PlatformAddress

impl Eq for PlatformAddress

impl JsonSafeFields for PlatformAddress

impl StructuralPartialEq for PlatformAddress