Zeto lock support

build.gradle

@@ -209,44 +209,30 @@ task copyZetoZKPFiles(type: Copy) {
         include 'anon_enc_batch-vkey.json'
         include 'anon_enc_batch_js/anon_enc_batch.wasm'
         // anon_nullifier
-        include 'anon_nullifier.zkey'
-        include 'anon_nullifier-vkey.json'
-        include 'anon_nullifier_js/anon_nullifier.wasm'
-        include 'anon_nullifier_batch.zkey'
-        include 'anon_nullifier_batch-vkey.json'
-        include 'anon_nullifier_batch_js/anon_nullifier_batch.wasm'
+        include 'anon_nullifier_transfer.zkey'
+        include 'anon_nullifier_transfer-vkey.json'
+        include 'anon_nullifier_transfer_js/anon_nullifier_transfer.wasm'
+        include 'anon_nullifier_transfer_batch.zkey'
+        include 'anon_nullifier_transfer_batch-vkey.json'
+        include 'anon_nullifier_transfer_batch_js/anon_nullifier_transfer_batch.wasm'
         // deposit
-        include 'check_hashes_value.zkey'
-        include 'check_hashes_value-vkey.json'
-        include 'check_hashes_value_js/check_hashes_value.wasm'
+        include 'deposit.zkey'
+        include 'deposit-vkey.json'
+        include 'deposit_js/deposit.wasm'
         // withdraw
-        include 'check_inputs_outputs_value.zkey'
-        include 'check_inputs_outputs_value-vkey.json'
-        include 'check_inputs_outputs_value_js/check_inputs_outputs_value.wasm'
-        include 'check_inputs_outputs_value_batch.zkey'
-        include 'check_inputs_outputs_value_batch-vkey.json'
-        include 'check_inputs_outputs_value_batch_js/check_inputs_outputs_value_batch.wasm'
+        include 'withdraw.zkey'
+        include 'withdraw-vkey.json'
+        include 'withdraw_js/withdraw.wasm'
+        include 'withdraw_batch.zkey'
+        include 'withdraw_batch-vkey.json'
+        include 'withdraw_batch_js/withdraw_batch.wasm'
         // withdraw_nullifier
-        include 'check_nullifiers_value.zkey'
-        include 'check_nullifiers_value-vkey.json'
-        include 'check_nullifiers_value_js/check_nullifiers_value.wasm'
-        include 'check_nullifiers_value_batch.zkey'
-        include 'check_nullifiers_value_batch-vkey.json'
-        include 'check_nullifiers_value_batch_js/check_nullifiers_value_batch.wasm'
-        // check_utxos_owner
-        include 'check_utxos_owner.zkey'
-        include 'check_utxos_owner-vkey.json'
-        include 'check_utxos_owner_js/check_utxos_owner.wasm'
-        include 'check_utxos_owner_batch.zkey'
-        include 'check_utxos_owner_batch-vkey.json'
-        include 'check_utxos_owner_batch_js/check_utxos_owner_batch.wasm'
-        // check_nullifiers_owner
-        include 'check_nullifiers_owner.zkey'
-        include 'check_nullifiers_owner-vkey.json'
-        include 'check_nullifiers_owner_js/check_nullifiers_owner.wasm'
-        include 'check_nullifiers_owner_batch.zkey'
-        include 'check_nullifiers_owner_batch-vkey.json'
-        include 'check_nullifiers_owner_batch_js/check_nullifiers_owner_batch.wasm'
+        include 'withdraw_nullifier.zkey'
+        include 'withdraw_nullifier-vkey.json'
+        include 'withdraw_nullifier_js/withdraw_nullifier.wasm'
+        include 'withdraw_nullifier_batch.zkey'
+        include 'withdraw_nullifier_batch-vkey.json'
+        include 'withdraw_nullifier_batch_js/withdraw_nullifier_batch.wasm'
     }
     into zetoZkpDir
 

core/go/internal/identityresolver/identityresolver_test.go

@@ -3,11 +3,64 @@ package identityresolver
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/kaleido-io/paladin/config/pkg/pldconf"
+	"github.com/kaleido-io/paladin/core/mocks/componentmocks"
+	"github.com/kaleido-io/paladin/toolkit/pkg/algorithms"
+	"github.com/kaleido-io/paladin/toolkit/pkg/cache"
+	"github.com/kaleido-io/paladin/toolkit/pkg/pldapi"
+	"github.com/kaleido-io/paladin/toolkit/pkg/verifiers"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )
 
+func TestResolveVerifier(t *testing.T) {
+	r := &identityResolver{}
+	_, err := r.ResolveVerifier(context.Background(), "something$bad", "bad algorithm", "bad type")
+	assert.ErrorContains(t, err, "PD020006: Locator string something$bad is invalid")
+
+	capacity := 100
+	config := &pldconf.CacheConfig{Capacity: &capacity}
+	r = &identityResolver{
+		nodeName:      "testnode",
+		verifierCache: cache.NewCache[string, string](config, config),
+		keyManager:    componentmocks.NewKeyManager(t),
+	}
+	waitChan := make(chan time.Time)
+	resolvedKey := &pldapi.KeyMappingAndVerifier{
+		Verifier: &pldapi.KeyVerifier{
+			Verifier: "0x1234567890abcdef",
+			Type:     "ETH_ADDRESS",
+		},
+	}
+	r.keyManager.(*componentmocks.KeyManager).On("ResolveKeyNewDatabaseTX", mock.Anything, mock.Anything, mock.Anything, mock.Anything).WaitUntil(waitChan).Return(resolvedKey, nil)
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
+	defer func() {
+		cancel()
+		close(waitChan)
+	}()
+
+	done := make(chan bool)
+	go func() {
+		_, err := r.ResolveVerifier(ctx, "something@testnode", algorithms.Curve_SECP256K1, verifiers.ETH_ADDRESS)
+		assert.ErrorContains(t, err, "PD010301: Context canceled")
+		done <- true
+	}()
+	<-done
+}
+
+func TestResolveVerifierAsync(t *testing.T) {
+	r := &identityResolver{}
+	resolved := func(ctx context.Context, verifier string) {
+		t.Logf("Resolved verifier: %s", verifier)
+	}
+	errhandler := func(ctx context.Context, err error) {
+		assert.ErrorContains(t, err, "PD020006: Locator string something$bad is invalid")
+	}
+	r.ResolveVerifierAsync(context.Background(), "something$bad", "bad algorithm", "bad type", resolved, errhandler)
+}
+
 func TestNewIdentityResolver(t *testing.T) {
 	capacity := 100
 	ctx := context.Background()

domains/integration-test/helpers/zeto_helper.go

@@ -18,14 +18,21 @@ package helpers
 import (
 	"context"
 	_ "embed"
+	"encoding/json"
 	"testing"
 
+	"github.com/kaleido-io/paladin/core/pkg/testbed"
 	"github.com/kaleido-io/paladin/domains/zeto/pkg/types"
+	"github.com/kaleido-io/paladin/toolkit/pkg/pldapi"
 	"github.com/kaleido-io/paladin/toolkit/pkg/rpcclient"
+	"github.com/kaleido-io/paladin/toolkit/pkg/solutils"
 	"github.com/kaleido-io/paladin/toolkit/pkg/tktypes"
 	"github.com/stretchr/testify/assert"
 )
 
+//go:embed abis/Zeto_Anon.json
+var ZetoAnonABIJSON []byte
+
 type ZetoHelper struct {
 	t       *testing.T
 	rpc     rpcclient.Client
@@ -82,14 +89,48 @@ func (n *ZetoHelperFungible) Transfer(ctx context.Context, to string, amount uin
 	}))
 }
 
-func (z *ZetoHelperFungible) Lock(ctx context.Context, delegate *tktypes.EthAddress, call []byte) *DomainTransactionHelper {
+func (n *ZetoHelper) TransferLocked(ctx context.Context, lockedUtxo *tktypes.HexUint256, delegate string, to string, amount uint64) *DomainTransactionHelper {
+	fn := types.ZetoFungibleABI.Functions()["transferLocked"]
+	return NewDomainTransactionHelper(ctx, n.t, n.rpc, n.Address, fn, toJSON(n.t, &types.FungibleTransferLockedParams{
+		LockedInputs: []*tktypes.HexUint256{lockedUtxo},
+		Delegate:     delegate,
+		Transfers: []*types.FungibleTransferParamEntry{
+			{
+				To:     to,
+				Amount: tktypes.Uint64ToUint256(amount),
+			},
+		},
+	}))
+}
+
+func (z *ZetoHelper) Lock(ctx context.Context, delegate *tktypes.EthAddress, amount int) *DomainTransactionHelper {
 	fn := types.ZetoFungibleABI.Functions()["lock"]
 	return NewDomainTransactionHelper(ctx, z.t, z.rpc, z.Address, fn, toJSON(z.t, &types.LockParams{
 		Delegate: delegate,
-		Call:     call,
+		Amount:   tktypes.Uint64ToUint256(uint64(amount)),
 	}))
 }
 
+func (z *ZetoHelper) DelegateLock(ctx context.Context, tb testbed.Testbed, lockedUtxo *tktypes.HexUint256, delegate *tktypes.EthAddress, sender string) {
+	txInput := map[string]any{
+		"utxos":    []string{lockedUtxo.String()},
+		"delegate": delegate.String(),
+		"data":     "0x",
+	}
+	txInputJson, _ := json.Marshal(txInput)
+	_, err := tb.ExecTransactionSync(ctx, &pldapi.TransactionInput{
+		TransactionBase: pldapi.TransactionBase{
+			Type:     pldapi.TransactionTypePublic.Enum(),
+			From:     sender,
+			To:       z.Address,
+			Function: "delegateLock",
+			Data:     txInputJson,
+		},
+		ABI: solutils.MustLoadBuild(ZetoAnonABIJSON).ABI,
+	})
+	assert.NoError(z.t, err)
+}
+
 // =============================================================================
 //
 //	NonFungible

domains/integration-test/pvp_test.go

@@ -428,8 +428,15 @@ func (s *pvpTestSuite) TestNotoForZeto() {
 	require.NoError(t, err)
 
 	log.L(ctx).Infof("Prepare the Zeto transfer")
-	transferZeto := zeto.Transfer(ctx, alice, 1).Prepare(bob)
-	zeto.Lock(ctx, tktypes.MustEthAddress(bobKey.Verifier.Verifier), transferZeto.EncodedCall).SignAndSend(bob).Wait()
+	zeto.Lock(ctx, tktypes.MustEthAddress(bobKey.Verifier.Verifier), 1).SignAndSend(bob).Wait()
+
+	jq := query.NewQueryBuilder().Limit(100).Equal("locked", true).Query()
+	lockedZetoCoins := findAvailableCoins(t, ctx, rpc, zetoDomain.Name(), zetoDomain.CoinSchemaID(), zeto.Address, jq, func(coins []*zetotypes.ZetoCoinState) bool {
+		return len(coins) >= 1
+	})
+	lockedZeto, _ := lockedZetoCoins[0].Data.Hash(ctx)
+
+	transferZeto := zeto.TransferLocked(ctx, lockedZeto, bobKey.Verifier.Verifier, alice, 1).Prepare(bob)
 
 	// TODO: this should actually be a Pente state transition
 	log.L(ctx).Infof("Prepare the trade execute")
@@ -488,7 +495,7 @@ func (s *pvpTestSuite) TestNotoForZeto() {
 		Unlock:   unlockParams,
 		Delegate: transferAtom.Address,
 	}).SignAndSend(alice).Wait()
-	zeto.Lock(ctx, transferAtom.Address, transferZeto.EncodedCall).SignAndSend(bob).Wait()
+	zeto.DelegateLock(ctx, tb, lockedZeto, transferAtom.Address, bobKey.Identifier)
 
 	log.L(ctx).Infof("Execute the atomic operation")
 	sent = transferAtom.Execute(ctx).SignAndSend(alice).Wait(5 * time.Second)
@@ -508,9 +515,9 @@ func (s *pvpTestSuite) TestNotoForZeto() {
 	zetoCoins = findAvailableCoins[zetotypes.ZetoCoinState](t, ctx, rpc, zetoDomain.Name(), zetoDomain.CoinSchemaID(), zeto.Address, nil)
 	require.NoError(t, err)
 	require.Len(t, zetoCoins, 2)
-	assert.Equal(t, int64(1), zetoCoins[0].Data.Amount.Int().Int64())
+	assert.Equal(t, int64(1), zetoCoins[1].Data.Amount.Int().Int64())
 	alicesKey := resolveZetoKey(t, ctx, rpc, zetoDomain.Name(), alice)
-	assert.Equal(t, alicesKey, zetoCoins[0].Data.Owner.String())
-	assert.Equal(t, int64(9), zetoCoins[1].Data.Amount.Int().Int64())
-	assert.Equal(t, bobsKey, zetoCoins[1].Data.Owner.String())
+	assert.Equal(t, alicesKey, zetoCoins[1].Data.Owner.String())
+	assert.Equal(t, int64(9), zetoCoins[0].Data.Amount.Int().Int64())
+	assert.Equal(t, bobsKey, zetoCoins[0].Data.Owner.String())
 }

domains/integration-test/zeto/config-for-deploy.yaml

@@ -11,30 +11,32 @@ contracts:
     - name: Groth16Verifier_AnonBatch
       abiAndBytecode:
         path: ./helpers/abis/Groth16Verifier_AnonBatch.json
-    - name: Groth16Verifier_CheckHashesValue
+    - name: Groth16Verifier_Deposit
       abiAndBytecode:
-        path: ./helpers/abis/Groth16Verifier_CheckHashesValue.json
-    - name: Groth16Verifier_CheckInputsOutputsValue
+        path: ./helpers/abis/Groth16Verifier_Deposit.json
+    - name: Groth16Verifier_Withdraw
       abiAndBytecode:
-        path: ./helpers/abis/Groth16Verifier_CheckInputsOutputsValue.json
-    - name: Groth16Verifier_CheckInputsOutputsValueBatch
+        path: ./helpers/abis/Groth16Verifier_Withdraw.json
+    - name: Groth16Verifier_WithdrawBatch
       abiAndBytecode:
-        path: ./helpers/abis/Groth16Verifier_CheckInputsOutputsValueBatch.json
-    - name: Groth16Verifier_CheckUtxosOwner
-      abiAndBytecode:
-        path: ./helpers/abis/Groth16Verifier_CheckUtxosOwner.json
-    - name: Groth16Verifier_CheckUtxosOwnerBatch
-      abiAndBytecode:
-        path: ./helpers/abis/Groth16Verifier_CheckUtxosOwnerBatch.json
+        path: ./helpers/abis/Groth16Verifier_WithdrawBatch.json
     - name: Zeto_Anon
       verifier: Groth16Verifier_Anon
       batchVerifier: Groth16Verifier_AnonBatch
-      depositVerifier: Groth16Verifier_CheckHashesValue
-      withdrawVerifier: Groth16Verifier_CheckInputsOutputsValue
-      batchWithdrawVerifier: Groth16Verifier_CheckInputsOutputsValueBatch
-      lockVerifier: Groth16Verifier_CheckUtxosOwner
-      batchLockVerifier: Groth16Verifier_CheckUtxosOwnerBatch
-      circuitId: anon
+      depositVerifier: Groth16Verifier_Deposit
+      withdrawVerifier: Groth16Verifier_Withdraw
+      batchWithdrawVerifier: Groth16Verifier_WithdrawBatch
+      lockVerifier: Groth16Verifier_Anon
+      batchLockVerifier: Groth16Verifier_AnonBatch
+      circuits:
+        deposit:
+          name: deposit
+        withdraw:
+          name: withdraw
+        transfer:
+          name: anon
+        transferLocked:
+          name: anon
       cloneable: true
       abiAndBytecode:
         path: ./helpers/abis/Zeto_Anon.json

domains/zeto/build.gradle

@@ -24,15 +24,15 @@ ext {
     goFilesE2E = fileTree(".") {
         include "integration-test/**/*.go"
     }
-    targetCoverage = 92.0
+    targetCoverage = 92.5 // temporary
     maxCoverageBarGap = 1
     coveragePackages = [
         "github.com/kaleido-io/paladin/domains/zeto/internal/...",
         "github.com/kaleido-io/paladin/domains/zeto/pkg/types",
         "github.com/kaleido-io/paladin/domains/zeto/pkg/zetosigner",
     ]
 
-    zetoVersion = "v0.0.11"
+    zetoVersion = "v0.0.12"
     zetoHost = "hyperledger-labs"
     zkpOut = "${projectDir}/zkp"
     toolsOut = "${projectDir}/tools"