fix(ledger): use amount for conway per CIP-0094 (#1257)

Signed-off-by: Chris Gianelloni <[email protected]>

Author: wolf31o2

ledger/conway/rules.go

@@ -255,7 +255,14 @@ func UtxoValidateValueNotConservedUtxo(
 	for _, cert := range tx.Certificates() {
 		switch tmpCert := cert.(type) {
 		case *common.DeregistrationCertificate:
-			consumedValue += uint64(tmpPparams.KeyDeposit)
+			// CIP-0094 deregistration uses Amount field for refund (symmetric with registration deposit)
+			if tmpCert.Amount <= 0 {
+				return shelley.InvalidCertificateDepositError{
+					CertificateType: common.CertificateType(tmpCert.CertType),
+					Amount:          tmpCert.Amount,
+				}
+			}
+			consumedValue += uint64(tmpCert.Amount)
 		case *common.DeregistrationDrepCertificate:
 			if tmpCert.Amount <= 0 {
 				return shelley.InvalidCertificateDepositError{
@@ -265,6 +272,7 @@ func UtxoValidateValueNotConservedUtxo(
 			}
 			consumedValue += uint64(tmpCert.Amount)
 		case *common.StakeDeregistrationCertificate:
+			// Traditional stake deregistration uses protocol KeyDeposit parameter
 			consumedValue += uint64(tmpPparams.KeyDeposit)
 		}
 	}
@@ -286,6 +294,7 @@ func UtxoValidateValueNotConservedUtxo(
 				producedValue += uint64(tmpPparams.PoolDeposit)
 			}
 		case *common.RegistrationCertificate:
+			// CIP-0094 registration uses Amount field for deposit
 			if tmpCert.Amount <= 0 {
 				return shelley.InvalidCertificateDepositError{
 					CertificateType: common.CertificateType(tmpCert.CertType),
@@ -302,6 +311,7 @@ func UtxoValidateValueNotConservedUtxo(
 			}
 			producedValue += uint64(tmpCert.Amount)
 		case *common.StakeRegistrationCertificate:
+			// Traditional stake registration uses protocol KeyDeposit parameter
 			producedValue += uint64(tmpPparams.KeyDeposit)
 		case *common.StakeRegistrationDelegationCertificate:
 			if tmpCert.Amount <= 0 {

ledger/conway/rules_test.go

@@ -502,6 +502,7 @@ func TestUtxoValidateValueNotConservedUtxo(t *testing.T) {
 	var testInputAmount uint64 = 555666777
 	var testFee uint64 = 123456
 	var testStakeDeposit uint64 = 2_000_000
+	var testDepositAmount uint64 = 1_500_000
 	testOutputExactAmount := testInputAmount - testFee
 	testOutputUnderAmount := testOutputExactAmount - 999
 	testOutputOverAmount := testOutputExactAmount + 999
@@ -662,6 +663,136 @@ func TestUtxoValidateValueNotConservedUtxo(t *testing.T) {
 			)
 		},
 	)
+	// CIP-0094 Registration certificate with valid deposit
+	t.Run(
+		"registration certificate valid deposit",
+		func(t *testing.T) {
+			testTx.Body.TxOutputs[0].OutputAmount.Amount = testOutputExactAmount - testDepositAmount // Subtract deposit from output
+			testTx.Body.TxCertificates = []common.CertificateWrapper{
+				{
+					Type: uint(common.CertificateTypeRegistration),
+					Certificate: &common.RegistrationCertificate{
+						StakeCredential: common.Credential{},
+						Amount:          int64(testDepositAmount),
+					},
+				},
+			}
+			err := conway.UtxoValidateValueNotConservedUtxo(
+				testTx,
+				testSlot,
+				testLedgerState,
+				testProtocolParams,
+			)
+			if err != nil {
+				t.Errorf(
+					"UtxoValidateValueNotConservedUtxo should succeed with valid registration deposit\n  got error: %v",
+					err,
+				)
+			}
+		},
+	)
+	// CIP-0094 Registration certificate with invalid deposit (zero)
+	t.Run(
+		"registration certificate invalid deposit zero",
+		func(t *testing.T) {
+			testTx.Body.TxOutputs[0].OutputAmount.Amount = testOutputExactAmount
+			testTx.Body.TxCertificates = []common.CertificateWrapper{
+				{
+					Type: uint(common.CertificateTypeRegistration),
+					Certificate: &common.RegistrationCertificate{
+						StakeCredential: common.Credential{},
+						Amount:          0,
+					},
+				},
+			}
+			err := conway.UtxoValidateValueNotConservedUtxo(
+				testTx,
+				testSlot,
+				testLedgerState,
+				testProtocolParams,
+			)
+			if err == nil {
+				t.Errorf(
+					"UtxoValidateValueNotConservedUtxo should fail with zero registration deposit",
+				)
+				return
+			}
+			testErrType := shelley.InvalidCertificateDepositError{}
+			assert.IsType(
+				t,
+				testErrType,
+				err,
+				"did not get expected error type: got %T, wanted %T",
+				err,
+				testErrType,
+			)
+		},
+	)
+	// CIP-0094 Deregistration certificate with valid refund
+	t.Run(
+		"deregistration certificate valid refund",
+		func(t *testing.T) {
+			testTx.Body.TxOutputs[0].OutputAmount.Amount = testOutputExactAmount + testDepositAmount // Add refund to output
+			testTx.Body.TxCertificates = []common.CertificateWrapper{
+				{
+					Type: uint(common.CertificateTypeDeregistration),
+					Certificate: &common.DeregistrationCertificate{
+						StakeCredential: common.Credential{},
+						Amount:          int64(testDepositAmount),
+					},
+				},
+			}
+			err := conway.UtxoValidateValueNotConservedUtxo(
+				testTx,
+				testSlot,
+				testLedgerState,
+				testProtocolParams,
+			)
+			if err != nil {
+				t.Errorf(
+					"UtxoValidateValueNotConservedUtxo should succeed with valid deregistration refund\n  got error: %v",
+					err,
+				)
+			}
+		},
+	)
+	// CIP-0094 Deregistration certificate with invalid refund (zero)
+	t.Run(
+		"deregistration certificate invalid refund zero",
+		func(t *testing.T) {
+			testTx.Body.TxOutputs[0].OutputAmount.Amount = testOutputExactAmount
+			testTx.Body.TxCertificates = []common.CertificateWrapper{
+				{
+					Type: uint(common.CertificateTypeDeregistration),
+					Certificate: &common.DeregistrationCertificate{
+						StakeCredential: common.Credential{},
+						Amount:          0,
+					},
+				},
+			}
+			err := conway.UtxoValidateValueNotConservedUtxo(
+				testTx,
+				testSlot,
+				testLedgerState,
+				testProtocolParams,
+			)
+			if err == nil {
+				t.Errorf(
+					"UtxoValidateValueNotConservedUtxo should fail with zero deregistration refund",
+				)
+				return
+			}
+			testErrType := shelley.InvalidCertificateDepositError{}
+			assert.IsType(
+				t,
+				testErrType,
+				err,
+				"did not get expected error type: got %T, wanted %T",
+				err,
+				testErrType,
+			)
+		},
+	)
 }
 
 func TestUtxoValidateOutputTooSmallUtxo(t *testing.T) {