Add CashTokens core logic

Author: OPReturnCode

blockchain/compress.go

@@ -207,7 +207,7 @@ func isScriptHash(script []byte) (bool, []byte) {
 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 {
+		script[34] == txscript.OP_EQUAL {
 
 		return true, script[2:34]
 	}

blockchain/scriptval.go

@@ -77,11 +77,12 @@ out:
 			sigScript := txIn.SignatureScript
 			pkScript := utxo.PkScript()
 			inputAmount := utxo.Amount()
+			tokenData := utxo.tokenData
 
 			utxoEntryCache := txscript.NewUtxoCache()
 			for i, in := range txVI.tx.MsgTx().TxIn {
 				if i == txVI.txInIndex {
-					utxoEntryCache.AddEntry(i, *wire.NewTxOut(utxo.amount, utxo.pkScript))
+					utxoEntryCache.AddEntry(i, *wire.NewTxOut(utxo.amount, utxo.pkScript, tokenData))
 					continue
 				}
 				u := v.utxoView.LookupEntry(in.PreviousOutPoint)
@@ -95,7 +96,7 @@ out:
 					v.sendResult(err)
 					break out
 				}
-				utxoEntryCache.AddEntry(i, *wire.NewTxOut(u.amount, u.pkScript))
+				utxoEntryCache.AddEntry(i, *wire.NewTxOut(u.amount, u.pkScript, u.tokenData))
 			}
 
 			vm, err := txscript.NewEngine(pkScript, txVI.tx.MsgTx(),
@@ -255,6 +256,19 @@ func ValidateTransactionScripts(tx *bchutil.Tx, utxoView *UtxoViewpoint,
 		cachedHashes = txscript.NewTxSigHashes(tx.MsgTx())
 	}
 
+	if cachedHashes != nil {
+		utxoCache := txscript.NewUtxoCache()
+		for i, in := range tx.MsgTx().TxIn {
+			u := utxoView.LookupEntry(in.PreviousOutPoint)
+			if u == nil {
+				break // Raise error?
+			}
+			utxoCache.AddEntry(i, *wire.NewTxOut(u.amount, u.pkScript, u.tokenData))
+		}
+
+		cachedHashes.AddTxSigHashUtxoFromUtxoCache(tx.MsgTx(), utxoCache)
+	}
+
 	// Collect all of the transaction inputs and required information for
 	// validation.
 	sigChecks := uint32(0)
@@ -319,6 +333,19 @@ func checkBlockScripts(block *bchutil.Block, utxoView *UtxoViewpoint,
 			cachedHashes = txscript.NewTxSigHashes(tx.MsgTx())
 		}
 
+		if cachedHashes != nil {
+			utxoCache := txscript.NewUtxoCache()
+			for i, in := range tx.MsgTx().TxIn {
+				u := utxoView.LookupEntry(in.PreviousOutPoint)
+				if u == nil {
+					break // Raise error?
+				}
+				utxoCache.AddEntry(i, *wire.NewTxOut(u.amount, u.pkScript, u.tokenData))
+			}
+
+			cachedHashes.AddTxSigHashUtxoFromUtxoCache(tx.MsgTx(), utxoCache)
+		}
+
 		for txInIdx, txIn := range tx.MsgTx().TxIn {
 			// Skip coinbases.
 			if txIn.PreviousOutPoint.Index == math.MaxUint32 {

blockchain/utxocache.go

@@ -73,6 +73,8 @@ type UtxoEntry struct {
 	pkScript    []byte // The public key script for the output.
 	blockHeight int32  // Height of block containing tx.
 
+	tokenData wire.TokenData // TODO this can use better memorry optimization. Check the paddings.
+
 	// packedFlags contains additional info about output such as whether it
 	// is a coinbase, whether it is spent, and whether it has been modified
 	// since it was loaded.  This approach is used in order to reduce memory
@@ -90,6 +92,7 @@ func NewUtxoEntry(txOut *wire.TxOut, blockHeight int32, isCoinbase bool) *UtxoEn
 	return &UtxoEntry{
 		amount:      txOut.Value,
 		pkScript:    txOut.PkScript,
+		tokenData:   txOut.TokenData,
 		blockHeight: blockHeight,
 		packedFlags: cbFlag,
 	}
@@ -145,6 +148,8 @@ func (entry *UtxoEntry) memoryUsage() uint64 {
 	//   unsafe.Sizeof(UtxoEntry{})
 	baseEntrySize := uint64(40)
 
+	baseEntrySize += uint64(88) // Size of TokenData
+
 	return baseEntrySize + uint64(len(entry.pkScript))
 }
 
@@ -169,6 +174,7 @@ func (entry *UtxoEntry) Clone() *UtxoEntry {
 	return &UtxoEntry{
 		amount:      entry.amount,
 		pkScript:    entry.pkScript,
+		tokenData:   entry.tokenData,
 		blockHeight: entry.blockHeight,
 		packedFlags: entry.packedFlags,
 	}

blockchain/utxoviewpoint.go

@@ -189,6 +189,7 @@ func addTxOuts(view utxoView, tx *bchutil.Tx, blockHeight int32, overwrite bool)
 		entry := &UtxoEntry{
 			amount:      txOut.Value,
 			pkScript:    pkScript,
+			tokenData:   txOut.TokenData,
 			blockHeight: blockHeight,
 			packedFlags: tfModified,
 		}
@@ -339,8 +340,10 @@ func disconnectTransactions(view utxoView, block *bchutil.Block, stxos []SpentTx
 			copy(pkScript, stxo.PkScript)
 
 			entry := &UtxoEntry{
-				amount:      stxo.Amount,
-				pkScript:    pkScript,
+				amount:   stxo.Amount,
+				pkScript: pkScript,
+				// tokenData: stxo.tokenData,
+				// TODO TODO SpentTxOut
 				blockHeight: stxo.Height,
 				packedFlags: tfModified,
 			}
@@ -391,6 +394,7 @@ func disconnectTransactions(view utxoView, block *bchutil.Block, stxos []SpentTx
 			entry := &UtxoEntry{
 				amount:      txOut.Value,
 				pkScript:    pkScript,
+				tokenData:   txOut.TokenData,
 				blockHeight: block.Height(),
 				packedFlags: packedFlags,
 			}

blockchain/validate.go

@@ -260,14 +260,17 @@ func CheckTransactionSanity(tx *bchutil.Tx, magneticAnomalyActive bool, upgrade9
 		return ruleError(ErrTxTooBig, str)
 	}
 
-	if magneticAnomalyActive && serializedTxSize < MagneticAnomalyMinTransactionSize {
+	if magneticAnomalyActive || upgrade9Active {
 		minTxSize := MagneticAnomalyMinTransactionSize
 		if upgrade9Active {
 			minTxSize = MinTransactionSize
 		}
-		str := fmt.Sprintf("serialized transaction is too small - got "+
-			"%d, min %d", serializedTxSize, minTxSize)
-		return ruleError(ErrTxTooSmall, str)
+		if serializedTxSize < minTxSize {
+
+			str := fmt.Sprintf("serialized transaction is too small - got "+
+				"%d, min %d", serializedTxSize, minTxSize)
+			return ruleError(ErrTxTooSmall, str)
+		}
 	}
 
 	// Ensure the transaction amounts are in range.  Each transaction
@@ -1014,6 +1017,8 @@ func (b *BlockChain) checkConnectBlock(node *blockNode, block *bchutil.Block, vi
 	// If CosmicInflation is active we enforce 64BitIntegers and NativeIntrospection
 	cosmicInflationActive := node.parent.CalcPastMedianTime().Unix() >= int64(b.chainParams.CosmicInflationActivationTime)
 
+	upgrade9Active := node.height > b.chainParams.Upgrade9ForkHeight
+
 	// BIP0030 added a rule to prevent blocks which contain duplicate
 	// transactions that 'overwrite' older transactions which are not fully
 	// spent.  See the documentation for checkBIP0030 for more details.
@@ -1113,6 +1118,10 @@ func (b *BlockChain) checkConnectBlock(node *blockNode, block *bchutil.Block, vi
 		scriptFlags |= txscript.ScriptVerify64BitIntegers | txscript.ScriptVerifyNativeIntrospection
 	}
 
+	if upgrade9Active {
+		scriptFlags |= txscript.ScriptAllowSighashUTXO
+	}
+
 	// Perform several checks on the inputs for each transaction.  Also
 	// accumulate the total fees.  This could technically be combined with
 	// the loop above instead of running another loop over the transactions,

chaincfg/params.go

@@ -651,6 +651,7 @@ var ChipNetParams = Params{
 	GravitonForkHeight:          4999,
 	PhononForkHeight:            0,
 	AxionActivationHeight:       16844,
+	Upgrade9ForkHeight:          121956,
 
 	CosmicInflationActivationTime: 1637694000,
 

netsync/manager.go

@@ -801,6 +801,7 @@ func (sm *SyncManager) handleBlockMsg(bmsg *blockMsg) {
 
 	// If we didn't ask for this block then the peer is misbehaving.
 	blockHash := bmsg.block.Hash()
+
 	if _, exists = state.requestedBlocks[*blockHash]; !exists && !peer.AllowDirectBlockRelay() {
 		// The regression test intentionally sends some blocks twice
 		// to test duplicate block insertion fails.  Don't disconnect

rpcserver.go

@@ -609,7 +609,7 @@ func handleCreateRawTransaction(s *rpcServer, cmd interface{}, closeNotifier <-c
 			return nil, internalRPCError(err.Error(), context)
 		}
 
-		txOut := wire.NewTxOut(int64(satoshi), pkScript)
+		txOut := wire.NewTxOut(int64(satoshi), pkScript, wire.TokenData{}) // TODO TODO FIX THIS! This shouldn't be an empty token data
 		mtx.AddTxOut(txOut)
 	}
 

txscript/engine.go

@@ -127,6 +127,9 @@ const (
 	// ScriptVerifyNativeIntrospection enables the suite of native introspection
 	// opcodes.
 	ScriptVerifyNativeIntrospection
+
+	// ScriptAllowSighashUTXO enables the use of SighashUTXO signing serialization type
+	ScriptAllowSighashUTXO
 )
 
 // HasFlag returns whether the ScriptFlags has the passed flag set.
@@ -375,6 +378,7 @@ func (vm *Engine) Step() (done bool, err error) {
 	if err != nil {
 		return true, err
 	}
+
 	opcode := &vm.scripts[vm.scriptIdx][vm.scriptOff]
 	vm.scriptOff++
 
@@ -502,6 +506,20 @@ func (vm *Engine) checkHashTypeEncoding(hashType SigHashType) error {
 		}
 	}
 
+	if vm.hasFlag(ScriptAllowSighashUTXO) {
+		sigHashType &= ^SigHashUTXO
+	} else {
+		if hashType&SigHashUTXO != 0 {
+			str := fmt.Sprintf("invalid hash type containing SIGHASH_UTXOS 0x%x", hashType)
+			return scriptError(ErrInvalidSigHashType, str)
+		}
+	}
+
+	if hashType&SigHashUTXO != 0 && hashType&SigHashAnyOneCanPay != 0 {
+		str := fmt.Sprintf("invalid hash type containing both SIGHASH_UTXOS and SIGHASH_ANYONECANPAY 0x%x", hashType)
+		return scriptError(ErrInvalidSigHashType, str)
+	}
+
 	if sigHashType < SigHashAll || sigHashType > SigHashSingle {
 		str := fmt.Sprintf("invalid hash type 0x%x", hashType)
 		return scriptError(ErrInvalidSigHashType, str)
@@ -954,6 +972,16 @@ func NewEngine(scriptPubKey []byte, tx *wire.MsgTx, txIdx int, flags ScriptFlags
 		}
 		vm.bip16 = true
 	}
+
+	if vm.hasFlag(ScriptBip16) && isScriptHash32(vm.scripts[1]) {
+		// Only accept input scripts that push data for P2SH.
+		if !isPushOnly(vm.scripts[0]) {
+			return nil, scriptError(ErrNotPushOnly,
+				"pay to script hash is not push only")
+		}
+		vm.bip16 = true
+	}
+
 	if vm.hasFlag(ScriptVerifyMinimalData) {
 		vm.dstack.verifyMinimalData = true
 		vm.astack.verifyMinimalData = true

txscript/hashcache.go

@@ -17,9 +17,11 @@ import (
 // transaction when validating all inputs. As a result, validation complexity
 // for SigHashAll can be reduced by a polynomial factor.
 type TxSigHashes struct {
-	HashPrevOuts chainhash.Hash
-	HashSequence chainhash.Hash
-	HashOutputs  chainhash.Hash
+	HashPrevOuts  chainhash.Hash
+	HashSequence  chainhash.Hash
+	HashOutputs   chainhash.Hash
+	HashUTXOS     chainhash.Hash
+	tokenDataList [][]byte
 }
 
 // NewTxSigHashes computes, and returns the cached sighashes of the given
@@ -29,9 +31,17 @@ func NewTxSigHashes(tx *wire.MsgTx) *TxSigHashes {
 		HashPrevOuts: calcHashPrevOuts(tx),
 		HashSequence: calcHashSequence(tx),
 		HashOutputs:  calcHashOutputs(tx),
+		// HashUTXOS:    calcHashUtxos(tx),
+		HashUTXOS: chainhash.Hash{},
 	}
 }
 
+func (txSighashes *TxSigHashes) AddTxSigHashUtxoFromUtxoCache(tx *wire.MsgTx, utxoCache *UtxoCache) {
+	hash := calcHashUtxos(tx, utxoCache)
+	txSighashes.HashUTXOS = hash
+	txSighashes.tokenDataList = calUtxoTokenData(tx, utxoCache)
+}
+
 // HashCache houses a set of partial sighashes keyed by txid. The set of partial
 // sighashes are those introduced within BIP0143 by the new more efficient
 // sighash digest calculation algorithm. Using this threadsafe shared cache,