From fc093b2e9f83e76191e1e2bafde663c36a60dd5f Mon Sep 17 00:00:00 2001
From: StephenButtolph <stephen@avalabs.org>
Date: Tue, 31 Mar 2020 15:14:31 -0400
Subject: [PATCH] Fixed mint signing

---
 vms/avm/service.go | 100 ++++++++++++++++++++++++---------------------
 1 file changed, 53 insertions(+), 47 deletions(-)

diff --git a/vms/avm/service.go b/vms/avm/service.go
index 775808c..49c96c4 100644
--- a/vms/avm/service.go
+++ b/vms/avm/service.go
@@ -869,71 +869,77 @@ func (service *Service) SignMintTx(r *http.Request, args *SignMintTxArgs, reply
 		return fmt.Errorf("problem creating transaction: %w", err)
 	}
 
-	inputUTXOs := tx.InputUTXOs()
-	if len(inputUTXOs) != 1 {
+	opTx, ok := tx.UnsignedTx.(*OperationTx)
+	if !ok {
+		return errors.New("transaction must be a mint transaction")
+	}
+	if len(opTx.Ins) != 0 {
 		return errCanOnlySignSingleInputTxs
 	}
-	inputUTXO := inputUTXOs[0]
+	if len(opTx.Ops) != 1 {
+		return errCanOnlySignSingleInputTxs
+	}
+	op := opTx.Ops[0]
 
-	inputTxID, utxoIndex := inputUTXO.InputSource()
-	utx := UniqueTx{
-		vm:   service.vm,
-		txID: inputTxID,
+	if len(op.UTXOIDs) != 1 {
+		return errCanOnlySignSingleInputTxs
 	}
-	if !utx.Status().Fetched() {
-		return errUnknownUTXO
-	}
-	utxos := utx.UTXOs()
-	if uint32(len(utxos)) <= utxoIndex {
-		return errInvalidUTXO
+	inputUTXO := op.UTXOIDs[0]
+
+	utxo, err := service.vm.getUTXO(inputUTXO)
+	if err != nil {
+		return err
 	}
 
-	utxo := utxos[int(utxoIndex)]
-
-	i := -1
-	size := 0
-	switch out := utxo.Out.(type) {
-	case *secp256k1fx.MintOutput:
-		size = int(out.Threshold)
-		for j, addr := range out.Addrs {
-			if bytes.Equal(addr.Bytes(), minter) {
-				i = j
-				break
-			}
-		}
-	default:
+	out, ok := utxo.Out.(*secp256k1fx.MintOutput)
+	if !ok {
 		return errUnknownOutputType
 	}
-	if i == -1 {
-		return errUnneededAddress
 
+	secpOp, ok := op.Op.(*secp256k1fx.MintOperation)
+	if !ok {
+		return errors.New("unknown mint operation")
+	}
+
+	sigIndex := -1
+	size := int(out.Threshold)
+	for i, addrIndex := range secpOp.MintInput.SigIndices {
+		if addrIndex >= uint32(len(out.Addrs)) {
+			return errors.New("input output mismatch")
+		}
+		if bytes.Equal(out.Addrs[int(addrIndex)].Bytes(), minter) {
+			sigIndex = i
+			break
+		}
+	}
+	if sigIndex == -1 {
+		return errUnneededAddress
 	}
 
 	if len(tx.Creds) == 0 {
 		tx.Creds = append(tx.Creds, &secp256k1fx.Credential{})
 	}
 
-	cred := tx.Creds[0]
-	switch cred := cred.(type) {
-	case *secp256k1fx.Credential:
-		if len(cred.Sigs) != size {
-			cred.Sigs = make([][crypto.SECP256K1RSigLen]byte, size)
-		}
-
-		unsignedBytes, err := service.vm.codec.Marshal(&tx.UnsignedTx)
-		if err != nil {
-			return fmt.Errorf("problem creating transaction: %w", err)
-		}
-
-		sig, err := sk.Sign(unsignedBytes)
-		if err != nil {
-			return fmt.Errorf("problem signing transaction: %w", err)
-		}
-		copy(cred.Sigs[i][:], sig)
-	default:
+	cred, ok := tx.Creds[0].(*secp256k1fx.Credential)
+	if !ok {
 		return errUnknownCredentialType
 	}
 
+	if len(cred.Sigs) != size {
+		cred.Sigs = make([][crypto.SECP256K1RSigLen]byte, size)
+	}
+
+	unsignedBytes, err := service.vm.codec.Marshal(&tx.UnsignedTx)
+	if err != nil {
+		return fmt.Errorf("problem creating transaction: %w", err)
+	}
+
+	sig, err := sk.Sign(unsignedBytes)
+	if err != nil {
+		return fmt.Errorf("problem signing transaction: %w", err)
+	}
+	copy(cred.Sigs[sigIndex][:], sig)
+
 	txBytes, err := service.vm.codec.Marshal(&tx)
 	if err != nil {
 		return fmt.Errorf("problem creating transaction: %w", err)