Communicate additional send and buy module limits to client (#61)

Author: jeffyanta

go.mod

@@ -6,7 +6,7 @@ require (
 	firebase.google.com/go/v4 v4.8.0
 	github.com/aws/aws-sdk-go-v2 v0.17.0
 	github.com/bits-and-blooms/bloom/v3 v3.1.0
-	github.com/code-payments/code-protobuf-api v1.10.0
+	github.com/code-payments/code-protobuf-api v1.11.0
 	github.com/emirpasic/gods v1.12.0
 	github.com/envoyproxy/protoc-gen-validate v0.1.0
 	github.com/golang-jwt/jwt/v5 v5.0.0

go.sum

@@ -108,8 +108,8 @@ github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWH
 github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cockroachdb/apd v1.1.0 h1:3LFP3629v+1aKXU5Q37mxmRxX/pIu1nijXydLShEq5I=
 github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
-github.com/code-payments/code-protobuf-api v1.10.0 h1:0I/lCHUtuQdbSKj02miQZlwSEdEUqVtTR0LxPTxA15w=
-github.com/code-payments/code-protobuf-api v1.10.0/go.mod h1:pHQm75vydD6Cm2qHAzlimW6drysm489Z4tVxC2zHSsU=
+github.com/code-payments/code-protobuf-api v1.11.0 h1:xlE4cwDAkyzsa8Jxmvy5D0trtTGLCw+wqs142tYhTXo=
+github.com/code-payments/code-protobuf-api v1.11.0/go.mod h1:pHQm75vydD6Cm2qHAzlimW6drysm489Z4tVxC2zHSsU=
 github.com/containerd/continuity v0.0.0-20190827140505-75bee3e2ccb6 h1:NmTXa/uVnDyp0TY5MKi197+3HWcnYWfnHGyaFthlnGw=
 github.com/containerd/continuity v0.0.0-20190827140505-75bee3e2ccb6/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
 github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=

pkg/code/server/grpc/transaction/v2/limits.go

@@ -8,14 +8,14 @@ import (
 
 	transactionpb "github.com/code-payments/code-protobuf-api/generated/go/transaction/v2"
 
-	currency_lib "github.com/code-payments/code-server/pkg/currency"
-	"github.com/code-payments/code-server/pkg/grpc/client"
-	"github.com/code-payments/code-server/pkg/kin"
 	"github.com/code-payments/code-server/pkg/code/balance"
 	"github.com/code-payments/code-server/pkg/code/common"
 	"github.com/code-payments/code-server/pkg/code/data/phone"
 	exchange_rate_util "github.com/code-payments/code-server/pkg/code/exchangerate"
 	"github.com/code-payments/code-server/pkg/code/limit"
+	currency_lib "github.com/code-payments/code-server/pkg/currency"
+	"github.com/code-payments/code-server/pkg/grpc/client"
+	"github.com/code-payments/code-server/pkg/kin"
 )
 
 func (s *transactionServer) GetLimits(ctx context.Context, req *transactionpb.GetLimitsRequest) (*transactionpb.GetLimitsResponse, error) {
@@ -35,31 +35,35 @@ func (s *transactionServer) GetLimits(ctx context.Context, req *transactionpb.Ge
 		return nil, err
 	}
 
-	zeroSendLimits := make(map[string]*transactionpb.RemainingSendLimit)
+	zeroSendLimits := make(map[string]*transactionpb.SendLimit)
 	zeroMicroPaymentLimits := make(map[string]*transactionpb.MicroPaymentLimit)
+	zeroBuyModuleLimits := make(map[string]*transactionpb.BuyModuleLimit)
 	for currency := range limit.SendLimits {
-		zeroSendLimits[string(currency)] = &transactionpb.RemainingSendLimit{
-			NextTransaction: 0,
+		zeroSendLimits[string(currency)] = &transactionpb.SendLimit{
+			NextTransaction:   0,
+			MaxPerTransaction: 0,
+			MaxPerDay:         0,
 		}
 		zeroMicroPaymentLimits[string(currency)] = &transactionpb.MicroPaymentLimit{
 			MaxPerTransaction: 0,
 			MinPerTransaction: 0,
 		}
 	}
-	zeroSendLimits[string(currency_lib.KIN)] = &transactionpb.RemainingSendLimit{
+	zeroSendLimits[string(currency_lib.KIN)] = &transactionpb.SendLimit{
 		NextTransaction: 0,
 	}
 	zeroMicroPaymentLimits[string(currency_lib.KIN)] = &transactionpb.MicroPaymentLimit{
 		MaxPerTransaction: 0,
 		MinPerTransaction: 0,
 	}
 	zeroResp := &transactionpb.GetLimitsResponse{
-		Result:                        transactionpb.GetLimitsResponse_OK,
-		RemainingSendLimitsByCurrency: zeroSendLimits,
+		Result:                       transactionpb.GetLimitsResponse_OK,
+		SendLimitsByCurrency:         zeroSendLimits,
+		MicroPaymentLimitsByCurrency: zeroMicroPaymentLimits,
+		BuyModuleLimitsByCurrency:    zeroBuyModuleLimits,
 		DepositLimit: &transactionpb.DepositLimit{
 			MaxQuarks: 0,
 		},
-		MicroPaymentLimitsByCurrency: zeroMicroPaymentLimits,
 	}
 
 	verificationRecord, err := s.data.GetLatestPhoneVerificationForAccount(ctx, ownerAccount.PublicKey().ToBase58())
@@ -108,7 +112,7 @@ func (s *transactionServer) GetLimits(ctx context.Context, req *transactionpb.Ge
 	// Part 1: Calculate send limits
 	//
 
-	remainingSendLimits := make(map[string]*transactionpb.RemainingSendLimit)
+	sendLimits := make(map[string]*transactionpb.SendLimit)
 	for currency, sendLimit := range limit.SendLimits {
 		otherRate, ok := multiRateRecord.Rates[string(currency)]
 		if !ok {
@@ -133,16 +137,20 @@ func (s *transactionServer) GetLimits(ctx context.Context, req *transactionpb.Ge
 			remainingNextTransaction = 0
 		}
 
-		remainingSendLimits[string(currency)] = &transactionpb.RemainingSendLimit{
-			NextTransaction: float32(remainingNextTransaction),
+		sendLimits[string(currency)] = &transactionpb.SendLimit{
+			NextTransaction:   float32(remainingNextTransaction),
+			MaxPerTransaction: float32(sendLimit.PerTransaction),
+			MaxPerDay:         float32(sendLimit.Daily),
 		}
 	}
 
-	usdSendLimits := remainingSendLimits[string(currency_lib.USD)]
+	usdSendLimits := sendLimits[string(currency_lib.USD)]
 
 	// Inject a Kin limit based on the remaining USD amount and rate
-	remainingSendLimits[string(currency_lib.KIN)] = &transactionpb.RemainingSendLimit{
-		NextTransaction: usdSendLimits.NextTransaction / float32(usdRate),
+	sendLimits[string(currency_lib.KIN)] = &transactionpb.SendLimit{
+		NextTransaction:   usdSendLimits.NextTransaction / float32(usdRate),
+		MaxPerTransaction: usdSendLimits.MaxPerTransaction / float32(usdRate),
+		MaxPerDay:         usdSendLimits.MaxPerDay / float32(usdRate),
 	}
 
 	//
@@ -183,12 +191,25 @@ func (s *transactionServer) GetLimits(ctx context.Context, req *transactionpb.Ge
 		}
 	}
 
+	//
+	// Part 4: Calculate buy module limits
+	//
+
+	convertedBuyModuleLimits := make(map[string]*transactionpb.BuyModuleLimit)
+	for currency, limits := range limit.SendLimits {
+		convertedBuyModuleLimits[string(currency)] = &transactionpb.BuyModuleLimit{
+			MaxPerTransaction: float32(limits.PerTransaction),
+			MinPerTransaction: float32(limits.PerTransaction / 10),
+		}
+	}
+
 	return &transactionpb.GetLimitsResponse{
-		Result:                        transactionpb.GetLimitsResponse_OK,
-		RemainingSendLimitsByCurrency: remainingSendLimits,
+		Result:                       transactionpb.GetLimitsResponse_OK,
+		SendLimitsByCurrency:         sendLimits,
+		MicroPaymentLimitsByCurrency: convertedMicroPaymentLimits,
+		BuyModuleLimitsByCurrency:    convertedBuyModuleLimits,
 		DepositLimit: &transactionpb.DepositLimit{
 			MaxQuarks: kin.ToQuarks(uint64(usdForNextDeposit / usdRate)),
 		},
-		MicroPaymentLimitsByCurrency: convertedMicroPaymentLimits,
 	}, nil
 }

pkg/code/server/grpc/transaction/v2/limits_test.go

@@ -14,10 +14,10 @@ import (
 	commonpb "github.com/code-payments/code-protobuf-api/generated/go/common/v1"
 	transactionpb "github.com/code-payments/code-protobuf-api/generated/go/transaction/v2"
 
+	"github.com/code-payments/code-server/pkg/code/limit"
 	currency_lib "github.com/code-payments/code-server/pkg/currency"
 	"github.com/code-payments/code-server/pkg/kin"
 	"github.com/code-payments/code-server/pkg/testutil"
-	"github.com/code-payments/code-server/pkg/code/limit"
 )
 
 func TestGetLimits_SendLimits_HappyPath(t *testing.T) {
@@ -44,9 +44,13 @@ func TestGetLimits_SendLimits_HappyPath(t *testing.T) {
 
 		actual := limitsByCurrency[string(currency_lib.USD)]
 		assert.EqualValues(t, usdLimits.PerTransaction, actual.NextTransaction)
+		assert.EqualValues(t, usdLimits.PerTransaction, actual.MaxPerTransaction)
+		assert.EqualValues(t, usdLimits.Daily, actual.MaxPerDay)
 
 		actual = limitsByCurrency[string(currency_lib.KIN)]
 		assert.EqualValues(t, usdLimits.PerTransaction/usdRate.Rate, actual.NextTransaction)
+		assert.EqualValues(t, usdLimits.PerTransaction/usdRate.Rate, actual.MaxPerTransaction)
+		assert.EqualValues(t, usdLimits.Daily/usdRate.Rate, actual.MaxPerDay)
 
 		sendingPhone.privatelyWithdraw123KinToExternalWallet(t).requireSuccess(t)
 
@@ -58,9 +62,13 @@ func TestGetLimits_SendLimits_HappyPath(t *testing.T) {
 
 	actual := limitsByCurrency[string(currency_lib.USD)]
 	assert.EqualValues(t, usdLimits.Daily-usdSent, actual.NextTransaction)
+	assert.EqualValues(t, usdLimits.PerTransaction, actual.MaxPerTransaction)
+	assert.EqualValues(t, usdLimits.Daily, actual.MaxPerDay)
 
 	actual = limitsByCurrency[string(currency_lib.KIN)]
 	assert.EqualValues(t, (usdLimits.Daily-usdSent)/usdRate.Rate, actual.NextTransaction)
+	assert.EqualValues(t, usdLimits.PerTransaction/usdRate.Rate, actual.MaxPerTransaction)
+	assert.EqualValues(t, usdLimits.Daily/usdRate.Rate, actual.MaxPerDay)
 
 	for {
 		if usdSent > usdLimits.Daily {
@@ -78,9 +86,13 @@ func TestGetLimits_SendLimits_HappyPath(t *testing.T) {
 
 	actual = limitsByCurrency[string(currency_lib.USD)]
 	assert.EqualValues(t, 0, actual.NextTransaction)
+	assert.EqualValues(t, usdLimits.PerTransaction, actual.MaxPerTransaction)
+	assert.EqualValues(t, usdLimits.Daily, actual.MaxPerDay)
 
 	actual = limitsByCurrency[string(currency_lib.KIN)]
 	assert.EqualValues(t, 0, actual.NextTransaction)
+	assert.EqualValues(t, usdLimits.PerTransaction/usdRate.Rate, actual.MaxPerTransaction)
+	assert.EqualValues(t, usdLimits.Daily/usdRate.Rate, actual.MaxPerDay)
 }
 
 func TestGetLimits_DepositLimits_HappyPath_DailyConsumed(t *testing.T) {
@@ -178,6 +190,24 @@ func TestGetLimits_MicroPaymentLimits_HappyPath(t *testing.T) {
 	}
 }
 
+func TestGetLimits_BuyModuleLimits_HappyPath(t *testing.T) {
+	server, phone, _, cleanup := setupTestEnv(t, &testOverrides{})
+	defer cleanup()
+
+	server.generateAvailableNonces(t, 10000)
+
+	phone.openAccounts(t).requireSuccess(t)
+
+	actualBuyModuleLimits := phone.getBuyModuleLimits(t)
+	assert.Len(t, actualBuyModuleLimits, len(limit.SendLimits))
+	for currency, actualLimits := range actualBuyModuleLimits {
+		sendLimit, ok := limit.SendLimits[currency_lib.Code(currency)]
+		require.True(t, ok)
+		assert.EqualValues(t, sendLimit.PerTransaction, actualLimits.MaxPerTransaction)
+		assert.EqualValues(t, sendLimit.PerTransaction/10, actualLimits.MinPerTransaction)
+	}
+}
+
 func TestGetLimits_UnauthenticateddAccess(t *testing.T) {
 	_, phone, _, cleanup := setupTestEnv(t, &testOverrides{})
 	defer cleanup()

pkg/code/server/grpc/transaction/v2/testutil.go

@@ -5217,7 +5217,7 @@ func (p *phoneTestEnv) validateUpgradeableIntents(t *testing.T, upgradeableInten
 	}
 }
 
-func (p *phoneTestEnv) getSendLimits(t *testing.T) map[string]*transactionpb.RemainingSendLimit {
+func (p *phoneTestEnv) getSendLimits(t *testing.T) map[string]*transactionpb.SendLimit {
 	req := &transactionpb.GetLimitsRequest{
 		Owner:         p.parentAccount.ToProto(),
 		ConsumedSince: timestamppb.New(time.Now().Add(-24 * time.Hour)),
@@ -5227,10 +5227,10 @@ func (p *phoneTestEnv) getSendLimits(t *testing.T) map[string]*transactionpb.Rem
 	resp, err := p.client.GetLimits(p.ctx, req)
 	require.NoError(t, err)
 	assert.Equal(t, transactionpb.GetLimitsResponse_OK, resp.Result)
-	return resp.RemainingSendLimitsByCurrency
+	return resp.SendLimitsByCurrency
 }
 
-func (p *phoneTestEnv) getDepositLimit(t *testing.T) *transactionpb.DepositLimit {
+func (p *phoneTestEnv) getMicroPaymentLimits(t *testing.T) map[string]*transactionpb.MicroPaymentLimit {
 	req := &transactionpb.GetLimitsRequest{
 		Owner:         p.parentAccount.ToProto(),
 		ConsumedSince: timestamppb.New(time.Now().Add(-24 * time.Hour)),
@@ -5240,10 +5240,10 @@ func (p *phoneTestEnv) getDepositLimit(t *testing.T) *transactionpb.DepositLimit
 	resp, err := p.client.GetLimits(p.ctx, req)
 	require.NoError(t, err)
 	assert.Equal(t, transactionpb.GetLimitsResponse_OK, resp.Result)
-	return resp.DepositLimit
+	return resp.MicroPaymentLimitsByCurrency
 }
 
-func (p *phoneTestEnv) getMicroPaymentLimits(t *testing.T) map[string]*transactionpb.MicroPaymentLimit {
+func (p *phoneTestEnv) getBuyModuleLimits(t *testing.T) map[string]*transactionpb.BuyModuleLimit {
 	req := &transactionpb.GetLimitsRequest{
 		Owner:         p.parentAccount.ToProto(),
 		ConsumedSince: timestamppb.New(time.Now().Add(-24 * time.Hour)),
@@ -5253,7 +5253,20 @@ func (p *phoneTestEnv) getMicroPaymentLimits(t *testing.T) map[string]*transacti
 	resp, err := p.client.GetLimits(p.ctx, req)
 	require.NoError(t, err)
 	assert.Equal(t, transactionpb.GetLimitsResponse_OK, resp.Result)
-	return resp.MicroPaymentLimitsByCurrency
+	return resp.BuyModuleLimitsByCurrency
+}
+
+func (p *phoneTestEnv) getDepositLimit(t *testing.T) *transactionpb.DepositLimit {
+	req := &transactionpb.GetLimitsRequest{
+		Owner:         p.parentAccount.ToProto(),
+		ConsumedSince: timestamppb.New(time.Now().Add(-24 * time.Hour)),
+	}
+	req.Signature = p.signProtoMessage(t, req, req.Owner, false)
+
+	resp, err := p.client.GetLimits(p.ctx, req)
+	require.NoError(t, err)
+	assert.Equal(t, transactionpb.GetLimitsResponse_OK, resp.Result)
+	return resp.DepositLimit
 }
 
 func (p *phoneTestEnv) getPaymentHistory(t *testing.T) []*transactionpb.PaymentHistoryItem {