Address Conversion#
The hashes used in P2PKH and P2SH outputs are commonly encoded as Dash addresses. This is the procedure to encode those hashes and decode the addresses.
Conversion Process#
First, get your hash. For P2PKH, you RIPEMD-160(SHA256()) hash a ECDSA public key derived from your 256-bit ECDSA private key (random data). For P2SH, you RIPEMD-160(SHA256()) hash a redeem script serialized in the format used in raw transactions (described in a following sub-section). Taking the resulting hash:
Add an address version byte in front of the hash. The version bytes commonly used by Dash are:
0x4c for P2PKH addresses on the main Dash network (mainnet)
0x8c for P2PKH addresses on the Dash testing network (testnet)
0x10 for P2SH addresses on mainnet
0x13 for P2SH addresses on testnet
Create a copy of the version and hash; then hash that twice with SHA256:
SHA256(SHA256(version . hash))Extract the first four bytes from the double-hashed copy. These are used as a checksum to ensure the base hash gets transmitted correctly.
Append the checksum to the version and hash, and encode it as a base58 string:
BASE58(version . hash . checksum)
Example Code#
Dash’s base58 encoding, called Base58Check may not match other implementations. Tier Nolan provided the following example encoding algorithm to the Bitcoin Wiki Base58Check encoding page under the Creative Commons Attribution 3.0 license:
code_string = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
x = convert_bytes_to_big_integer(hash_result)
output_string = ""
while(x > 0)
{
(x, remainder) = divide(x, 58)
output_string.append(code_string[remainder])
}
repeat(number_of_leading_zero_bytes_in_hash)
{
output_string.append(code_string[0]);
}
output_string.reverse();
Dash’s own code can be traced using the base58 header file.
To convert addresses back into hashes, reverse the base58 encoding, extract the checksum, repeat the steps to create the checksum and compare it against the extracted checksum, and then remove the version byte.
Dash Platform Addresses#
Dash Core also encodes and decodes Dash Platform addresses, which DIP18 defines. A Platform address uses the same P2PKH or P2SH hash, but encodes it with bech32m instead of Base58Check:
Add a type byte in front of the 20-byte hash to create a 21-byte payload. The type bytes are:
0xb0 for P2PKH addresses
0x80 for P2SH addresses
Encode the payload as a bech32m string using the human-readable part (HRP) for the network:
Because of the type bytes, P2PKH Platform addresses start with dash1k (tdash1k) and P2SH Platform addresses start with dash1s (tdash1s). For example, the P2PKH hash f7da0a2b5cbd4ff6bb2c4d89b67d2f3ffeec0525 encodes as dash1krma5z3ttj75la4m93xcndna9ullamq9y5e9n5rs on mainnet and tdash1krma5z3ttj75la4m93xcndna9ullamq9y5fzq2j7 on testnet. Decoding rejects an address with a bech32 (not bech32m) checksum, the wrong HRP for the network, a payload that isn’t 21 bytes, or an unknown type byte.
The validateaddress RPC and getaddressinfo RPC accept Platform addresses. The sendtoaddress RPC and sendmany RPC also accept them once the v24 hard fork activates. Paying a Platform address creates an asset lock transaction with a version 2 payload, whose credit output pays the standard P2PKH or P2SH script for the address’s hash. Version 2 asset locks are currently non-standard, so the wallet only sends to Platform addresses on a node started with -acceptnonstdtxn=1, which is only available on testnet, devnets and regtest.