func (a *scriptAddress) Address() hcashutil.Address {
	return a.address
}
Address returns the hcashutil.Address which represents the managed address.
This will be a pay-to-script-hash address.

This is part of the ManagedAddress interface implementation.
package udb
import (
	"encoding/hex"
	"github.com/HcashOrg/hcashd/chaincfg/chainec"
	"github.com/HcashOrg/hcashutil"
	"github.com/HcashOrg/hcashutil/hdkeychain"
	"github.com/HcashOrg/hcashwallet/apperrors"
)
type ManagedAddress interface {
	Account() uint32
	Address() hcashutil.Address
	AddrHash() []byte
	Imported() bool
	Internal() bool
	Multisig() bool
	Compressed() bool
}
type ManagedPubKeyAddress interface {
	ManagedAddress
	PubKey() chainec.PublicKey
	ExportPubKey() string
}
type ManagedScriptAddress interface {
	ManagedAddress
	isScriptAddress()
}
type managedAddress struct {
	manager    *Manager
	account    uint32
	address    *hcashutil.AddressPubKeyHash
	imported   bool
	internal   bool
	multisig   bool
	compressed bool
	pubKey     chainec.PublicKey
}
var _ ManagedPubKeyAddress = (*managedAddress)(nil)
func (a *managedAddress) Account() uint32 {
	return a.account
}
func (a *managedAddress) Address() hcashutil.Address {
	return a.address
}
func (a *managedAddress) AddrHash() []byte {
	return a.address.Hash160()[:]
}
func (a *managedAddress) Imported() bool {
	return a.imported
}
func (a *managedAddress) Internal() bool {
	return a.internal
}
func (a *managedAddress) Multisig() bool {
	return a.multisig
}
func (a *managedAddress) Compressed() bool {
	return a.compressed
}
func (a *managedAddress) PubKey() chainec.PublicKey {
	return a.pubKey
}
func (a *managedAddress) pubKeyBytes() []byte {
	if a.compressed {
		return a.pubKey.SerializeCompressed()
	}
	return a.pubKey.SerializeUncompressed()
}
func (a *managedAddress) ExportPubKey() string {
	return hex.EncodeToString(a.pubKeyBytes())
}
func newManagedAddressWithoutPrivKey(m *Manager, account uint32, pubKey chainec.PublicKey, compressed bool) (*managedAddress, error) {
	var pubKeyHash []byte
	if compressed && pubKey.GetType() == chainec.ECTypeSecp256k1 {
	   pubKeyHash = hcashutil.Hash160(pubKey.SerializeCompressed())
	} else if pubKey.GetType() == chainec.ECTypeSecp256k1 {
	   pubKeyHash = hcashutil.Hash160(pubKey.SerializeUncompressed())
	} else {
	   pubKeyHash = hcashutil.Hash160(pubKey.Serialize())
	}
	address, err := hcashutil.NewAddressPubKeyHash(pubKeyHash, m.chainParams,
	   pubKey.GetType())
	if err != nil {
	   return nil, err
	}
	return &managedAddress{
	   manager:    m,
	   address:    address,
	   account:    account,
	   imported:   false,
	   internal:   false,
	   multisig:   false,
	   compressed: compressed,
	   pubKey:     pubKey,
	}, nil
 }
func newManagedAddressFromExtKey(m *Manager, account uint32, key *hdkeychain.ExtendedKey) (*managedAddress, error) {
	pubKey, err := key.ECPubKey()
	if err != nil {
		const str = "failed to create public key"
		return nil, apperrors.E{ErrorCode: apperrors.ErrKeyChain, Description: str, Err: err}
	}
	return newManagedAddressWithoutPrivKey(m, account, pubKey, true)
}
type scriptAddress struct {
	manager *Manager
	account uint32
	address *hcashutil.AddressScriptHash
}
var _ ManagedScriptAddress = (*scriptAddress)(nil)
func (a *scriptAddress) Account() uint32 {
	return a.account
}