Add P2SH32

Author: OPReturnCode

bchrpc/server.go

@@ -1017,7 +1017,7 @@ func (s *GrpcServer) GetAddressUnspentOutputs(ctx context.Context, req *pb.GetAd
 			matchAddr := ""
 
 			switch typedAddr := addrs[0].(type) {
-			case *bchutil.AddressPubKeyHash, *bchutil.AddressScriptHash:
+			case *bchutil.AddressPubKeyHash, *bchutil.AddressScriptHash, *bchutil.AddressScriptHash32:
 				matchAddr = addrs[0].EncodeAddress()
 
 			case *bchutil.AddressPubKey:

blockchain/compress.go

@@ -201,6 +201,20 @@ func isScriptHash(script []byte) (bool, []byte) {
 	return false, nil
 }
 
+// isScriptHash32 returns whether or not the passed public key script is a
+// standard pay-to-script-hash script along with the script hash it is paying to
+// if it is.
+func isScriptHash32(script []byte) (bool, []byte) {
+	if len(script) == 35 && script[0] == txscript.OP_HASH256 &&
+		script[1] == txscript.OP_DATA_32 &&
+		script[22] == txscript.OP_EQUAL {
+
+		return true, script[2:34]
+	}
+
+	return false, nil
+}
+
 // isPubKey returns whether or not the passed public key script is a standard
 // pay-to-pubkey script that pays to a valid compressed or uncompressed public
 // key along with the serialized pubkey it is paying to if it is.

blockchain/fullblocktests/generate.go

@@ -230,6 +230,19 @@ func payToScriptHashScript(redeemScript []byte) []byte {
 	return script
 }
 
+// payToScriptHashScript32 returns a standard pay-to-script-hash for the provided
+// redeem script.
+func payToScriptHashScript32(redeemScript []byte) []byte {
+	redeemScriptHash := bchutil.Hash256(redeemScript)
+	script, err := txscript.NewScriptBuilder().
+		AddOp(txscript.OP_HASH256).AddData(redeemScriptHash).
+		AddOp(txscript.OP_EQUAL).Script()
+	if err != nil {
+		panic(err)
+	}
+	return script
+}
+
 // pushDataScript returns a script with the provided items individually pushed
 // to the stack.
 func pushDataScript(items ...[]byte) []byte {

blockchain/indexers/addrindex.go

@@ -30,7 +30,14 @@ const (
 
 	// addrKeySize is the number of bytes an address key consumes in the
 	// index.  It consists of 1 byte address type + 20 bytes hash160.
-	addrKeySize = 1 + 20
+	//addrKeySize = 1 + 20
+
+	// addrKeySize is the number of bytes an address key consumes in the
+	// index.  It consists of 1 byte address type + 32 bytes hash256.
+	// TODO: Since we updated the size, please note that we need to either:
+	// a) detect old indexes and force them to be rebuilt
+	// b) write a migration of the existing index
+	addrKeySize = 1 + 32
 
 	// levelKeySize is the number of bytes a level key in the address index
 	// consumes.  It consists of the address key + 1 byte for the level.
@@ -529,6 +536,11 @@ func addrToKey(addr bchutil.Address) ([addrKeySize]byte, error) {
 		copy(result[1:], addr.Hash160()[:])
 		return result, nil
 
+	case *bchutil.AddressScriptHash32:
+		var result [addrKeySize]byte
+		result[0] = addrKeyTypeScriptHash
+		copy(result[1:], addr.Hash256()[:])
+		return result, nil
 	case *bchutil.AddressPubKey:
 		var result [addrKeySize]byte
 		result[0] = addrKeyTypePubKeyHash

rpcserver.go

@@ -580,6 +580,7 @@ func handleCreateRawTransaction(s *rpcServer, cmd interface{}, closeNotifier <-c
 		switch addr.(type) {
 		case *bchutil.AddressPubKeyHash:
 		case *bchutil.AddressScriptHash:
+		case *bchutil.AddressScriptHash32:
 		default:
 			return nil, &btcjson.RPCError{
 				Code:    btcjson.ErrRPCInvalidAddressOrKey,

txscript/pkscript.go

@@ -139,7 +139,7 @@ func (s PkScript) String() string {
 // ComputePkScript computes the pkScript of an transaction output by looking at
 // the transaction input's signature script.
 //
-// NOTE: Only P2PKH, and P2SH redeem scripts are supported.
+// NOTE: Only P2PKH, P2SH and P2SH32 redeem scripts are supported.
 func ComputePkScript(sigScript []byte) (PkScript, error) {
 	var pkScript PkScript
 

txscript/script.go

@@ -64,6 +64,15 @@ func isScriptHash(pops []parsedOpcode) bool {
 		pops[2].opcode.value == OP_EQUAL
 }
 
+// isScriptHash32 returns true if the script passed is a pay-to-script-hash-32
+// transaction, false otherwise.
+func isScriptHash32(pops []parsedOpcode) bool {
+	return len(pops) == 3 &&
+		pops[0].opcode.value == OP_HASH256 &&
+		pops[1].opcode.value == OP_DATA_32 &&
+		pops[2].opcode.value == OP_EQUAL
+}
+
 // IsPayToScriptHash returns true if the script is in the standard
 // pay-to-script-hash (P2SH) format, false otherwise.
 func IsPayToScriptHash(script []byte) bool {
@@ -74,6 +83,16 @@ func IsPayToScriptHash(script []byte) bool {
 	return isScriptHash(pops)
 }
 
+// IsPayToScriptHash32 returns true if the script is in the standard
+// pay-to-script-hash-32 (P2SH) format, false otherwise.
+func IsPayToScriptHash32(script []byte) bool {
+	pops, err := parseScript(script)
+	if err != nil {
+		return false
+	}
+	return isScriptHash32(pops)
+}
+
 // isPushOnly returns true if the script only pushes data, false otherwise.
 func isPushOnly(pops []parsedOpcode) bool {
 	// NOTE: This function does NOT verify opcodes directly since it is

txscript/standard.go

@@ -55,12 +55,13 @@ type ScriptClass byte
 
 // Classes of script payment known about in the blockchain.
 const (
-	NonStandardTy ScriptClass = iota // None of the recognized forms.
-	PubKeyTy                         // Pay pubkey.
-	PubKeyHashTy                     // Pay pubkey hash.
-	ScriptHashTy                     // Pay to script hash.
-	MultiSigTy                       // Multi signature.
-	NullDataTy                       // Empty data-only (provably prunable).
+	NonStandardTy  ScriptClass = iota // None of the recognized forms.
+	PubKeyTy                          // Pay pubkey.
+	PubKeyHashTy                      // Pay pubkey hash.
+	ScriptHashTy                      // Pay to script hash.
+	ScriptHash32Ty                    // Pay to script hash 32
+	MultiSigTy                        // Multi signature.
+	NullDataTy                        // Empty data-only (provably prunable).
 )
 
 // scriptClassToName houses the human-readable strings which describe each
@@ -186,6 +187,8 @@ func typeOfScript(pops []parsedOpcode) ScriptClass {
 		return PubKeyHashTy
 	} else if isScriptHash(pops) {
 		return ScriptHashTy
+	} else if isScriptHash32(pops) {
+		return ScriptHash32Ty
 	} else if isMultiSig(pops) {
 		return MultiSigTy
 	} else if isNullData(pops) {
@@ -355,6 +358,13 @@ func payToScriptHashScript(scriptHash []byte) ([]byte, error) {
 		AddOp(OP_EQUAL).Script()
 }
 
+// payToScriptHashScript creates a new script to pay a transaction output to a
+// script hash. It is expected that the input is a valid hash.
+func payToScriptHashScript32(scriptHash []byte) ([]byte, error) {
+	return NewScriptBuilder().AddOp(OP_HASH256).AddData(scriptHash).
+		AddOp(OP_EQUAL).Script()
+}
+
 // payToPubkeyScript creates a new script to pay a transaction output to a
 // public key. It is expected that the input is a valid pubkey.
 func payToPubKeyScript(serializedPubKey []byte) ([]byte, error) {
@@ -392,6 +402,12 @@ func PayToAddrScript(addr bchutil.Address) ([]byte, error) {
 				nilAddrErrStr)
 		}
 		return payToScriptHashScript(addr.ScriptAddress())
+	case *bchutil.AddressScriptHash32:
+		if addr == nil {
+			return nil, scriptError(ErrUnsupportedAddress,
+				nilAddrErrStr)
+		}
+		return payToScriptHashScript32(addr.ScriptAddress())
 	case *bchutil.AddressPubKey:
 		if addr == nil {
 			return nil, scriptError(ErrUnsupportedAddress,
@@ -512,6 +528,18 @@ func ExtractPkScriptAddrs(pkScript []byte, chainParams *chaincfg.Params) (Script
 			addrs = append(addrs, addr)
 		}
 
+	case ScriptHash32Ty:
+		// A pay-to-script-hash32 script is of the form:
+		//  OP_HASH256 <scripthash> OP_EQUAL
+		// Therefore the script hash is the 2nd item on the stack.
+		// Skip the script hash if it's invalid for some reason.
+		requiredSigs = 1
+		addr, err := bchutil.NewAddressScriptHash32FromHash(pops[1].data,
+			chainParams)
+		if err == nil {
+			addrs = append(addrs, addr)
+		}
+
 	case MultiSigTy:
 		// A multi-signature script is of the form:
 		//  <numsigs> <pubkey> <pubkey> <pubkey>... <numpubkeys> OP_CHECKMULTISIG