tapdb+tapfreighter: set and retrieve fields from new columns

Set and retrieve the `proof_delivery_complete` and
`position` columns from the `asset_transfer_outputs` table.

Author: ffranr

tapdb/assets_store.go

@@ -2401,20 +2401,50 @@ func insertAssetTransferOutput(ctx context.Context, q ActiveAssetsStore,
 		return fmt.Errorf("unable to insert script key: %w", err)
 	}
 
+	// Now we will mark the output proof as undelivered if it is intended
+	// for a counterpart.
+	//
+	// If the transfer output proof is not intended for a counterpart the
+	// `proofDeliveryComplete` field will be left as NULL. Otherwise, we set
+	// it to false to indicate that the proof has not been delivered yet.
+	shouldDeliverProof, err := output.ShouldDeliverProof()
+	if err != nil {
+		return fmt.Errorf("unable to determine if proof should be "+
+			"delivery for given transfer output: %w", err)
+	}
+
+	var proofDeliveryComplete sql.NullBool
+	if shouldDeliverProof {
+		proofDeliveryComplete = sql.NullBool{
+			Bool:  false,
+			Valid: true,
+		}
+	}
+
+	// Check if position value can be stored in a 32-bit integer. Type cast
+	// if possible, otherwise return an error.
+	if output.Position > math.MaxInt32 {
+		return fmt.Errorf("position value %d is too large for db "+
+			"storage", output.Position)
+	}
+	position := int32(output.Position)
+
 	dbOutput := NewTransferOutput{
-		TransferID:          transferID,
-		AnchorUtxo:          newUtxoID,
-		ScriptKey:           scriptKeyID,
-		ScriptKeyLocal:      output.ScriptKeyLocal,
-		Amount:              int64(output.Amount),
-		LockTime:            sqlInt32(output.LockTime),
-		RelativeLockTime:    sqlInt32(output.RelativeLockTime),
-		AssetVersion:        int32(output.AssetVersion),
-		SerializedWitnesses: witnessBuf.Bytes(),
-		ProofSuffix:         output.ProofSuffix,
-		NumPassiveAssets:    int32(output.Anchor.NumPassiveAssets),
-		OutputType:          int16(output.Type),
-		ProofCourierAddr:    output.ProofCourierAddr,
+		TransferID:            transferID,
+		AnchorUtxo:            newUtxoID,
+		ScriptKey:             scriptKeyID,
+		ScriptKeyLocal:        output.ScriptKeyLocal,
+		Amount:                int64(output.Amount),
+		LockTime:              sqlInt32(output.LockTime),
+		RelativeLockTime:      sqlInt32(output.RelativeLockTime),
+		AssetVersion:          int32(output.AssetVersion),
+		SerializedWitnesses:   witnessBuf.Bytes(),
+		ProofSuffix:           output.ProofSuffix,
+		NumPassiveAssets:      int32(output.Anchor.NumPassiveAssets),
+		OutputType:            int16(output.Type),
+		ProofCourierAddr:      output.ProofCourierAddr,
+		ProofDeliveryComplete: proofDeliveryComplete,
+		Position:              position,
 	}
 
 	// There might not have been a split, so we can't rely on the split root
@@ -2526,6 +2556,22 @@ func fetchAssetTransferOutputs(ctx context.Context, q ActiveAssetsStore,
 			outputAnchor.CommitmentVersion = fn.Ptr(dbRootVersion)
 		}
 
+		// Parse the proof deliver complete flag from the database.
+		var proofDeliveryComplete fn.Option[bool]
+		if dbOut.ProofDeliveryComplete.Valid {
+			proofDeliveryComplete = fn.Some(
+				dbOut.ProofDeliveryComplete.Bool,
+			)
+		}
+
+		vOutputType := tappsbt.VOutputType(dbOut.OutputType)
+
+		// Ensure the position value is valid.
+		if dbOut.Position < 0 {
+			return nil, fmt.Errorf("invalid position value in "+
+				"db: %d", dbOut.Position)
+		}
+
 		outputs[idx] = tapfreighter.TransferOutput{
 			Anchor:           outputAnchor,
 			Amount:           uint64(dbOut.Amount),
@@ -2549,9 +2595,11 @@ func fetchAssetTransferOutputs(ctx context.Context, q ActiveAssetsStore,
 				splitRootHash,
 				uint64(dbOut.SplitCommitmentRootValue.Int64),
 			),
-			ProofSuffix:      dbOut.ProofSuffix,
-			Type:             tappsbt.VOutputType(dbOut.OutputType),
-			ProofCourierAddr: dbOut.ProofCourierAddr,
+			ProofSuffix:           dbOut.ProofSuffix,
+			Type:                  vOutputType,
+			ProofCourierAddr:      dbOut.ProofCourierAddr,
+			ProofDeliveryComplete: proofDeliveryComplete,
+			Position:              uint64(dbOut.Position),
 		}
 
 		err = readOutPoint(
@@ -2794,10 +2842,10 @@ func (a *AssetStore) ConfirmParcelDelivery(ctx context.Context,
 				!out.ScriptKeyLocal && !isKnown
 
 			log.Tracef("Skip asset creation for "+
-				"output %d?: %v,  scriptKey=%x, "+
+				"output %d?: %v,  position=%v, scriptKey=%x, "+
 				"isTombstone=%v, isBurn=%v, "+
 				"scriptKeyLocal=%v, scriptKeyKnown=%v",
-				idx, skipAssetCreation,
+				idx, skipAssetCreation, out.Position,
 				scriptPubKey.SerializeCompressed(),
 				isTombstone, isBurn, out.ScriptKeyLocal,
 				isKnown)

tapfreighter/interface.go

@@ -246,6 +246,18 @@ type TransferOutput struct {
 	// ProofCourierAddr is the bytes encoded proof courier service address
 	// associated with this output.
 	ProofCourierAddr []byte
+
+	// ProofDeliveryComplete is a flag that indicates whether the proof
+	// delivery for this output is complete.
+	//
+	// This field can take one of the following values:
+	// - None: A proof will not be delivered to a counterparty.
+	// - False: The proof has not yet been delivered successfully.
+	// - True: The proof has been delivered to the recipient.
+	ProofDeliveryComplete fn.Option[bool]
+
+	// Position is the position of the output in the transfer output list.
+	Position uint64
 }
 
 // ShouldDeliverProof returns true if a proof corresponding to the subject

tapfreighter/parcel.go

@@ -531,17 +531,24 @@ func ConvertToTransfer(currentHeight uint32, activeTransfers []*tappsbt.VPacket,
 		}
 	}
 
+	// The outputPosition represents the index of the output within the list
+	// of output transfers. It is continuously incremented across all
+	// outputs and virtual packets.
+	outputPosition := uint64(0)
+
 	for pIdx := range activeTransfers {
 		vPkt := activeTransfers[pIdx]
 
-		for idx := range vPkt.Outputs {
+		for vPktOutputIdx := range vPkt.Outputs {
 			tOut, err := transferOutput(
-				vPkt, idx, anchorTx, passiveAssets, isLocalKey,
+				vPkt, vPktOutputIdx, outputPosition, anchorTx,
+				passiveAssets, isLocalKey,
 			)
 			if err != nil {
 				return nil, fmt.Errorf("unable to convert "+
-					"output %d: %w", idx, err)
+					"output %d: %w", vPktOutputIdx, err)
 			}
+			outputPosition += 1
 
 			parcel.Outputs = append(parcel.Outputs, *tOut)
 		}
@@ -566,7 +573,7 @@ func transferInput(vIn *tappsbt.VInput) (*TransferInput, error) {
 
 // transferOutput creates a TransferOutput from a virtual output and the anchor
 // packet.
-func transferOutput(vPkt *tappsbt.VPacket, vOutIdx int,
+func transferOutput(vPkt *tappsbt.VPacket, vOutIdx int, position uint64,
 	anchorTx *tapsend.AnchorTransaction, passiveAssets []*tappsbt.VPacket,
 	isLocalKey func(asset.ScriptKey) bool) (*TransferOutput, error) {
 
@@ -612,6 +619,7 @@ func transferOutput(vPkt *tappsbt.VPacket, vOutIdx int,
 		ProofSuffix:         proofSuffixBuf.Bytes(),
 		ProofCourierAddr:    proofCourierAddrBytes,
 		ScriptKeyLocal:      isLocalKey(vOut.ScriptKey),
+		Position:            position,
 	}, nil
 }