Merge pull request #152 from kaleido-io/constructor-abi

Remove ABI validation of domain constructor args
LF-Decentralized-Trust-labs · Sep 12, 2024 · 8d24e18 · 8d24e18
2 parents f867339 + ffe0c60
commit 8d24e18
Show file tree

Hide file tree

Showing 14 changed files with 10 additions and 182 deletions.
diff --git a/core/go/internal/domainmgr/domain.go b/core/go/internal/domainmgr/domain.go
@@ -51,7 +51,6 @@ type domain struct {
 	config                 *prototk.DomainConfig
 	schemasBySignature     map[string]statestore.Schema
 	schemasByID            map[string]statestore.Schema
-	constructorABI         *abi.Entry
 	factoryContractAddress *tktypes.EthAddress
 
 	initError atomic.Pointer[error]
@@ -92,14 +91,7 @@ func (d *domain) processDomainConfig(confRes *prototk.ConfigureDomainResponse) (
 		}
 	}
 
-	err := json.Unmarshal(([]byte)(d.config.ConstructorAbiJson), &d.constructorABI)
-	if err != nil {
-		return nil, i18n.WrapError(d.ctx, err, msgs.MsgDomainConstructorAbiJsonInvalid)
-	}
-	if d.constructorABI.Type != abi.Constructor {
-		return nil, i18n.NewError(d.ctx, msgs.MsgDomainConstructorABITypeWrong, d.constructorABI.Type)
-	}
-
+	var err error
 	d.factoryContractAddress, err = tktypes.ParseEthAddress(d.config.FactoryContractAddress)
 	if err != nil {
 		return nil, i18n.WrapError(d.ctx, err, msgs.MsgDomainFactoryAddressInvalid)
@@ -244,25 +236,10 @@ func (d *domain) InitDeploy(ctx context.Context, tx *components.PrivateContractD
 	}
 
 	// Build the init request
-	var abiJSON []byte
-	var paramsJSON []byte
-	constructorValues, err := d.constructorABI.Inputs.ParseJSONCtx(ctx, tx.Inputs)
-	if err == nil {
-		abiJSON, err = json.Marshal(d.constructorABI)
-	}
-	if err == nil {
-		// Serialize to standardized JSON before passing to domain
-		paramsJSON, err = tktypes.StandardABISerializer().SerializeJSONCtx(ctx, constructorValues)
-	}
-	if err != nil {
-		return i18n.WrapError(ctx, err, msgs.MsgDomainInvalidConstructorParams, d.constructorABI.SolString())
-	}
-
 	txSpec := &prototk.DeployTransactionSpecification{}
 	tx.TransactionSpecification = txSpec
 	txSpec.TransactionId = tktypes.Bytes32UUIDFirst16(tx.ID).String()
-	txSpec.ConstructorAbi = string(abiJSON)
-	txSpec.ConstructorParamsJson = string(paramsJSON)
+	txSpec.ConstructorParamsJson = tx.Inputs.String()
 
 	// Do the request with the domain
 	res, err := d.api.InitDeploy(ctx, &prototk.InitDeployRequest{

diff --git a/core/go/internal/domainmgr/domain_test.go b/core/go/internal/domainmgr/domain_test.go
@@ -37,25 +37,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const fakeCoinConstructorABI = `{
-	 "type": "constructor",
-	 "inputs": [
-	   {
-		 "name": "notary",
-		 "type": "string"
-	   },
-	   {
-		 "name": "name",
-		 "type": "string"
-	   },
-	   {
-		 "name": "symbol",
-		 "type": "string"
-	   }
-	 ],
-	 "outputs": null
- }`
-
 const fakeCoinStateSchema = `{
 	"type": "tuple",
 	"internalType": "struct FakeCoin",
@@ -206,7 +187,6 @@ func goodDomainConf() *prototk.DomainConfig {
 			SubmitMode:       prototk.BaseLedgerSubmitConfig_ONE_TIME_USE_KEYS,
 			OneTimeUsePrefix: "one/time/keys/",
 		},
-		ConstructorAbiJson:     fakeCoinConstructorABI,
 		FactoryContractAddress: tktypes.MustEthAddress(tktypes.RandHex(20)).String(),
 		AbiStateSchemasJson: []string{
 			fakeCoinStateSchema,
@@ -267,7 +247,6 @@ func TestDoubleRegisterReplaces(t *testing.T) {
 func TestDomainInitBadSchemas(t *testing.T) {
 	_, _, tp, done := newTestDomain(t, false, &prototk.DomainConfig{
 		BaseLedgerSubmitConfig: &prototk.BaseLedgerSubmitConfig{},
-		ConstructorAbiJson:     fakeCoinConstructorABI,
 		FactoryContractAddress: tktypes.MustEthAddress(tktypes.RandHex(20)).String(),
 		AbiStateSchemasJson: []string{
 			`!!! Wrong`,
@@ -278,52 +257,9 @@ func TestDomainInitBadSchemas(t *testing.T) {
 	assert.False(t, tp.initialized.Load())
 }
 
-func TestDomainInitBadConstructor(t *testing.T) {
-	_, _, tp, done := newTestDomain(t, false, &prototk.DomainConfig{
-		BaseLedgerSubmitConfig: &prototk.BaseLedgerSubmitConfig{},
-		ConstructorAbiJson:     `!!!wrong`,
-		FactoryContractAddress: tktypes.MustEthAddress(tktypes.RandHex(20)).String(),
-		AbiStateSchemasJson: []string{
-			fakeCoinStateSchema,
-		},
-	})
-	defer done()
-	assert.Regexp(t, "PD011603", *tp.d.initError.Load())
-	assert.False(t, tp.initialized.Load())
-}
-
-func TestDomainInitBadConstructorType(t *testing.T) {
-	_, _, tp, done := newTestDomain(t, false, &prototk.DomainConfig{
-		BaseLedgerSubmitConfig: &prototk.BaseLedgerSubmitConfig{},
-		ConstructorAbiJson:     `{"type":"event"}`,
-		FactoryContractAddress: tktypes.MustEthAddress(tktypes.RandHex(20)).String(),
-		AbiStateSchemasJson: []string{
-			fakeCoinStateSchema,
-		},
-	})
-	defer done()
-	assert.Regexp(t, "PD011604", *tp.d.initError.Load())
-	assert.False(t, tp.initialized.Load())
-}
-
-func TestDomainInitSchemaStoreFail(t *testing.T) {
-	_, _, tp, done := newTestDomain(t, false, &prototk.DomainConfig{
-		BaseLedgerSubmitConfig: &prototk.BaseLedgerSubmitConfig{},
-		ConstructorAbiJson:     `{"type":"event"}`,
-		FactoryContractAddress: tktypes.MustEthAddress(tktypes.RandHex(20)).String(),
-		AbiStateSchemasJson: []string{
-			fakeCoinStateSchema,
-		},
-	})
-	defer done()
-	assert.Regexp(t, "PD011604", *tp.d.initError.Load())
-	assert.False(t, tp.initialized.Load())
-}
-
 func TestDomainInitBadAddress(t *testing.T) {
 	_, _, tp, done := newTestDomain(t, false, &prototk.DomainConfig{
 		BaseLedgerSubmitConfig: &prototk.BaseLedgerSubmitConfig{},
-		ConstructorAbiJson:     fakeCoinConstructorABI,
 		FactoryContractAddress: `!wrong`,
 		AbiStateSchemasJson: []string{
 			fakeCoinStateSchema,
@@ -337,7 +273,6 @@ func TestDomainInitBadAddress(t *testing.T) {
 func TestDomainInitFactorySchemaStoreFail(t *testing.T) {
 	_, _, tp, done := newTestDomain(t, false, &prototk.DomainConfig{
 		BaseLedgerSubmitConfig: &prototk.BaseLedgerSubmitConfig{},
-		ConstructorAbiJson:     fakeCoinConstructorABI,
 		FactoryContractAddress: tktypes.MustEthAddress(tktypes.RandHex(20)).String(),
 		AbiStateSchemasJson: []string{
 			fakeCoinStateSchema,
@@ -479,7 +414,6 @@ func TestDomainInitDeployOK(t *testing.T) {
 	tp.Functions.InitDeploy = func(ctx context.Context, idr *prototk.InitDeployRequest) (*prototk.InitDeployResponse, error) {
 		defer done()
 		assert.Equal(t, "0x53ba5dd6b708444da2fa50578b974fb700000000000000000000000000000000", idr.Transaction.TransactionId)
-		assert.JSONEq(t, fakeCoinConstructorABI, idr.Transaction.ConstructorAbi)
 		assert.JSONEq(t, `{
 		  "notary": "notary1",
 		  "name": "token1",
@@ -525,26 +459,6 @@ func TestDomainInitDeployMissingInput(t *testing.T) {
 	assert.Nil(t, tx.RequiredVerifiers)
 }
 
-func TestDomainInitDeployBadConstructorParams(t *testing.T) {
-	ctx, _, tp, done := newTestDomain(t, false, goodDomainConf(), mockSchemas())
-	defer done()
-	assert.Nil(t, tp.d.initError.Load())
-
-	txID := uuid.MustParse("53BA5DD6-B708-444D-A2FA-50578B974FB7")
-	domain := tp.d
-	tx := &components.PrivateContractDeploy{
-		ID: txID,
-		Inputs: tktypes.RawJSON(`{
-		  "notary": "notary1",
-		  "name": 12345,
-		  "symbol": "TKN1"
-		}`),
-	}
-	err := domain.InitDeploy(ctx, tx)
-	assert.Regexp(t, "PD011610", err)
-	assert.Nil(t, tx.RequiredVerifiers)
-}
-
 func TestDomainInitDeployError(t *testing.T) {
 	ctx, _, tp, done := newTestDomain(t, false, goodDomainConf(), mockSchemas())
 	defer done()

diff --git a/core/go/internal/msgs/en_errors.go b/core/go/internal/msgs/en_errors.go
@@ -209,14 +209,11 @@ var (
 	MsgDomainNotFound                         = ffe("PD011600", "Domain %q not found")
 	MsgDomainNotInitialized                   = ffe("PD011601", "Domain not initialized")
 	MsgDomainInvalidSchema                    = ffe("PD011602", "Domain schema %d is invalid")
-	MsgDomainConstructorAbiJsonInvalid        = ffe("PD011603", "Constructor ABI function definition invalid")
-	MsgDomainConstructorABITypeWrong          = ffe("PD011604", "Constructor ABI function definition has wrong type: %s")
 	MsgDomainFactoryAbiJsonInvalid            = ffe("PD011605", "Factory contract ABI invalid")
 	MsgDomainFactoryAddressInvalid            = ffe("PD011606", "Factory contract address invalid")
 	MsgDomainPrivateAbiJsonInvalid            = ffe("PD011607", "Private contract ABI invalid")
 	MsgDomainInvalidQueryJSON                 = ffe("PD011608", "Invalid query JSON")
 	MsgDomainContractNotFoundByAddr           = ffe("PD011609", "A smart contract with address %s has not yet been indexed")
-	MsgDomainInvalidConstructorParams         = ffe("PD011610", "Invalid constructor parameters for %s")
 	MsgDomainInvalidPrepareDeployResult       = ffe("PD011611", "Prepare deploy did not result in exactly one of a invoke transaction or a deploy transaction")
 	MsgDomainInvalidFunctionParams            = ffe("PD011612", "Invalid function parameters for %s")
 	MsgDomainUnknownSchema                    = ffe("PD011613", "Unknown schema %s")

diff --git a/core/go/internal/plugins/domains_test.go b/core/go/internal/plugins/domains_test.go
@@ -111,7 +111,7 @@ func TestDomainRequestsOK(t *testing.T) {
 			assert.Equal(t, int64(12345), cdr.ChainId)
 			return &prototk.ConfigureDomainResponse{
 				DomainConfig: &prototk.DomainConfig{
-					ConstructorAbiJson: "ABI1",
+					FactoryContractAddress: "address1",
 				},
 			}, nil
 		},
@@ -196,7 +196,7 @@ func TestDomainRequestsOK(t *testing.T) {
 		ChainId: int64(12345),
 	})
 	require.NoError(t, err)
-	assert.Equal(t, "ABI1", cdr.DomainConfig.ConstructorAbiJson)
+	assert.Equal(t, "address1", cdr.DomainConfig.FactoryContractAddress)
 
 	_, err = domainAPI.InitDomain(ctx, &prototk.InitDomainRequest{
 		DomainUuid: domainID,

diff --git a/core/go/pkg/testbed/ut_simdomain_notarized_token_test.go b/core/go/pkg/testbed/ut_simdomain_notarized_token_test.go
@@ -65,24 +65,6 @@ func TestDemoNotarizedCoinSelection(t *testing.T) {
 
 	var blockIndexer atomic.Pointer[blockindexer.BlockIndexer]
 	var ec ethclient.EthClient
-	fakeCoinConstructorABI := `{
-		"type": "constructor",
-		"inputs": [
-		  {
-		    "name": "notary",
-			"type": "string"
-		  },
-		  {
-		    "name": "name",
-			"type": "string"
-		  },
-		  {
-		    "name": "symbol",
-			"type": "string"
-		  }
-		],
-		"outputs": null
-	}`
 
 	fakeCoinStateSchema := `{
 		"type": "tuple",
@@ -336,7 +318,6 @@ func TestDemoNotarizedCoinSelection(t *testing.T) {
 						BaseLedgerSubmitConfig: &prototk.BaseLedgerSubmitConfig{
 							SubmitMode: prototk.BaseLedgerSubmitConfig_ENDORSER_SUBMISSION,
 						},
-						ConstructorAbiJson:     fakeCoinConstructorABI,
 						FactoryContractAddress: deployTx.ContractAddress.String(),
 						AbiStateSchemasJson:    []string{fakeCoinStateSchema},
 					},
@@ -351,7 +332,6 @@ func TestDemoNotarizedCoinSelection(t *testing.T) {
 			},
 
 			InitDeploy: func(ctx context.Context, req *prototk.InitDeployRequest) (*prototk.InitDeployResponse, error) {
-				assert.JSONEq(t, fakeCoinConstructorABI, req.Transaction.ConstructorAbi)
 				assert.JSONEq(t, fakeDeployPayload, req.Transaction.ConstructorParamsJson)
 				return &prototk.InitDeployResponse{
 					RequiredVerifiers: []*prototk.ResolveVerifierRequest{
@@ -364,7 +344,6 @@ func TestDemoNotarizedCoinSelection(t *testing.T) {
 			},
 
 			PrepareDeploy: func(ctx context.Context, req *prototk.PrepareDeployRequest) (*prototk.PrepareDeployResponse, error) {
-				assert.JSONEq(t, fakeCoinConstructorABI, req.Transaction.ConstructorAbi)
 				assert.JSONEq(t, `{
 					"notary": "domain1/contract1/notary",
 					"name": "FakeToken1",

diff --git a/core/java/src/test/java/io/kaleido/paladin/TestDomain.java b/core/java/src/test/java/io/kaleido/paladin/TestDomain.java
@@ -29,9 +29,6 @@ public class TestDomain extends DomainInstance {
     @Override
     protected CompletableFuture<ToDomain.ConfigureDomainResponse> configureDomain(ToDomain.ConfigureDomainRequest request) {
         ToDomain.DomainConfig domainConfig = ToDomain.DomainConfig.newBuilder()
-                .setConstructorAbiJson("""
-                    {"type":"constructor","inputs":[]}
-                """)
                 .setFactoryContractAddress("0x1000000000000000000000000000000000000001")
                 .setBaseLedgerSubmitConfig(ToDomain.BaseLedgerSubmitConfig.newBuilder()
                         .setSubmitMode(ToDomain.BaseLedgerSubmitConfig.Mode.ONE_TIME_USE_KEYS)

diff --git a/domains/noto/internal/noto/noto.go b/domains/noto/internal/noto/noto.go
@@ -93,10 +93,6 @@ func (n *Noto) ConfigureDomain(ctx context.Context, req *pb.ConfigureDomainReque
 		return nil, fmt.Errorf("unrecognized variant: %s", config.Variant)
 	}
 
-	constructorJSON, err := json.Marshal(types.NotoABI.Constructor())
-	if err != nil {
-		return nil, err
-	}
 	schemaJSON, err := json.Marshal(types.NotoCoinABI)
 	if err != nil {
 		return nil, err
@@ -105,7 +101,6 @@ func (n *Noto) ConfigureDomain(ctx context.Context, req *pb.ConfigureDomainReque
 	return &pb.ConfigureDomainResponse{
 		DomainConfig: &pb.DomainConfig{
 			FactoryContractAddress: config.FactoryAddress,
-			ConstructorAbiJson:     string(constructorJSON),
 			AbiStateSchemasJson:    []string{string(schemaJSON)},
 			BaseLedgerSubmitConfig: &pb.BaseLedgerSubmitConfig{
 				SubmitMode: pb.BaseLedgerSubmitConfig_ENDORSER_SUBMISSION,

diff --git a/domains/noto/pkg/types/abi.go b/domains/noto/pkg/types/abi.go
@@ -21,12 +21,6 @@ import (
 )
 
 var NotoABI = abi.ABI{
-	{
-		Type: abi.Constructor,
-		Inputs: abi.ParameterArray{
-			{Name: "notary", Type: "string"},
-		},
-	},
 	{
 		Name: "mint",
 		Type: abi.Function,

diff --git a/domains/pente/src/main/java/io/kaleido/pente/domain/PenteConfiguration.java b/domains/pente/src/main/java/io/kaleido/pente/domain/PenteConfiguration.java
@@ -74,13 +74,6 @@ private static JsonABI.Parameter abiTuple_group() {
         ));
     }
 
-    JsonABI.Entry abiEntry_privateConstructor() {
-        return JsonABI.newConstructor(JsonABI.newParameters(
-                abiTuple_group(),
-                JsonABI.newParameter("endorsementType", "string")
-        ));
-    }
-
     JsonABI.Entry abiEntry_privateTransactionInvoke() {
         return JsonABI.newConstructor(JsonABI.newParameters(
                 abiTuple_group(),

diff --git a/domains/pente/src/main/java/io/kaleido/pente/domain/PenteDomain.java b/domains/pente/src/main/java/io/kaleido/pente/domain/PenteDomain.java
@@ -38,7 +38,6 @@ protected CompletableFuture<ToDomain.ConfigureDomainResponse> configureDomain(To
         config.initFromJSON(request.getConfigJson());
 
         ToDomain.DomainConfig domainConfig = ToDomain.DomainConfig.newBuilder()
-                .setConstructorAbiJson(config.abiEntry_privateConstructor().toString())
                 .setFactoryContractAddress(config.getAddress().toString())
                 .addAllAbiStateSchemasJson(config.allPenteSchemas())
                 .setBaseLedgerSubmitConfig(ToDomain.BaseLedgerSubmitConfig.newBuilder()

diff --git a/domains/zeto/internal/zeto/zeto.go b/domains/zeto/internal/zeto/zeto.go
@@ -82,10 +82,6 @@ func (z *Zeto) ConfigureDomain(ctx context.Context, req *pb.ConfigureDomainReque
 	z.factoryABI = factory.ABI
 	z.contractABI = contract.ABI
 
-	constructorJSON, err := json.Marshal(types.ZetoABI.Constructor())
-	if err != nil {
-		return nil, err
-	}
 	schemaJSON, err := json.Marshal(types.ZetoCoinABI)
 	if err != nil {
 		return nil, err
@@ -94,7 +90,6 @@ func (z *Zeto) ConfigureDomain(ctx context.Context, req *pb.ConfigureDomainReque
 	return &pb.ConfigureDomainResponse{
 		DomainConfig: &pb.DomainConfig{
 			FactoryContractAddress: config.FactoryAddress,
-			ConstructorAbiJson:     string(constructorJSON),
 			AbiStateSchemasJson:    []string{string(schemaJSON)},
 			BaseLedgerSubmitConfig: &pb.BaseLedgerSubmitConfig{
 				SubmitMode: pb.BaseLedgerSubmitConfig_ENDORSER_SUBMISSION,

diff --git a/domains/zeto/pkg/types/abi.go b/domains/zeto/pkg/types/abi.go
@@ -21,24 +21,15 @@ import (
 )
 
 var ZetoABI = abi.ABI{
-	&abi.Entry{
-		Type: abi.Constructor,
-		Inputs: abi.ParameterArray{
-			{Name: "from", Type: "string"},
-			{Name: "depositVerifier", Type: "address"},
-			{Name: "withdrawVerifier", Type: "address"},
-			{Name: "verifier", Type: "address"},
-		},
-	},
-	&abi.Entry{
+	{
 		Name: "mint",
 		Type: abi.Function,
 		Inputs: abi.ParameterArray{
 			{Name: "to", Type: "string"},
 			{Name: "amount", Type: "uint256"},
 		},
 	},
-	&abi.Entry{
+	{
 		Name: "transfer",
 		Type: abi.Function,
 		Inputs: abi.ParameterArray{

diff --git a/toolkit/go/domainstarter/starter/starter.go b/toolkit/go/domainstarter/starter/starter.go
@@ -42,7 +42,6 @@ func (s *starter) configureDomain(ctx context.Context, cdr *prototk.ConfigureDom
 	return &prototk.ConfigureDomainResponse{
 		// This is a useless, but valid, example
 		DomainConfig: &prototk.DomainConfig{
-			ConstructorAbiJson:     `{"type":"constructor","inputs":[]}`,
 			FactoryContractAddress: `0x1000000000000000000000000000000000000001`,
 			AbiStateSchemasJson:    []string{},
 			BaseLedgerSubmitConfig: &prototk.BaseLedgerSubmitConfig{