sdk executor and e2e tests

example/bearer_auth/main.go

@@ -0,0 +1,129 @@
+package main
+
+import (
+	"context"
+	"log"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+	cryptocdc "github.com/cosmos/cosmos-sdk/crypto/codec"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	prototypes "github.com/cosmos/gogoproto/types"
+
+	"github.com/sourcenetwork/sourcehub/sdk"
+	"github.com/sourcenetwork/sourcehub/x/acp/bearer_token"
+	"github.com/sourcenetwork/sourcehub/x/acp/did"
+	acptypes "github.com/sourcenetwork/sourcehub/x/acp/types"
+)
+
+func main() {
+	ctx := context.Background()
+
+	client, err := sdk.NewClient()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	txBuilder, err := sdk.NewTxBuilder(
+		sdk.WithSDKClient(client),
+		sdk.WithChainID("sourcehub-dev"),
+	)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	reg := cdctypes.NewInterfaceRegistry()
+	cryptocdc.RegisterInterfaces(reg)
+	cdc := codec.NewProtoCodec(reg)
+	keyring, err := keyring.New("sourcehub", keyring.BackendTest, "~/.sourcehub", nil, cdc)
+	if err != nil {
+		log.Fatalf("could not load keyring: %v", err)
+	}
+
+	txSigner, err := sdk.NewTxSignerFromKeyringKey(keyring, "validator")
+	if err != nil {
+		log.Fatalf("could not load keyring: %v", err)
+	}
+
+	policy := `
+name: test
+resources:
+  resource:
+    relations:
+      owner:
+        types:
+          - actor
+`
+
+	msgSet := sdk.MsgSet{}
+	policyMapper := msgSet.WithCreatePolicy(acptypes.NewMsgCreatePolicyNow(txSigner.GetAccAddress(), policy, acptypes.PolicyMarshalingType_SHORT_YAML))
+	tx, err := txBuilder.Build(ctx, txSigner, &msgSet)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	resp, err := client.BroadcastTx(ctx, tx)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	result, err := client.AwaitTx(ctx, resp.TxHash)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if result.Error() != nil {
+		log.Fatalf("Tx failed: %v", result.Error())
+	}
+
+	policyResponse, err := policyMapper.Map(result.TxPayload())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Printf("policy created: %v", policyResponse.Policy.Id)
+
+	alice, signer, err := did.ProduceDID()
+	if err != nil {
+		log.Fatalf("could not generate alice: %v", err)
+	}
+	log.Printf("alice's DID: %v", alice)
+
+	token := bearer_token.NewBearerTokenNow(alice, txSigner.GetAccAddress())
+	jws, err := token.ToJWS(signer)
+	if err != nil {
+		log.Fatalf("could not produce Bearer for alice: %v", err)
+	}
+
+	log.Printf("alice's raw token: %v", token)
+	log.Printf("alice's JWS: %v", jws)
+
+	bearerCmd := acptypes.MsgBearerPolicyCmd{
+		Creator:      txSigner.GetAccAddress(),
+		BearerToken:  jws,
+		PolicyId:     policyResponse.Policy.Id,
+		Cmd:          acptypes.NewRegisterObjectCmd(acptypes.NewObject("resource", "foo")),
+		CreationTime: prototypes.TimestampNow(),
+	}
+
+	log.Printf("Bearer Cmd: %v", bearerCmd)
+	msgSet = sdk.MsgSet{}
+	msgSet.WithBearerPolicyCmd(&bearerCmd)
+	tx, err = txBuilder.Build(ctx, txSigner, &msgSet)
+	if err != nil {
+		log.Fatal(err)
+	}
+	resp, err = client.BroadcastTx(ctx, tx)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	result, err = client.AwaitTx(ctx, resp.TxHash)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if result.Error() != nil {
+		log.Fatalf("Tx failed: %v", result.Error())
+	}
+
+	log.Printf("object registered")
+}

sdk/msgset.go

@@ -76,3 +76,8 @@ func (b *MsgSet) WithBearerPolicyCmd(msg *acptypes.MsgBearerPolicyCmd) Mapper[*a
 	idx := b.addMsg(msg)
 	return newMapper(idx, &acptypes.MsgBearerPolicyCmdResponse{})
 }
+
+func (b *MsgSet) WithDirectPolicyCmd(msg *acptypes.MsgDirectPolicyCmd) Mapper[*acptypes.MsgDirectPolicyCmdResponse] {
+	idx := b.addMsg(msg)
+	return newMapper(idx, &acptypes.MsgDirectPolicyCmdResponse{})
+}

sdk/sdk.go

@@ -2,6 +2,7 @@ package sdk
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"log"
 
@@ -181,3 +182,17 @@ func (c *Client) AwaitTx(ctx context.Context, txHash string) (*TxExecResult, err
 
 	return newTxExecResult(result), nil
 }
+
+func (c *Client) GetTx(ctx context.Context, txHash string) (*TxExecResult, error) {
+	bytes, err := hex.DecodeString(txHash)
+	if err != nil {
+		return nil, fmt.Errorf("invalid tx hash: %v", err)
+	}
+
+	txRPC, err := c.CometBFTRPCClient().Tx(ctx, bytes, false)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get tx: %v", err)
+	}
+
+	return newTxExecResult(txRPC), nil
+}

sdk/tx.go

@@ -54,7 +54,7 @@ func NewTxBuilder(opts ...TxBuilderOpt) (TxBuilder, error) {
 	}
 
 	if builder.authClient == nil {
-		return TxBuilder{}, fmt.Errorf("TxBuilder: Auth GRPC Client is required: use either WithAuthQueryClient or WithClientConn to set it")
+		return TxBuilder{}, fmt.Errorf("TxBuilder: Auth GRPC Client is required: use either WithAuthQueryClient or WithSDKClient to set it")
 	}
 
 	return builder, nil

sdk/types.go

@@ -10,6 +10,7 @@ func newTxExecResult(result *rpctypes.ResultTx) *TxExecResult {
 	var err error
 	if result.TxResult.Code != 0 {
 		err = fmt.Errorf("%v: %v", ErrTxFailed, result.TxResult.Log)
+		result = nil
 	}
 
 	return &TxExecResult{

tests/e2e/sdk/sdk_test.go

@@ -2,7 +2,6 @@ package sdk
 
 import (
 	"context"
-	"encoding/hex"
 	"testing"
 
 	"github.com/sourcenetwork/sourcehub/sdk"
@@ -47,15 +46,10 @@ name: test policy
 
 	network.Network.WaitForNextBlock()
 
-	bytes, _ := hex.DecodeString(response.TxHash)
-	txRPC, err := client.CometBFTRPCClient().Tx(ctx, bytes, false)
+	result, err := network.Client.GetTx(ctx, response.TxHash)
 	require.NoError(t, err)
+	require.NoError(t, result.Error())
 
-	//execResult, err := client.AwaitTx(ctx, response.TxHash)
-	//require.NoError(t, err)
-	//require.NoError(t, execResult.Error())
-
-	msgResponse, err := mapper.Map(txRPC)
+	_, err = mapper.Map(result.TxPayload())
 	require.NoError(t, err)
-	require.Equal(t, "", msgResponse.Policy.Id)
 }

tests/integration/acp/ctx.go

@@ -22,30 +22,26 @@ type TestState struct {
 	PolicyCreator string
 }
 
-func NewTestCtxFromConfig(t *testing.T, config TestConfig) (*TestCtx, error) {
-	baseCtx, executor, err := NewExecutor(config.ExecutorStrategy)
-	if err != nil {
-		return nil, err
-	}
+func NewTestCtxFromConfig(t *testing.T, config TestConfig) *TestCtx {
+	baseCtx, executor := NewExecutor(t, config.ExecutorStrategy)
 
 	root := MustNewSourceHubActorFromName("root")
-	_, err = executor.GetOrCreateAccountFromActor(baseCtx, root)
-	if err != nil {
-		return nil, err
-	}
-
 	ctx := &TestCtx{
 		Ctx:          baseCtx,
 		T:            t,
 		TxSigner:     root,
-		Timestamp:    time.Date(2024, 6, 21, 12, 10, 00, 0, time.UTC),
-		TokenIssueTs: time.Date(2024, 6, 21, 12, 00, 00, 0, time.UTC),
+		Timestamp:    time.Now(),
+		TokenIssueTs: time.Now(),
 		Executor:     executor,
 		Strategy:     config.AuthStrategy,
 		ActorType:    config.ActorType,
 		LogicalClock: &logicalClockImpl{},
 	}
-	return ctx, nil
+
+	_, err := executor.GetOrCreateAccountFromActor(ctx, root)
+	require.NoError(t, err)
+
+	return ctx
 }
 
 type TestCtx struct {
@@ -67,8 +63,7 @@ type TestCtx struct {
 func NewTestCtx(t *testing.T) *TestCtx {
 	initTest()
 	config := MustNewTestConfigFromEnv()
-	ctx, err := NewTestCtxFromConfig(t, config)
-	require.NoError(t, err)
+	ctx := NewTestCtxFromConfig(t, config)
 	return ctx
 }
 
@@ -84,7 +79,7 @@ func (c *TestCtx) GetActor(alias string) *TestActor {
 		return MustNewED25519ActorFromName(alias)
 	case Actor_SECP256K1:
 		acc := MustNewSourceHubActorFromName(alias)
-		_, err := c.Executor.GetOrCreateAccountFromActor(c.Ctx, acc)
+		_, err := c.Executor.GetOrCreateAccountFromActor(c, acc)
 		require.NoError(c.T, err)
 		return acc
 	default:
@@ -101,3 +96,7 @@ func (c *TestCtx) GetSourceHubAccount(alias string) *TestActor {
 func (c *TestCtx) GetParams() types.Params {
 	return types.NewParams()
 }
+
+func (c *TestCtx) Cleanup() {
+	c.Executor.Cleanup()
+}