Mirroristas/planetmint-go
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint-go.git synced 2025-03-30 15:08:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor clients (#486)

Browse Source 
* refactor(clients): into sub-packages
* refactor(clients): improve readability
  - add some error cases
* refactor(client): align naming with rddl claim client
  - rddl claim client is `RCClient`

Signed-off-by: Julian Strobl <jmastr@mailbox.org>
This commit is contained in:
Julian Strobl 2024-11-21 10:13:42 +01:00 committed by GitHub
parent 3cf3c67e08
commit 8e87cd77db
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 152 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
clients/claim/client.go Normal file
View File

@ -0,0 +1,48 @@
package claim
import (
"context"
"errors"
"fmt"
"net/http"
"github.com/planetmint/planetmint-go/config"
"github.com/rddl-network/rddl-claim-service/client"
"github.com/rddl-network/rddl-claim-service/types"
)
var (
RCClient client.IRCClient
)
func lazyLoad() client.IRCClient {
if RCClient != nil {
return RCClient
}
cfg := config.GetConfig()
RCClient = client.NewRCClient(cfg.ClaimHost, &http.Client{})
return RCClient
}
func PostClaim(ctx context.Context, beneficiary string, amount uint64, id uint64) (txID string, err error) {
if beneficiary == "" {
return txID, errors.New("beneficiary cannot be empty")
}
if amount == 0 {
return txID, errors.New("amount must be greater than 0")
}
req := types.PostClaimRequest{
Beneficiary: beneficiary,
Amount: amount,
ClaimID: int(id),
}
client := lazyLoad()
resp, err := client.PostClaim(ctx, req)
if err != nil {
return txID, fmt.Errorf("failed to post claim: %w", err)
}
return resp.TxID, nil
}

30
clients/claim_client.go
View File

@ -1,30 +0,0 @@
package clients
import (
"context"
"net/http"
"github.com/planetmint/planetmint-go/config"
"github.com/rddl-network/rddl-claim-service/client"
"github.com/rddl-network/rddl-claim-service/types"
)
var ClaimServiceClient client.IRCClient
func lazyLoad() client.IRCClient {
if ClaimServiceClient != nil {
return ClaimServiceClient
}
cfg := config.GetConfig()
ClaimServiceClient = client.NewRCClient(cfg.ClaimHost, &http.Client{})
return ClaimServiceClient
}
func PostClaim(ctx context.Context, beneficiary string, amount uint64, id uint64) (txID string, err error) {
client := lazyLoad()
res, err := client.PostClaim(ctx, types.PostClaimRequest{Beneficiary: beneficiary, Amount: amount, ClaimID: int(id)})
if err != nil {
return
}
return res.TxID, nil
}

55
clients/shamir/coordinator/client.go Normal file
View File

@ -0,0 +1,55 @@
package coordinator
import (
"context"
"errors"
"github.com/planetmint/planetmint-go/config"
"github.com/rddl-network/go-utils/tls"
"github.com/rddl-network/shamir-coordinator-service/client"
)
var (
SCClient client.ISCClient
)
func lazyLoad() client.ISCClient {
if SCClient != nil {
return SCClient
}
cfg := config.GetConfig()
httpsClient, err := tls.Get2WayTLSClient(cfg.CertsPath)
if err != nil {
err := errors.New("fatal error setting up mutual tls client for shamir coordinator")
panic(err)
}
SCClient = client.NewSCClient(cfg.IssuerHost, httpsClient)
return SCClient
}
func SendTokens(ctx context.Context, recipient string, amount string, asset string) (txID string, err error) {
client := lazyLoad()
resp, err := client.SendTokens(ctx, recipient, amount, asset)
if err != nil {
return
}
return resp.TxID, nil
}
func ReIssueAsset(ctx context.Context, asset string, amount string) (txID string, err error) {
client := lazyLoad()
resp, err := client.ReIssueAsset(ctx, asset, amount)
if err != nil {
return
}
return resp.TxID, nil
}
func IssueNFTAsset(ctx context.Context, name string, machineAddress string, domain string) (assetID string, contract string, hexTx string, err error) {
client := lazyLoad()
resp, err := client.IssueMachineNFT(ctx, name, machineAddress, domain)
if err != nil {
return
}
return resp.Asset, resp.Contract, resp.HexTX, nil
}

52
clients/shamir_coordinator_client.go
View File

@ -1,52 +0,0 @@
package clients
import (
"context"
"log"
"github.com/planetmint/planetmint-go/config"
"github.com/rddl-network/go-utils/tls"
"github.com/rddl-network/shamir-coordinator-service/client"
)
var ShamirCoordinatorServiceClient client.IShamirCoordinatorClient
func lazyLoadShamirCoordinatorClient() client.IShamirCoordinatorClient {
if ShamirCoordinatorServiceClient != nil {
return ShamirCoordinatorServiceClient
}
cfg := config.GetConfig()
httpsClient, err := tls.Get2WayTLSClient(cfg.CertsPath)
if err != nil {
defer log.Fatal("fatal error setting up mutual tls client for shamir coordinator")
}
ShamirCoordinatorServiceClient = client.NewShamirCoordinatorClient(cfg.IssuerHost, httpsClient)
return ShamirCoordinatorServiceClient
}
func SendTokens(ctx context.Context, recipient string, amount string, asset string) (txID string, err error) {
client := lazyLoadShamirCoordinatorClient()
res, err := client.SendTokens(ctx, recipient, amount, asset)
if err != nil {
return
}
return res.TxID, nil
}
func ReIssueAsset(ctx context.Context, asset string, amount string) (txID string, err error) {
client := lazyLoadShamirCoordinatorClient()
res, err := client.ReIssueAsset(ctx, asset, amount)
if err != nil {
return
}
return res.TxID, nil
}
func IssueNFTAsset(ctx context.Context, name string, machineAddress string, domain string) (assetID string, contract string, hexTx string, err error) {
client := lazyLoadShamirCoordinatorClient()
res, err := client.IssueMachineNFT(ctx, name, machineAddress, domain)
if err != nil {
return
}
return res.Asset, res.Contract, res.HexTX, nil
}

2
go.mod
View File

@ -29,7 +29,7 @@ require (
github.com/rddl-network/rddl-claim-service v0.3.2
github.com/rddl-network/rddl-claim-service/client v0.0.6
github.com/rddl-network/shamir-coordinator-service v0.7.7
github.com/rddl-network/shamir-coordinator-service/client v0.0.10
github.com/rddl-network/shamir-coordinator-service/client v0.1.0
github.com/spf13/cast v1.6.0
github.com/spf13/cobra v1.7.0
github.com/spf13/pflag v1.0.5

4
go.sum
View File

@ -943,8 +943,8 @@ github.com/rddl-network/rddl-claim-service/client v0.0.6 h1:GLqj8RMozFPVUvPQGRLB
github.com/rddl-network/rddl-claim-service/client v0.0.6/go.mod h1:CFAfupB5XogWqVsb6ndsLU97feGs4oUqlGI4WRff3zU=
github.com/rddl-network/shamir-coordinator-service v0.7.7 h1:hszDZZnqBdeiOEBWlnSK2lKIJEbWclX6cchYDazpvIU=
github.com/rddl-network/shamir-coordinator-service v0.7.7/go.mod h1:g3JnQlzKQWtnp4ZA7VtD/4N0GKpFWrW0ANHqged7M/g=
github.com/rddl-network/shamir-coordinator-service/client v0.0.10 h1:M1lxVprsfyCLK+1LLGhAW4mne129ey23n3VpA9Xz2Kg=
github.com/rddl-network/shamir-coordinator-service/client v0.0.10/go.mod h1:dhxYyhmU71iv32WqS6S+6Pm/Lsb5/d0KVn2MVTq5Jfk=
github.com/rddl-network/shamir-coordinator-service/client v0.1.0 h1:o8oZzvGSAyTto5hSkNRr2KvilhwWiqGbL70HRg4aKhA=
github.com/rddl-network/shamir-coordinator-service/client v0.1.0/go.mod h1:dhxYyhmU71iv32WqS6S+6Pm/Lsb5/d0KVn2MVTq5Jfk=
github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=

52
testutil/mocks/shamir_coordinator_client_mock.go
View File

@ -12,31 +12,31 @@ import (
"github.com/rddl-network/shamir-coordinator-service/types"
)
// MockIShamirCoordinatorClient is a mock of IShamirCoordinatorClient interface.
type MockIShamirCoordinatorClient struct {
// MockISCClient is a mock of ISCClient interface.
type MockISCClient struct {
ctrl *gomock.Controller
recorder *MockIShamirCoordinatorClientMockRecorder
recorder *MockISCClientMockRecorder
}
// MockIShamirCoordinatorClientMockRecorder is the mock recorder for MockIShamirCoordinatorClient.
type MockIShamirCoordinatorClientMockRecorder struct {
mock *MockIShamirCoordinatorClient
// MockISCClientMockRecorder is the mock recorder for MockISCClient.
type MockISCClientMockRecorder struct {
mock *MockISCClient
}
// NewMockIShamirCoordinatorClient creates a new mock instance.
func NewMockIShamirCoordinatorClient(ctrl *gomock.Controller) *MockIShamirCoordinatorClient {
mock := &MockIShamirCoordinatorClient{ctrl: ctrl}
mock.recorder = &MockIShamirCoordinatorClientMockRecorder{mock}
// NewMockISCClient creates a new mock instance.
func NewMockISCClient(ctrl *gomock.Controller) *MockISCClient {
mock := &MockISCClient{ctrl: ctrl}
mock.recorder = &MockISCClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockIShamirCoordinatorClient) EXPECT() *MockIShamirCoordinatorClientMockRecorder {
func (m *MockISCClient) EXPECT() *MockISCClientMockRecorder {
return m.recorder
}
// GetMnemonics mocks base method.
func (m *MockIShamirCoordinatorClient) GetMnemonics(ctx context.Context) (types.MnemonicsResponse, error) {
func (m *MockISCClient) GetMnemonics(ctx context.Context) (types.MnemonicsResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetMnemonics", ctx)
ret0, _ := ret[0].(types.MnemonicsResponse)
@ -45,13 +45,13 @@ func (m *MockIShamirCoordinatorClient) GetMnemonics(ctx context.Context) (types.
}
// GetMnemonics indicates an expected call of GetMnemonics.
func (mr *MockIShamirCoordinatorClientMockRecorder) GetMnemonics(ctx interface{}) *gomock.Call {
func (mr *MockISCClientMockRecorder) GetMnemonics(ctx interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMnemonics", reflect.TypeOf((*MockIShamirCoordinatorClient)(nil).GetMnemonics), ctx)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMnemonics", reflect.TypeOf((*MockISCClient)(nil).GetMnemonics), ctx)
}
// IssueMachineNFT mocks base method.
func (m *MockIShamirCoordinatorClient) IssueMachineNFT(ctx context.Context, name, machineAddress, domain string) (types.IssueMachineNFTResponse, error) {
func (m *MockISCClient) IssueMachineNFT(ctx context.Context, name, machineAddress, domain string) (types.IssueMachineNFTResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IssueMachineNFT", ctx, name, machineAddress, domain)
ret0, _ := ret[0].(types.IssueMachineNFTResponse)
@ -60,13 +60,13 @@ func (m *MockIShamirCoordinatorClient) IssueMachineNFT(ctx context.Context, name
}
// IssueMachineNFT indicates an expected call of IssueMachineNFT.
func (mr *MockIShamirCoordinatorClientMockRecorder) IssueMachineNFT(ctx, name, machineAddress, domain interface{}) *gomock.Call {
func (mr *MockISCClientMockRecorder) IssueMachineNFT(ctx, name, machineAddress, domain interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IssueMachineNFT", reflect.TypeOf((*MockIShamirCoordinatorClient)(nil).IssueMachineNFT), ctx, name, machineAddress, domain)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IssueMachineNFT", reflect.TypeOf((*MockISCClient)(nil).IssueMachineNFT), ctx, name, machineAddress, domain)
}
// PostMnemonics mocks base method.
func (m *MockIShamirCoordinatorClient) PostMnemonics(ctx context.Context, secret string) error {
func (m *MockISCClient) PostMnemonics(ctx context.Context, secret string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PostMnemonics", ctx, secret)
ret0, _ := ret[0].(error)
@ -74,13 +74,13 @@ func (m *MockIShamirCoordinatorClient) PostMnemonics(ctx context.Context, secret
}
// PostMnemonics indicates an expected call of PostMnemonics.
func (mr *MockIShamirCoordinatorClientMockRecorder) PostMnemonics(ctx, secret interface{}) *gomock.Call {
func (mr *MockISCClientMockRecorder) PostMnemonics(ctx, secret interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMnemonics", reflect.TypeOf((*MockIShamirCoordinatorClient)(nil).PostMnemonics), ctx, secret)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMnemonics", reflect.TypeOf((*MockISCClient)(nil).PostMnemonics), ctx, secret)
}
// ReIssueAsset mocks base method.
func (m *MockIShamirCoordinatorClient) ReIssueAsset(ctx context.Context, asset, amount string) (types.ReIssueResponse, error) {
func (m *MockISCClient) ReIssueAsset(ctx context.Context, asset, amount string) (types.ReIssueResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReIssueAsset", ctx, asset, amount)
ret0, _ := ret[0].(types.ReIssueResponse)
@ -89,13 +89,13 @@ func (m *MockIShamirCoordinatorClient) ReIssueAsset(ctx context.Context, asset,
}
// ReIssueAsset indicates an expected call of ReIssueAsset.
func (mr *MockIShamirCoordinatorClientMockRecorder) ReIssueAsset(ctx, asset, amount interface{}) *gomock.Call {
func (mr *MockISCClientMockRecorder) ReIssueAsset(ctx, asset, amount interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReIssueAsset", reflect.TypeOf((*MockIShamirCoordinatorClient)(nil).ReIssueAsset), ctx, asset, amount)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReIssueAsset", reflect.TypeOf((*MockISCClient)(nil).ReIssueAsset), ctx, asset, amount)
}
// SendTokens mocks base method.
func (m *MockIShamirCoordinatorClient) SendTokens(ctx context.Context, recipient, amount, asset string) (types.SendTokensResponse, error) {
func (m *MockISCClient) SendTokens(ctx context.Context, recipient, amount, asset string) (types.SendTokensResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendTokens", ctx, recipient, amount, asset)
ret0, _ := ret[0].(types.SendTokensResponse)
@ -104,7 +104,7 @@ func (m *MockIShamirCoordinatorClient) SendTokens(ctx context.Context, recipient
}
// SendTokens indicates an expected call of SendTokens.
func (mr *MockIShamirCoordinatorClientMockRecorder) SendTokens(ctx, recipient, amount, asset interface{}) *gomock.Call {
func (mr *MockISCClientMockRecorder) SendTokens(ctx, recipient, amount, asset interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTokens", reflect.TypeOf((*MockIShamirCoordinatorClient)(nil).SendTokens), ctx, recipient, amount, asset)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTokens", reflect.TypeOf((*MockISCClient)(nil).SendTokens), ctx, recipient, amount, asset)
}

9
testutil/network/loader.go
View File

@ -16,7 +16,8 @@ import (
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
"github.com/golang/mock/gomock"
"github.com/planetmint/planetmint-go/app"
"github.com/planetmint/planetmint-go/clients"
"github.com/planetmint/planetmint-go/clients/claim"
"github.com/planetmint/planetmint-go/clients/shamir/coordinator"
"github.com/planetmint/planetmint-go/monitor"
monitormocks "github.com/planetmint/planetmint-go/monitor/mocks"
clientmocks "github.com/planetmint/planetmint-go/testutil/mocks"
@ -55,9 +56,9 @@ func Load(t *testing.T, configs ...Config) *Network {
claimMock.EXPECT().PostClaim(gomock.Any(), gomock.Any()).AnyTimes().Return(rcctypes.PostClaimResponse{
TxID: "0000000000000000000000000000000000000000000000000000000000000000",
}, nil)
clients.ClaimServiceClient = claimMock
claim.RCClient = claimMock
shamirMock := clientmocks.NewMockIShamirCoordinatorClient(ctrl)
shamirMock := clientmocks.NewMockISCClient(ctrl)
shamirMock.EXPECT().SendTokens(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(scctypes.SendTokensResponse{
TxID: "7add40beb27df701e02ee85089c5bc0021bc813823fedb5f1dcb5debda7f3da9",
}, nil)
@ -69,7 +70,7 @@ func Load(t *testing.T, configs ...Config) *Network {
Contract: `{"entity":{"domain":"testnet-assets.rddl.io"}, "issuer_pubkey":"02", "machine_addr":"addr","name":"machine","precicion":8,"version":1}`,
Asset: "0000000000000000000000000000000000000000000000000000000000000000",
}, nil)
clients.ShamirCoordinatorServiceClient = shamirMock
coordinator.SCClient = shamirMock
// enable application logger in tests
appLogger := util.GetAppLogger()

4
util/machine_nft.go
View File

@ -12,7 +12,7 @@ import (
errorsmod "cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/planetmint/planetmint-go/clients"
"github.com/planetmint/planetmint-go/clients/shamir/coordinator"
"github.com/planetmint/planetmint-go/x/machine/types"
)
@ -33,7 +33,7 @@ func IssueMachineNFT(goCtx context.Context, machine *types.Machine, scheme strin
// asset registration is in order to have the contact published
var notarizedAsset types.LiquidAsset
notarizedAsset.Registered = true
assetID, contract, hex, err := clients.IssueNFTAsset(goCtx, machine.Name, machine.Address, domain)
assetID, contract, hex, err := coordinator.IssueNFTAsset(goCtx, machine.Name, machine.Address, domain)
if err != nil {
GetAppLogger().Error(ctx, err, "")
return err

6
util/machine_nft_test.go
View File

@ -10,7 +10,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/golang/mock/gomock"
"github.com/planetmint/planetmint-go/clients"
"github.com/planetmint/planetmint-go/clients/shamir/coordinator"
"github.com/planetmint/planetmint-go/config"
"github.com/planetmint/planetmint-go/testutil/keeper"
clientmocks "github.com/planetmint/planetmint-go/testutil/mocks"
@ -55,13 +55,13 @@ func TestMachineNFTIssuance(t *testing.T) {
t.Setenv(config.ValAddr, "plmnt10mq5nj8jhh27z7ejnz2ql3nh0qhzjnfvy50877")
ctrl := gomock.NewController(t)
elements.Client = &elementsmocks.MockClient{}
shamirMock := clientmocks.NewMockIShamirCoordinatorClient(ctrl)
shamirMock := clientmocks.NewMockISCClient(ctrl)
shamirMock.EXPECT().IssueMachineNFT(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(scctypes.IssueMachineNFTResponse{
HexTX: "0000000000000000000000000000000000000000000000000000000000000000",
Contract: `{"entity":{"domain":"testnet-assets.rddl.io"}, "issuer_pubkey":"02", "machine_addr":"addr","name":"machine","precicion":8,"version":1}`,
Asset: "0000000000000000000000000000000000000000000000000000000000000000",
}, nil)
clients.ShamirCoordinatorServiceClient = shamirMock
coordinator.SCClient = shamirMock
util.RegisterAssetServiceHTTPClient = &mocks.MockClient{}
_, ctx := keeper.MachineKeeper(t)
params := types.DefaultParams()

12
x/dao/keeper/msg_server_distribution_request.go
View File

@ -5,7 +5,7 @@ import (
errorsmod "cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/planetmint/planetmint-go/clients"
"github.com/planetmint/planetmint-go/clients/shamir/coordinator"
"github.com/planetmint/planetmint-go/errormsg"
"github.com/planetmint/planetmint-go/util"
"github.com/planetmint/planetmint-go/x/dao/types"
@ -43,23 +43,23 @@ func (k msgServer) DistributionRequest(goCtx context.Context, msg *types.MsgDist
reissuanceAsset := k.GetParams(ctx).ReissuanceAsset
util.GetAppLogger().Info(ctx, distributionRequestTag+"entering asset distribution mode")
// issue 5 distributions:
earlyInvestorTx, err := clients.SendTokens(goCtx, msg.Distribution.EarlyInvAddr, msg.Distribution.EarlyInvAmount, reissuanceAsset)
earlyInvestorTx, err := coordinator.SendTokens(goCtx, msg.Distribution.EarlyInvAddr, msg.Distribution.EarlyInvAmount, reissuanceAsset)
if err != nil {
util.GetAppLogger().Error(ctx, err, distributionRequestTag+"could not distribute asset to early investors")
}
investorTx, err := clients.SendTokens(goCtx, msg.Distribution.InvestorAddr, msg.Distribution.InvestorAmount, reissuanceAsset)
investorTx, err := coordinator.SendTokens(goCtx, msg.Distribution.InvestorAddr, msg.Distribution.InvestorAmount, reissuanceAsset)
if err != nil {
util.GetAppLogger().Error(ctx, err, distributionRequestTag+"could not distribute asset to investors")
}
strategicTx, err := clients.SendTokens(goCtx, msg.Distribution.StrategicAddr, msg.Distribution.StrategicAmount, reissuanceAsset)
strategicTx, err := coordinator.SendTokens(goCtx, msg.Distribution.StrategicAddr, msg.Distribution.StrategicAmount, reissuanceAsset)
if err != nil {
util.GetAppLogger().Error(ctx, err, distributionRequestTag+"could not distribute asset to strategic investments")
}
popTx, err := clients.SendTokens(goCtx, msg.Distribution.PopAddr, msg.Distribution.PopAmount, reissuanceAsset)
popTx, err := coordinator.SendTokens(goCtx, msg.Distribution.PopAddr, msg.Distribution.PopAmount, reissuanceAsset)
if err != nil {
util.GetAppLogger().Error(ctx, err, distributionRequestTag+"could not distribute asset to PoP")
}
daoTx, err := clients.SendTokens(goCtx, msg.Distribution.DaoAddr, msg.Distribution.DaoAmount, reissuanceAsset)
daoTx, err := coordinator.SendTokens(goCtx, msg.Distribution.DaoAddr, msg.Distribution.DaoAmount, reissuanceAsset)
if err != nil {
util.GetAppLogger().Error(ctx, err, distributionRequestTag+"could not distribute asset to DAO")
}

4
x/dao/keeper/msg_server_redeem_claim.go
View File

@ -7,7 +7,7 @@ import (
errorsmod "cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/planetmint/planetmint-go/clients"
"github.com/planetmint/planetmint-go/clients/claim"
"github.com/planetmint/planetmint-go/util"
"github.com/planetmint/planetmint-go/x/dao/types"
)
@ -129,7 +129,7 @@ func (k msgServer) burnClaimAmount(ctx sdk.Context, addr sdk.AccAddress, burnCoi
func postClaimToService(goCtx context.Context, beneficiary string, amount uint64, id uint64) {
ctx := sdk.UnwrapSDKContext(goCtx)
util.GetAppLogger().Info(ctx, fmt.Sprintf("Issuing RDDL claim: %s/%d", beneficiary, id))
txID, err := clients.PostClaim(goCtx, beneficiary, amount, id)
txID, err := claim.PostClaim(goCtx, beneficiary, amount, id)
if err != nil {
util.GetAppLogger().Error(ctx, err, createRedeemClaimTag+"could not issue claim to beneficiary: "+beneficiary)
}

4
x/dao/keeper/msg_server_reissue_rddl_proposal.go
View File

@ -6,7 +6,7 @@ import (
errorsmod "cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/planetmint/planetmint-go/clients"
"github.com/planetmint/planetmint-go/clients/shamir/coordinator"
"github.com/planetmint/planetmint-go/errormsg"
"github.com/planetmint/planetmint-go/util"
"github.com/planetmint/planetmint-go/x/dao/types"
@ -44,7 +44,7 @@ func (k msgServer) ReissueRDDLProposal(goCtx context.Context, msg *types.MsgReis
util.GetAppLogger().Info(ctx, reissueTag+"asset: "+msg.GetCommand())
cmdArgs := strings.Split(msg.Command, " ")
txID, err := clients.ReIssueAsset(goCtx, cmdArgs[1], cmdArgs[2])
txID, err := coordinator.ReIssueAsset(goCtx, cmdArgs[1], cmdArgs[2])
if err != nil {
util.GetAppLogger().Error(ctx, err, reissueTag+"asset reissuance failed")
}