common/address.go

   1 package common
   2
   3 import (
   4         "bytes"
   5         "errors"
   6         "fmt"
   7         "strings"
   8
   9         "github.com/bytom/common/bech32"
  10         "github.com/bytom/consensus"
  11 )
  12
  13 var (
  14         // ErrChecksumMismatch describes an error where decoding failed due
  15         // to a bad checksum.
  16         ErrChecksumMismatch = errors.New("checksum mismatch")
  17
  18         // ErrUnknownAddressType describes an error where an address can not
  19         // decoded as a specific address type due to the string encoding
  20         // begining with an identifier byte unknown to any standard or
  21         // registered (via chaincfg.Register) network.
  22         ErrUnknownAddressType = errors.New("unknown address type")
  23
  24         // ErrAddressCollision describes an error where an address can not
  25         // be uniquely determined as either a pay-to-pubkey-hash or
  26         // pay-to-script-hash address since the leading identifier is used for
  27         // describing both address kinds, but for different networks.  Rather
  28         // than assuming or defaulting to one or the other, this error is
  29         // returned and the caller must decide how to decode the address.
  30         ErrAddressCollision = errors.New("address collision")
  31
  32         // ErrUnsupportedWitnessVer describes an error where a segwit address being
  33         // decoded has an unsupported witness version.
  34         ErrUnsupportedWitnessVer = errors.New("unsupported witness version")
  35
  36         // ErrUnsupportedWitnessProgLen describes an error where a segwit address
  37         // being decoded has an unsupported witness program length.
  38         ErrUnsupportedWitnessProgLen = errors.New("unsupported witness program length")
  39 )
  40
  41 // Address is an interface type for any type of destination a transaction
  42 // output may spend to.  This includes pay-to-pubkey (P2PK), pay-to-pubkey-hash
  43 // (P2PKH), and pay-to-script-hash (P2SH).  Address is designed to be generic
  44 // enough that other kinds of addresses may be added in the future without
  45 // changing the decoding and encoding API.
  46 type Address interface {
  47         // String returns the string encoding of the transaction output
  48         // destination.
  49         //
  50         // Please note that String differs subtly from EncodeAddress: String
  51         // will return the value as a string without any conversion, while
  52         // EncodeAddress may convert destination types (for example,
  53         // converting pubkeys to P2PKH addresses) before encoding as a
  54         // payment address string.
  55         String() string
  56
  57         // EncodeAddress returns the string encoding of the payment address
  58         // associated with the Address value.  See the comment on String
  59         // for how this method differs from String.
  60         EncodeAddress() string
  61
  62         // ScriptAddress returns the raw bytes of the address to be used
  63         // when inserting the address into a txout's script.
  64         ScriptAddress() []byte
  65
  66         // IsForNet returns whether or not the address is associated with the
  67         // passed bytom network.
  68         IsForNet(*consensus.Params) bool
  69 }
  70
  71 // encodeSegWitAddress creates a bech32 encoded address string representation
  72 // from witness version and witness program.
  73 func encodeSegWitAddress(hrp string, witnessVersion byte, witnessProgram []byte) (string, error) {
  74         // Group the address bytes into 5 bit groups, as this is what is used to
  75         // encode each character in the address string.
  76         converted, err := bech32.ConvertBits(witnessProgram, 8, 5, true)
  77         if err != nil {
  78                 return "", err
  79         }
  80
  81         // Concatenate the witness version and program, and encode the resulting
  82         // bytes using bech32 encoding.
  83         combined := make([]byte, len(converted)+1)
  84         combined[0] = witnessVersion
  85         copy(combined[1:], converted)
  86         bech, err := bech32.Bech32Encode(hrp, combined)
  87         if err != nil {
  88                 return "", err
  89         }
  90
  91         // Check validity by decoding the created address.
  92         version, program, err := decodeSegWitAddress(bech)
  93         if err != nil {
  94                 return "", fmt.Errorf("invalid segwit address: %v", err)
  95         }
  96
  97         if version != witnessVersion || !bytes.Equal(program, witnessProgram) {
  98                 return "", fmt.Errorf("invalid segwit address")
  99         }
 100
 101         return bech, nil
 102 }
 103
 104 // DecodeAddress decodes the string encoding of an address and returns
 105 // the Address if addr is a valid encoding for a known address type.
 106 //
 107 // The bytom network the address is associated with is extracted if possible.
 108 // When the address does not encode the network, such as in the case of a raw
 109 // public key, the address will be associated with the passed defaultNet.
 110 func DecodeAddress(addr string, param *consensus.Params) (Address, error) {
 111         // Bech32 encoded segwit addresses start with a human-readable part
 112         // (hrp) followed by '1'. For Bytom mainnet the hrp is "bm", and for
 113         // testnet it is "tm". If the address string has a prefix that matches
 114         // one of the prefixes for the known networks, we try to decode it as
 115         // a segwit address.
 116         oneIndex := strings.LastIndexByte(addr, '1')
 117         if oneIndex > 1 {
 118                 prefix := addr[:oneIndex+1]
 119                 if consensus.IsBech32SegwitPrefix(prefix, param) {
 120                         witnessVer, witnessProg, err := decodeSegWitAddress(addr)
 121                         if err != nil {
 122                                 return nil, err
 123                         }
 124
 125                         // We currently only support P2WPKH and P2WSH, which is
 126                         // witness version 0.
 127                         if witnessVer != 0 {
 128                                 return nil, ErrUnsupportedWitnessVer
 129                         }
 130
 131                         // The HRP is everything before the found '1'.
 132                         hrp := prefix[:len(prefix)-1]
 133
 134                         switch len(witnessProg) {
 135                         case 20:
 136                                 return newAddressWitnessPubKeyHash(hrp, witnessProg)
 137                         case 32:
 138                                 return newAddressWitnessScriptHash(hrp, witnessProg)
 139                         default:
 140                                 return nil, ErrUnsupportedWitnessProgLen
 141                         }
 142                 }
 143         }
 144         return nil, ErrUnknownAddressType
 145 }
 146
 147 // decodeSegWitAddress parses a bech32 encoded segwit address string and
 148 // returns the witness version and witness program byte representation.
 149 func decodeSegWitAddress(address string) (byte, []byte, error) {
 150         // Decode the bech32 encoded address.
 151         _, data, err := bech32.Bech32Decode(address)
 152         if err != nil {
 153                 return 0, nil, err
 154         }
 155
 156         // The first byte of the decoded address is the witness version, it must
 157         // exist.
 158         if len(data) < 1 {
 159                 return 0, nil, fmt.Errorf("no witness version")
 160         }
 161
 162         // ...and be <= 16.
 163         version := data[0]
 164         if version > 16 {
 165                 return 0, nil, fmt.Errorf("invalid witness version: %v", version)
 166         }
 167
 168         // The remaining characters of the address returned are grouped into
 169         // words of 5 bits. In order to restore the original witness program
 170         // bytes, we'll need to regroup into 8 bit words.
 171         regrouped, err := bech32.ConvertBits(data[1:], 5, 8, false)
 172         if err != nil {
 173                 return 0, nil, err
 174         }
 175
 176         // The regrouped data must be between 2 and 40 bytes.
 177         if len(regrouped) < 2 || len(regrouped) > 40 {
 178                 return 0, nil, fmt.Errorf("invalid data length")
 179         }
 180
 181         // For witness version 0, address MUST be exactly 20 or 32 bytes.
 182         if version == 0 && len(regrouped) != 20 && len(regrouped) != 32 {
 183                 return 0, nil, fmt.Errorf("invalid data length for witness "+
 184                         "version 0: %v", len(regrouped))
 185         }
 186
 187         return version, regrouped, nil
 188 }
 189
 190 // AddressWitnessPubKeyHash is an Address for a pay-to-witness-pubkey-hash
 191 // (P2WPKH) output. See BIP 173 for further details regarding native segregated
 192 // witness address encoding:
 193 // https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
 194 type AddressWitnessPubKeyHash struct {
 195         hrp            string
 196         witnessVersion byte
 197         witnessProgram [20]byte
 198 }
 199
 200 // NewAddressWitnessPubKeyHash returns a new AddressWitnessPubKeyHash.
 201 func NewAddressWitnessPubKeyHash(witnessProg []byte, param *consensus.Params) (*AddressWitnessPubKeyHash, error) {
 202         return newAddressWitnessPubKeyHash(param.Bech32HRPSegwit, witnessProg)
 203 }
 204
 205 // newAddressWitnessPubKeyHash is an internal helper function to create an
 206 // AddressWitnessPubKeyHash with a known human-readable part, rather than
 207 // looking it up through its parameters.
 208 func newAddressWitnessPubKeyHash(hrp string, witnessProg []byte) (*AddressWitnessPubKeyHash, error) {
 209         // Check for valid program length for witness version 0, which is 20
 210         // for P2WPKH.
 211         if len(witnessProg) != 20 {
 212                 return nil, errors.New("witness program must be 20 " +
 213                         "bytes for p2wpkh")
 214         }
 215
 216         addr := &AddressWitnessPubKeyHash{
 217                 hrp:            strings.ToLower(hrp),
 218                 witnessVersion: 0x00,
 219         }
 220
 221         copy(addr.witnessProgram[:], witnessProg)
 222
 223         return addr, nil
 224 }
 225
 226 // EncodeAddress returns the bech32 string encoding of an
 227 // AddressWitnessPubKeyHash.
 228 // Part of the Address interface.
 229 func (a *AddressWitnessPubKeyHash) EncodeAddress() string {
 230         str, err := encodeSegWitAddress(a.hrp, a.witnessVersion,
 231                 a.witnessProgram[:])
 232         if err != nil {
 233                 return ""
 234         }
 235         return str
 236 }
 237
 238 // ScriptAddress returns the witness program for this address.
 239 // Part of the Address interface.
 240 func (a *AddressWitnessPubKeyHash) ScriptAddress() []byte {
 241         return a.witnessProgram[:]
 242 }
 243
 244 // IsForNet returns whether or not the AddressWitnessPubKeyHash is associated
 245 // with the passed bitcoin network.
 246 // Part of the Address interface.
 247 func (a *AddressWitnessPubKeyHash) IsForNet(param *consensus.Params) bool {
 248         return a.hrp == param.Bech32HRPSegwit
 249 }
 250
 251 // String returns a human-readable string for the AddressWitnessPubKeyHash.
 252 // This is equivalent to calling EncodeAddress, but is provided so the type
 253 // can be used as a fmt.Stringer.
 254 // Part of the Address interface.
 255 func (a *AddressWitnessPubKeyHash) String() string {
 256         return a.EncodeAddress()
 257 }
 258
 259 // Hrp returns the human-readable part of the bech32 encoded
 260 // AddressWitnessPubKeyHash.
 261 func (a *AddressWitnessPubKeyHash) Hrp() string {
 262         return a.hrp
 263 }
 264
 265 // WitnessVersion returns the witness version of the AddressWitnessPubKeyHash.
 266 func (a *AddressWitnessPubKeyHash) WitnessVersion() byte {
 267         return a.witnessVersion
 268 }
 269
 270 // WitnessProgram returns the witness program of the AddressWitnessPubKeyHash.
 271 func (a *AddressWitnessPubKeyHash) WitnessProgram() []byte {
 272         return a.witnessProgram[:]
 273 }
 274
 275 // Hash160 returns the witness program of the AddressWitnessPubKeyHash as a
 276 // byte array.
 277 func (a *AddressWitnessPubKeyHash) Hash160() *[20]byte {
 278         return &a.witnessProgram
 279 }
 280
 281 // AddressWitnessScriptHash is an Address for a pay-to-witness-script-hash
 282 // (P2WSH) output. See BIP 173 for further details regarding native segregated
 283 // witness address encoding:
 284 // https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
 285 type AddressWitnessScriptHash struct {
 286         hrp            string
 287         witnessVersion byte
 288         witnessProgram [32]byte
 289 }
 290
 291 // NewAddressWitnessScriptHash returns a new AddressWitnessPubKeyHash.
 292 func NewAddressWitnessScriptHash(witnessProg []byte, param *consensus.Params) (*AddressWitnessScriptHash, error) {
 293         return newAddressWitnessScriptHash(param.Bech32HRPSegwit, witnessProg)
 294 }
 295
 296 // newAddressWitnessScriptHash is an internal helper function to create an
 297 // AddressWitnessScriptHash with a known human-readable part, rather than
 298 // looking it up through its parameters.
 299 func newAddressWitnessScriptHash(hrp string, witnessProg []byte) (*AddressWitnessScriptHash, error) {
 300         // Check for valid program length for witness version 0, which is 32
 301         // for P2WSH.
 302         if len(witnessProg) != 32 {
 303                 return nil, errors.New("witness program must be 32 " +
 304                         "bytes for p2wsh")
 305         }
 306
 307         addr := &AddressWitnessScriptHash{
 308                 hrp:            strings.ToLower(hrp),
 309                 witnessVersion: 0x00,
 310         }
 311
 312         copy(addr.witnessProgram[:], witnessProg)
 313
 314         return addr, nil
 315 }
 316
 317 // EncodeAddress returns the bech32 string encoding of an
 318 // AddressWitnessScriptHash.
 319 // Part of the Address interface.
 320 func (a *AddressWitnessScriptHash) EncodeAddress() string {
 321         str, err := encodeSegWitAddress(a.hrp, a.witnessVersion,
 322                 a.witnessProgram[:])
 323         if err != nil {
 324                 return ""
 325         }
 326         return str
 327 }
 328
 329 // ScriptAddress returns the witness program for this address.
 330 // Part of the Address interface.
 331 func (a *AddressWitnessScriptHash) ScriptAddress() []byte {
 332         return a.witnessProgram[:]
 333 }
 334
 335 // IsForNet returns whether or not the AddressWitnessScriptHash is associated
 336 // with the passed bytom network.
 337 // Part of the Address interface.
 338 func (a *AddressWitnessScriptHash) IsForNet(param *consensus.Params) bool {
 339         return a.hrp == param.Bech32HRPSegwit
 340 }
 341
 342 // String returns a human-readable string for the AddressWitnessScriptHash.
 343 // This is equivalent to calling EncodeAddress, but is provided so the type
 344 // can be used as a fmt.Stringer.
 345 // Part of the Address interface.
 346 func (a *AddressWitnessScriptHash) String() string {
 347         return a.EncodeAddress()
 348 }
 349
 350 // Hrp returns the human-readable part of the bech32 encoded
 351 // AddressWitnessScriptHash.
 352 func (a *AddressWitnessScriptHash) Hrp() string {
 353         return a.hrp
 354 }
 355
 356 // WitnessVersion returns the witness version of the AddressWitnessScriptHash.
 357 func (a *AddressWitnessScriptHash) WitnessVersion() byte {
 358         return a.witnessVersion
 359 }
 360
 361 // WitnessProgram returns the witness program of the AddressWitnessScriptHash.
 362 func (a *AddressWitnessScriptHash) WitnessProgram() []byte {
 363         return a.witnessProgram[:]
 364 }
 365
 366 // Hash160 returns the witness program of the AddressWitnessPubKeyHash as a
 367 // byte array.
 368 func (a *AddressWitnessScriptHash) Sha256() *[32]byte {
 369         return &a.witnessProgram
 370 }