utxo/propertyfx/fx.go

// Copyright (C) 2019-2025, Lux Industries, Inc. All rights reserved.
// See the file LICENSE for licensing terms.

package propertyfx

import (
	"errors"

	"github.com/luxfi/utxo/secp256k1fx"
	"github.com/luxfi/vm/components/verify"
)

var (
	errWrongTxType         = errors.New("wrong tx type")
	errWrongUTXOType       = errors.New("wrong utxo type")
	errWrongOperationType  = errors.New("wrong operation type")
	errWrongCredentialType = errors.New("wrong credential type")
	errWrongNumberOfUTXOs  = errors.New("wrong number of UTXOs for the operation")
	errWrongMintOutput     = errors.New("wrong mint output provided")
	errCantTransfer        = errors.New("cant transfer with this fx")
)

type Fx struct{ secp256k1fx.Fx }

func (fx *Fx) Initialize(vmIntf interface{}) error {
	if err := fx.InitializeVM(vmIntf); err != nil {
		return err
	}

	log := fx.VM.Logger()
	log.Debug("initializing nft fx")

	// ZAP-native: wire schemas are compile-time static. No runtime
	// codec registration needed.
	return nil
}

func (fx *Fx) VerifyOperation(txIntf, opIntf, credIntf interface{}, utxosIntf []interface{}) error {
	tx, ok := txIntf.(secp256k1fx.UnsignedTx)
	switch {
	case !ok:
		return errWrongTxType
	case len(utxosIntf) != 1:
		return errWrongNumberOfUTXOs
	}

	cred, ok := credIntf.(*Credential)
	if !ok {
		return errWrongCredentialType
	}

	switch op := opIntf.(type) {
	case *MintOperation:
		return fx.VerifyMintOperation(tx, op, cred, utxosIntf[0])
	case *BurnOperation:
		return fx.VerifyTransferOperation(tx, op, cred, utxosIntf[0])
	default:
		return errWrongOperationType
	}
}

func (fx *Fx) VerifyMintOperation(tx secp256k1fx.UnsignedTx, op *MintOperation, cred *Credential, utxoIntf interface{}) error {
	out, ok := utxoIntf.(*MintOutput)
	if !ok {
		return errWrongUTXOType
	}

	if err := verify.All(op, cred, out); err != nil {
		return err
	}

	switch {
	case !out.OutputOwners.Equals(&op.MintOutput.OutputOwners):
		return errWrongMintOutput
	default:
		return fx.Fx.VerifyCredentials(tx, &op.MintInput, &cred.Credential, &out.OutputOwners)
	}
}

func (fx *Fx) VerifyTransferOperation(tx secp256k1fx.UnsignedTx, op *BurnOperation, cred *Credential, utxoIntf interface{}) error {
	out, ok := utxoIntf.(*OwnedOutput)
	if !ok {
		return errWrongUTXOType
	}

	if err := verify.All(op, cred, out); err != nil {
		return err
	}

	return fx.VerifyCredentials(tx, &op.Input, &cred.Credential, &out.OutputOwners)
}

func (*Fx) VerifyTransfer(_, _, _, _ interface{}) error {
	return errCantTransfer
}