noto: add "lock" functionality

.dockerignore

@@ -13,14 +13,20 @@
 **/*.pb.go
 .git
 **/.gradle
+
 # Doc site is 100s of MB
 doc-site/
+
 # Zeto ZKP is 1GB
 domains/zeto/zkp
 
+# Other folders not needed for the Docker build
+example/
+sdk/
+
 # The operator has its own docker build (with its own .dockerignore), so we don't want to rebuild the whole
 # Paladin docker every time you're re-running the operator/test.
 # So we only install enough to keep the build happy.
 operator/**
 !operator/go.mod
-!operator/build.gradle
+!operator/build.gradle

.vscode/launch.json

@@ -15,6 +15,17 @@
             "type": "node",
             "cwd": "${workspaceFolder}/example/bond"
         },
+        {
+            "name": "Lock example: run",
+            "request": "launch",
+            "runtimeArgs": [
+                "run",
+                "start"
+            ],
+            "runtimeExecutable": "npm",
+            "type": "node",
+            "cwd": "${workspaceFolder}/example/lock"
+        },
         {
             "name": "Run Controller",
             "type": "go",

core/go/internal/components/statemgr.go

@@ -96,6 +96,9 @@ type DomainContext interface {
 	// The dbTX is passed in to allow re-use of a connection during read operations.
 	FindAvailableStates(dbTX *gorm.DB, schemaID tktypes.Bytes32, query *query.QueryJSON) (Schema, []*pldapi.State, error)
 
+	// GetStates retrieves a set of states by ID
+	GetStates(dbTX *gorm.DB, schemaID tktypes.Bytes32, ids []string) (Schema, []*pldapi.State, error)
+
 	// Return a snapshot of all currently known state locks
 	ExportSnapshot() ([]byte, error)
 

core/go/internal/domainmgr/domain.go

@@ -279,6 +279,26 @@ func (d *domain) Configuration() *prototk.DomainConfig {
 	return d.config
 }
 
+func toProtoStates(states []*pldapi.State) []*prototk.StoredState {
+	pbStates := make([]*prototk.StoredState, len(states))
+	for i, s := range states {
+		pbStates[i] = &prototk.StoredState{
+			Id:        s.ID.String(),
+			SchemaId:  s.Schema.String(),
+			CreatedAt: s.Created.UnixNano(),
+			DataJson:  string(s.Data),
+			Locks:     []*prototk.StateLock{},
+		}
+		for _, l := range s.Locks {
+			pbStates[i].Locks = append(pbStates[i].Locks, &prototk.StateLock{
+				Type:        mapStateLockType(l.Type.V()),
+				Transaction: l.Transaction.String(),
+			})
+		}
+	}
+	return pbStates
+}
+
 // Domain callback to query the state store
 func (d *domain) FindAvailableStates(ctx context.Context, req *prototk.FindAvailableStatesRequest) (*prototk.FindAvailableStatesResponse, error) {
 	c, err := d.checkInFlight(ctx, req.StateQueryContext)
@@ -306,24 +326,8 @@ func (d *domain) FindAvailableStates(ctx context.Context, req *prototk.FindAvail
 		return nil, err
 	}
 
-	pbStates := make([]*prototk.StoredState, len(states))
-	for i, s := range states {
-		pbStates[i] = &prototk.StoredState{
-			Id:        s.ID.String(),
-			SchemaId:  s.Schema.String(),
-			CreatedAt: s.Created.UnixNano(),
-			DataJson:  string(s.Data),
-			Locks:     []*prototk.StateLock{},
-		}
-		for _, l := range s.Locks {
-			pbStates[i].Locks = append(pbStates[i].Locks, &prototk.StateLock{
-				Type:        mapStateLockType(l.Type.V()),
-				Transaction: l.Transaction.String(),
-			})
-		}
-	}
 	return &prototk.FindAvailableStatesResponse{
-		States: pbStates,
+		States: toProtoStates(states),
 	}, nil
 
 }
@@ -771,3 +775,55 @@ func (d *domain) BuildDomainReceipt(ctx context.Context, dbTX *gorm.DB, txID uui
 	}
 	return tktypes.RawJSON(res.ReceiptJson), nil
 }
+
+func (d *domain) SendTransaction(ctx context.Context, tx *prototk.SendTransactionRequest) (*prototk.SendTransactionResponse, error) {
+	txType := pldapi.TransactionTypePrivate
+	if tx.Transaction.Type == prototk.TransactionInput_PUBLIC {
+		txType = pldapi.TransactionTypePublic
+	}
+	contractAddress, err := tktypes.ParseEthAddress(tx.Transaction.ContractAddress)
+	if err != nil {
+		return nil, err
+	}
+	var functionABI abi.Entry
+	if err = json.Unmarshal([]byte(tx.Transaction.FunctionAbiJson), &functionABI); err != nil {
+		return nil, err
+	}
+
+	id, err := d.dm.txManager.SendTransaction(ctx, &pldapi.TransactionInput{
+		TransactionBase: pldapi.TransactionBase{
+			Type: txType.Enum(),
+			From: tx.Transaction.From,
+			To:   contractAddress,
+			Data: tktypes.RawJSON(tx.Transaction.ParamsJson),
+		},
+		ABI: abi.ABI{&functionABI},
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &prototk.SendTransactionResponse{Id: id.String()}, nil
+}
+
+func (d *domain) LocalNodeName(ctx context.Context, req *prototk.LocalNodeNameRequest) (*prototk.LocalNodeNameResponse, error) {
+	return &prototk.LocalNodeNameResponse{
+		Name: d.dm.transportMgr.LocalNodeName(),
+	}, nil
+}
+
+func (d *domain) GetStates(ctx context.Context, req *prototk.GetStatesRequest) (*prototk.GetStatesResponse, error) {
+	c, err := d.checkInFlight(ctx, req.StateQueryContext)
+	if err != nil {
+		return nil, err
+	}
+
+	schemaID, err := tktypes.ParseBytes32(req.SchemaId)
+	if err != nil {
+		return nil, i18n.WrapError(ctx, err, msgs.MsgDomainInvalidSchemaID, req.SchemaId)
+	}
+
+	_, states, err := c.dCtx.GetStates(c.dbTX, schemaID, req.StateIds)
+	return &prototk.GetStatesResponse{
+		States: toProtoStates(states),
+	}, err
+}

core/go/internal/domainmgr/domain_test.go

@@ -287,7 +287,7 @@ func TestDomainInitStates(t *testing.T) {
 }
 func mockUpsertABIOk(mc *mockComponents) {
 	mc.txManager.On("UpsertABI", mock.Anything, mock.Anything, mock.Anything).Return(func() {}, &pldapi.StoredABI{
-		Hash: tktypes.Bytes32(tktypes.RandBytes(32)),
+		Hash: tktypes.RandBytes32(),
 	}, nil)
 }
 
@@ -496,7 +496,7 @@ func TestDomainFindAvailableStatesFail(t *testing.T) {
 	})
 	defer done()
 
-	schemaID := tktypes.Bytes32(tktypes.RandBytes(32))
+	schemaID := tktypes.RandBytes32()
 	td.mdc.On("FindAvailableStates", mock.Anything, schemaID, mock.Anything).Return(nil, nil, fmt.Errorf("pop"))
 
 	assert.Nil(t, td.d.initError.Load())
@@ -510,7 +510,7 @@ func TestDomainFindAvailableStatesFail(t *testing.T) {
 
 func storeTestState(t *testing.T, td *testDomainContext, txID uuid.UUID, amount *ethtypes.HexInteger) *fakeState {
 	state := &fakeState{
-		Salt:   tktypes.Bytes32(tktypes.RandBytes(32)),
+		Salt:   tktypes.RandBytes32(),
 		Owner:  tktypes.EthAddress(tktypes.RandBytes(20)),
 		Amount: amount,
 	}
@@ -1022,6 +1022,55 @@ func TestRecoverSignerFailCases(t *testing.T) {
 	assert.Regexp(t, "PD011638", err)
 }
 
+func TestSendTransactionFailCases(t *testing.T) {
+	td, done := newTestDomain(t, false, goodDomainConf(), mockSchemas())
+	defer done()
+
+	_, err := td.d.SendTransaction(td.ctx, &prototk.SendTransactionRequest{
+		Transaction: &prototk.TransactionInput{
+			ContractAddress: "badnotgood",
+			FunctionAbiJson: `{}`,
+			ParamsJson:      `{}`,
+		},
+	})
+	require.ErrorContains(t, err, "bad address")
+
+	_, err = td.d.SendTransaction(td.ctx, &prototk.SendTransactionRequest{
+		Transaction: &prototk.TransactionInput{
+			ContractAddress: "0x05d936207F04D81a85881b72A0D17854Ee8BE45A",
+			FunctionAbiJson: `bad`,
+			ParamsJson:      `{}`,
+		},
+	})
+	require.ErrorContains(t, err, "invalid character")
+}
+
+func TestGetStatesFailCases(t *testing.T) {
+	td, done := newTestDomain(t, false, goodDomainConf(), mockSchemas())
+	defer done()
+
+	_, err := td.d.GetStates(td.ctx, &prototk.GetStatesRequest{
+		StateQueryContext: "bad",
+	})
+	require.ErrorContains(t, err, "PD011649")
+
+	_, err = td.d.GetStates(td.ctx, &prototk.GetStatesRequest{
+		StateQueryContext: td.c.id,
+		SchemaId:          "bad",
+	})
+	require.ErrorContains(t, err, "PD011641")
+
+	schemaID := tktypes.Bytes32(tktypes.RandBytes(32))
+	td.mdc.On("GetStates", mock.Anything, schemaID, []string{"id1"}).Return(nil, nil, fmt.Errorf("pop"))
+
+	_, err = td.d.GetStates(td.ctx, &prototk.GetStatesRequest{
+		StateQueryContext: td.c.id,
+		SchemaId:          schemaID.String(),
+		StateIds:          []string{"id1"},
+	})
+	require.EqualError(t, err, "pop")
+}
+
 func TestMapStateLockType(t *testing.T) {
 	for _, pldType := range pldapi.StateLockType("").Options() {
 		assert.NotNil(t, mapStateLockType(pldapi.StateLockType(pldType)))

core/go/internal/domainmgr/event_indexer_test.go

@@ -205,7 +205,7 @@ func TestHandleEventBatch(t *testing.T) {
 	stateConfirmed := tktypes.RandHex(32)
 	stateInfo := tktypes.RandHex(32)
 	fakeHash1 := tktypes.RandHex(32)
-	fakeSchema := tktypes.Bytes32(tktypes.RandBytes(32))
+	fakeSchema := tktypes.RandBytes32()
 	event1 := &pldapi.EventWithData{
 		Address: *contract1,
 		IndexedEvent: &pldapi.IndexedEvent{
@@ -439,7 +439,7 @@ func TestHandleEventBatchRegistrationError(t *testing.T) {
 	mp.Mock.ExpectExec("INSERT.*private_smart_contracts").WillReturnError(fmt.Errorf("pop"))
 
 	registrationData := &event_PaladinRegisterSmartContract_V0{
-		TXId: tktypes.Bytes32(tktypes.RandBytes(32)),
+		TXId: tktypes.RandBytes32(),
 	}
 	registrationDataJSON, err := json.Marshal(registrationData)
 	require.NoError(t, err)

core/go/internal/domainmgr/private_smart_contract_test.go

@@ -522,6 +522,51 @@ func TestRecoverSignature(t *testing.T) {
 	assert.Equal(t, kp.Address.String(), res.Verifier)
 }
 
+func TestSendTransaction(t *testing.T) {
+	txID := uuid.New()
+	td, done := newTestDomain(t, false, goodDomainConf(), mockSchemas(), func(mc *mockComponents) {
+		mc.txManager.On("SendTransaction", mock.Anything, mock.Anything).Return(&txID, nil)
+	})
+	defer done()
+	assert.Nil(t, td.d.initError.Load())
+
+	_, err := td.d.SendTransaction(td.ctx, &prototk.SendTransactionRequest{
+		Transaction: &prototk.TransactionInput{
+			ContractAddress: "0x05d936207F04D81a85881b72A0D17854Ee8BE45A",
+			FunctionAbiJson: `{}`,
+			ParamsJson:      `{}`,
+		},
+	})
+	require.NoError(t, err)
+}
+
+func TestSendTransactionFail(t *testing.T) {
+	td, done := newTestDomain(t, false, goodDomainConf(), mockSchemas(), func(mc *mockComponents) {
+		mc.txManager.On("SendTransaction", mock.Anything, mock.Anything).Return(nil, fmt.Errorf("pop"))
+	})
+	defer done()
+	assert.Nil(t, td.d.initError.Load())
+
+	_, err := td.d.SendTransaction(td.ctx, &prototk.SendTransactionRequest{
+		Transaction: &prototk.TransactionInput{
+			ContractAddress: "0x05d936207F04D81a85881b72A0D17854Ee8BE45A",
+			FunctionAbiJson: `{}`,
+			ParamsJson:      `{}`,
+		},
+	})
+	require.EqualError(t, err, "pop")
+}
+
+func TestLocalNodeName(t *testing.T) {
+	td, done := newTestDomain(t, false, goodDomainConf(), mockSchemas())
+	defer done()
+	assert.Nil(t, td.d.initError.Load())
+
+	res, err := td.d.LocalNodeName(td.ctx, &prototk.LocalNodeNameRequest{})
+	require.NoError(t, err)
+	assert.Equal(t, "node1", res.Name)
+}
+
 func TestDomainInitTransactionMissingInput(t *testing.T) {
 	td, done := newTestDomain(t, false, goodDomainConf(), mockSchemas())
 	defer done()
@@ -606,13 +651,13 @@ func TestFullTransactionRealDBOK(t *testing.T) {
 	state4 := storeTestState(t, td, ptx.ID, ethtypes.NewHexInteger64(4444444))
 
 	state5 := &fakeState{
-		Salt:   tktypes.Bytes32(tktypes.RandBytes(32)),
+		Salt:   tktypes.RandBytes32(),
 		Owner:  tktypes.EthAddress(tktypes.RandBytes(20)),
 		Amount: ethtypes.NewHexInteger64(5555555),
 	}
 
 	state6 := &fakeState{
-		Salt:   tktypes.Bytes32(tktypes.RandBytes(32)),
+		Salt:   tktypes.RandBytes32(),
 		Owner:  tktypes.EthAddress(tktypes.RandBytes(20)),
 		Amount: ethtypes.NewHexInteger64(6666666),
 	}
@@ -957,7 +1002,7 @@ func TestDomainWritePotentialStatesBadSchema(t *testing.T) {
 
 func TestDomainWritePotentialStatesFail(t *testing.T) {
 	schema := componentmocks.NewSchema(t)
-	schemaID := tktypes.Bytes32(tktypes.RandBytes(32))
+	schemaID := tktypes.RandBytes32()
 	schema.On("ID").Return(schemaID)
 	schema.On("Signature").Return("schema1_signature")
 	td, done := newTestDomain(t, false, goodDomainConf(), mockSchemas(schema), mockBlockHeight)
@@ -975,7 +1020,7 @@ func TestDomainWritePotentialStatesFail(t *testing.T) {
 
 func TestDomainWritePotentialStatesBadID(t *testing.T) {
 	schema := componentmocks.NewSchema(t)
-	schemaID := tktypes.Bytes32(tktypes.RandBytes(32))
+	schemaID := tktypes.RandBytes32()
 	schema.On("ID").Return(schemaID)
 	schema.On("Signature").Return("schema1_signature")
 	td, done := newTestDomain(t, false, goodDomainConf(), mockSchemas(schema), mockBlockHeight)

core/go/internal/plugins/domains.go

@@ -98,6 +98,33 @@ func (br *domainBridge) RequestReply(ctx context.Context, reqMsg plugintk.Plugin
 				}
 			},
 		)
+	case *prototk.DomainMessage_SendTransaction:
+		return callManagerImpl(ctx, req.SendTransaction,
+			br.manager.SendTransaction,
+			func(resMsg *prototk.DomainMessage, res *prototk.SendTransactionResponse) {
+				resMsg.ResponseToDomain = &prototk.DomainMessage_SendTransactionRes{
+					SendTransactionRes: res,
+				}
+			},
+		)
+	case *prototk.DomainMessage_LocalNodeName:
+		return callManagerImpl(ctx, req.LocalNodeName,
+			br.manager.LocalNodeName,
+			func(resMsg *prototk.DomainMessage, res *prototk.LocalNodeNameResponse) {
+				resMsg.ResponseToDomain = &prototk.DomainMessage_LocalNodeNameRes{
+					LocalNodeNameRes: res,
+				}
+			},
+		)
+	case *prototk.DomainMessage_GetStates:
+		return callManagerImpl(ctx, req.GetStates,
+			br.manager.GetStates,
+			func(resMsg *prototk.DomainMessage, res *prototk.GetStatesResponse) {
+				resMsg.ResponseToDomain = &prototk.DomainMessage_GetStatesRes{
+					GetStatesRes: res,
+				}
+			},
+		)
 	default:
 		return nil, i18n.NewError(ctx, msgs.MsgPluginBadRequestBody, req)
 	}