satellite/payments : deposit bonuses (credits) added

Change-Id: Ib151bbb9b02d655fa619c53bfbc04ed6f3bb39e0
This commit is contained in:
Qweder93 2020-01-24 15:38:53 +02:00 committed by Nikolai Siedov
parent 3331b443e7
commit dc075eaa96
25 changed files with 2236 additions and 15 deletions

View File

@ -517,7 +517,8 @@ func NewAPI(log *zap.Logger, full *identity.FullIdentity, db DB,
peer.DB.ProjectAccounting(),
pc.StorageTBPrice,
pc.EgressTBPrice,
pc.ObjectPrice)
pc.ObjectPrice,
pc.BonusRate)
if err != nil {
return nil, errs.Combine(err, peer.Close())

View File

@ -32,4 +32,6 @@ const (
Charge BillingHistoryItemType = 2
// Coupon is an entity that adds some funds to Accounts balance for some fixed period.
Coupon BillingHistoryItemType = 3
// Credits is an entity that adds some funds to Accounts balance after deposit with storj coins.
Credits BillingHistoryItemType = 4
)

View File

@ -63,7 +63,7 @@ func TestGrapqhlMutation(t *testing.T) {
db.StripeCoinPayments(),
db.Console().Projects(),
db.ProjectAccounting(),
"0", "0", "0",
"0", "0", "0", 10,
)
require.NoError(t, err)

View File

@ -48,7 +48,7 @@ func TestGraphqlQuery(t *testing.T) {
db.StripeCoinPayments(),
db.Console().Projects(),
db.ProjectAccounting(),
"0", "0", "0",
"0", "0", "0", 10,
)
require.NoError(t, err)

View File

@ -190,7 +190,7 @@ func NewServer(logger *zap.Logger, config Config, service *console.Service, mail
return &server
}
// Run starts the server that host webapp and api endpoint
// Run starts the server that host webapp and api endpoint.
func (server *Server) Run(ctx context.Context) (err error) {
defer mon.Task()(&ctx)(&err)
@ -288,7 +288,7 @@ func (server *Server) withAuth(handler http.Handler) http.Handler {
})
}
// bucketUsageReportHandler generate bucket usage report page for project
// bucketUsageReportHandler generate bucket usage report page for project.
func (server *Server) bucketUsageReportHandler(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
var err error

View File

@ -115,7 +115,7 @@ func NewService(log *zap.Logger, signer Signer, store DB, projectAccounting acco
}, nil
}
// Payments separates all payment related functionality
// Payments separates all payment related functionality.
func (s *Service) Payments() PaymentsService {
return PaymentsService{service: s}
}
@ -296,6 +296,23 @@ func (paymentService PaymentsService) BillingHistory(ctx context.Context) (billi
)
}
credits, err := paymentService.service.accounts.Credits().ListByUserID(ctx, auth.User.ID)
if err != nil {
return nil, Error.Wrap(err)
}
for _, credit := range credits {
billingHistory = append(billingHistory,
&BillingHistoryItem{
Description: "10% bonus for deposit made in STORJ",
Amount: credit.Amount,
Status: "Added to balance",
Start: credit.Created,
Type: Credits,
},
)
}
sort.SliceStable(billingHistory,
func(i, j int) bool {
return billingHistory[i].Start.After(billingHistory[j].Start)

View File

@ -427,7 +427,8 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB,
peer.DB.ProjectAccounting(),
pc.StorageTBPrice,
pc.EgressTBPrice,
pc.ObjectPrice)
pc.ObjectPrice,
pc.BonusRate)
if err != nil {
return nil, errs.Combine(err, peer.Close())

View File

@ -30,6 +30,9 @@ type Accounts interface {
// Charges returns list of all credit card charges related to account.
Charges(ctx context.Context, userID uuid.UUID) ([]Charge, error)
// Credits exposes all needed functionality to manage credits.
Credits() Credits
// CreditCards exposes all needed functionality to manage account credit cards.
CreditCards() CreditCards

View File

@ -0,0 +1,40 @@
// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information.
package payments
import (
"context"
"time"
"github.com/skyrings/skyring-common/tools/uuid"
"storj.io/storj/satellite/payments/coinpayments"
)
// Credits exposes all needed functionality to manage credits.
//
// architecture: Service
type Credits interface {
// Create attaches a credit for payment account.
Create(ctx context.Context, credit Credit) (err error)
// ListByUserID return list of all credits of specified payment account.
ListByUserID(ctx context.Context, userID uuid.UUID) ([]Credit, error)
}
// Credit is an entity that holds bonus balance of user, earned by depositing with storj coins.
type Credit struct {
UserID uuid.UUID `json:"userId"`
Amount int64 `json:"credit"`
TransactionID coinpayments.TransactionID `json:"transactionId"`
Created time.Time `json:"created"`
}
// CreditsPage holds set of credits and indicates if
// there are more credits to fetch.
type CreditsPage struct {
Credits []Credit
Next bool
NextOffset int64
}

View File

@ -57,6 +57,14 @@ var _ payments.Coupons = (*coupons)(nil)
// architecture: Service
type coupons struct{}
// ensures that credits implements payments.Credits.
var _ payments.Credits = (*credits)(nil)
// credits is an implementation of payments.Credits.
//
// architecture: Service
type credits struct{}
// Accounts exposes all needed functionality to manage payment accounts.
func Accounts() payments.Accounts {
return &accounts{}
@ -82,6 +90,11 @@ func (accounts *accounts) Coupons() payments.Coupons {
return &coupons{}
}
// Credits exposes all needed functionality to manage coupons.
func (accounts *accounts) Credits() payments.Credits {
return &credits{}
}
// Setup creates a payment account for the user.
// If account is already set up it will return nil.
func (accounts *accounts) Setup(ctx context.Context, userID uuid.UUID, email string) (err error) {
@ -189,3 +202,17 @@ func (coupons *coupons) AddPromotionalCoupon(ctx context.Context, userID uuid.UU
return nil
}
// Create attaches a credit for payment account.
func (credits *credits) Create(ctx context.Context, credit payments.Credit) (err error) {
defer mon.Task()(&ctx, credit)(&err)
return nil
}
// ListByUserID return list of all credits of specified payment account.
func (credits *credits) ListByUserID(ctx context.Context, userID uuid.UUID) (_ []payments.Credit, err error) {
defer mon.Task()(&ctx, userID)(&err)
return ([]payments.Credit)(nil), Error.Wrap(err)
}

View File

@ -14,4 +14,5 @@ type Config struct {
StorageTBPrice string `help:"price user should pay for storing TB per month" default:"10"`
EgressTBPrice string `help:"price user should pay for each TB of egress" default:"45"`
ObjectPrice string `help:"price user should pay for each object stored in network per month" default:"0.0000022"`
BonusRate int64 `help:"amount of percents that user will earn as bonus credits by depositing in STORJ tokens" default:"10"`
}

View File

@ -87,7 +87,12 @@ func (accounts *accounts) Balance(ctx context.Context, userID uuid.UUID) (_ int6
couponsAmount += coupon.Amount - alreadyUsed
}
return -c.Balance + couponsAmount, nil
creditBalance, err := accounts.service.db.Credits().Balance(ctx, userID)
if err != nil {
return 0, Error.Wrap(err)
}
return -c.Balance + couponsAmount + creditBalance, nil
}
// ProjectCharges returns how much money current user will be charged for each project.
@ -180,3 +185,9 @@ func (accounts *accounts) StorjTokens() payments.StorjTokens {
func (accounts *accounts) Coupons() payments.Coupons {
return &coupons{service: accounts.service}
}
// Credits exposes all needed functionality to manage credits.
func (accounts *accounts) Credits() payments.Credits {
return &credits{service: accounts.service}
}

View File

@ -0,0 +1,95 @@
// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information.
package stripecoinpayments
import (
"context"
"time"
"github.com/skyrings/skyring-common/tools/uuid"
"storj.io/storj/satellite/payments"
"storj.io/storj/satellite/payments/coinpayments"
)
// CreditsDB is an interface for managing credits table.
//
// architecture: Database
type CreditsDB interface {
// InsertCredit inserts credit to user's credit balance into the database.
InsertCredit(ctx context.Context, credit payments.Credit) error
// GetCredit returns credit by transactionID.
GetCredit(ctx context.Context, transactionID coinpayments.TransactionID) (_ payments.Credit, err error)
// ListCredits returns all credits of specific user.
ListCredits(ctx context.Context, userID uuid.UUID) ([]payments.Credit, error)
// ListCreditsPaged returns all credits of specific user.
ListCreditsPaged(ctx context.Context, offset int64, limit int, before time.Time, userID uuid.UUID) (payments.CreditsPage, error)
// InsertCreditsSpending inserts spending to user's spending list into the database.
InsertCreditsSpending(ctx context.Context, spending CreditsSpending) error
// ListCreditsSpendings returns spending received for concrete deposit.
ListCreditsSpendings(ctx context.Context, userID uuid.UUID) ([]CreditsSpending, error)
// ListCreditsSpendingsPaged returns all spending of specific user.
ListCreditsSpendingsPaged(ctx context.Context, status int, offset int64, limit int, before time.Time) (CreditsSpendingsPage, error)
// ApplyCreditsSpending updated spending's status.
ApplyCreditsSpending(ctx context.Context, spendingID uuid.UUID, status int) (err error)
// Balance returns difference between all credits and creditsSpendings of specific user.
Balance(ctx context.Context, userID uuid.UUID) (int64, error)
}
// ensures that credits implements payments.Credits.
var _ payments.Credits = (*credits)(nil)
// credits is an implementation of payments.Credits.
//
// architecture: Service
type credits struct {
service *Service
}
// CreditsSpending is an entity that holds funds been used from Accounts bonus credit balance.
// Status shows if spending have been used to pay for invoice already or not.
type CreditsSpending struct {
ID uuid.UUID `json:"id"`
ProjectID uuid.UUID `json:"projectId"`
UserID uuid.UUID `json:"userId"`
Amount int64 `json:"amount"`
Status int `json:"status"`
Created time.Time `json:"created"`
}
// CreditsSpendingsPage holds set of spendings and indicates if
// there are more spendings to fetch.
type CreditsSpendingsPage struct {
Spendings []CreditsSpending
Next bool
NextOffset int64
}
// CreditsSpendingStatus indicates the state of the spending.
type CreditsSpendingStatus int
const (
// CreditsSpendingStatusUnapplied is a default spending state.
CreditsSpendingStatusUnapplied CreditsSpendingStatus = 0
// CreditsSpendingStatusApplied status indicates that spending was applied.
CreditsSpendingStatusApplied CreditsSpendingStatus = 1
)
// Create attaches a credit for payment account.
func (credits *credits) Create(ctx context.Context, credit payments.Credit) (err error) {
defer mon.Task()(&ctx, credit)(&err)
return Error.Wrap(credits.service.db.Credits().InsertCredit(ctx, credit))
}
// ListByUserID return list of all credits of specified payment account.
func (credits *credits) ListByUserID(ctx context.Context, userID uuid.UUID) (_ []payments.Credit, err error) {
defer mon.Task()(&ctx, userID)(&err)
creditsList, err := credits.service.db.Credits().ListCredits(ctx, userID)
return creditsList, Error.Wrap(err)
}

View File

@ -0,0 +1,168 @@
// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information.
package stripecoinpayments_test
import (
"strconv"
"testing"
"time"
"github.com/skyrings/skyring-common/tools/uuid"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"storj.io/common/testcontext"
"storj.io/common/testrand"
"storj.io/storj/satellite"
"storj.io/storj/satellite/payments"
"storj.io/storj/satellite/payments/coinpayments"
"storj.io/storj/satellite/payments/stripecoinpayments"
"storj.io/storj/satellite/satellitedb/satellitedbtest"
)
func TestCreditsRepository(t *testing.T) {
satellitedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db satellite.DB) {
creditsRepo := db.StripeCoinPayments().Credits()
userID := testrand.UUID()
credit := payments.Credit{
UserID: userID,
Amount: 10,
TransactionID: "transactionID",
}
spending := stripecoinpayments.CreditsSpending{
ProjectID: testrand.UUID(),
UserID: userID,
Amount: 5,
Status: int(stripecoinpayments.CreditsSpendingStatusUnapplied),
}
t.Run("insert", func(t *testing.T) {
err := creditsRepo.InsertCredit(ctx, credit)
assert.NoError(t, err)
credits, err := creditsRepo.ListCredits(ctx, userID)
assert.NoError(t, err)
assert.Equal(t, 1, len(credits))
credit = credits[0]
err = creditsRepo.InsertCreditsSpending(ctx, spending)
assert.NoError(t, err)
spendings, err := creditsRepo.ListCreditsSpendings(ctx, userID)
assert.NoError(t, err)
assert.Equal(t, 1, len(spendings))
})
t.Run("get credit by transactionID", func(t *testing.T) {
crdt, err := creditsRepo.GetCredit(ctx, credit.TransactionID)
assert.NoError(t, err)
assert.Equal(t, int64(10), crdt.Amount)
})
t.Run("update spending", func(t *testing.T) {
err := creditsRepo.ApplyCreditsSpending(ctx, spending.ID, int(stripecoinpayments.CreditsSpendingStatusApplied))
assert.NoError(t, err)
spendings, err := creditsRepo.ListCreditsSpendings(ctx, userID)
require.NoError(t, err)
require.Equal(t, int(stripecoinpayments.CreditsSpendingStatusApplied), spendings[0].Status)
spending = spendings[0]
})
t.Run("balance", func(t *testing.T) {
balance, err := creditsRepo.Balance(ctx, userID)
assert.NoError(t, err)
assert.Equal(t, 5, int(balance))
})
})
}
func TestCreditsRepositoryList(t *testing.T) {
satellitedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db satellite.DB) {
creditsDB := db.StripeCoinPayments().Credits()
const spendLen = 5
for i := 0; i < spendLen*2+3; i++ {
userID, err := uuid.New()
require.NoError(t, err)
projectID, err := uuid.New()
require.NoError(t, err)
spendingID, err := uuid.New()
require.NoError(t, err)
spending := stripecoinpayments.CreditsSpending{
ID: *spendingID,
ProjectID: *projectID,
UserID: *userID,
Amount: int64(5 + i),
Status: 0,
}
err = creditsDB.InsertCreditsSpending(ctx, spending)
require.NoError(t, err)
}
page, err := creditsDB.ListCreditsSpendingsPaged(ctx, 0, 0, spendLen, time.Now())
require.NoError(t, err)
require.Equal(t, spendLen, len(page.Spendings))
assert.True(t, page.Next)
assert.Equal(t, int64(5), page.NextOffset)
page, err = creditsDB.ListCreditsSpendingsPaged(ctx, 0, page.NextOffset, spendLen, time.Now())
require.NoError(t, err)
require.Equal(t, spendLen, len(page.Spendings))
assert.True(t, page.Next)
assert.Equal(t, int64(10), page.NextOffset)
page, err = creditsDB.ListCreditsSpendingsPaged(ctx, 0, page.NextOffset, spendLen, time.Now())
require.NoError(t, err)
require.Equal(t, 3, len(page.Spendings))
assert.False(t, page.Next)
assert.Equal(t, int64(0), page.NextOffset)
const credLen = 5
user2ID, err := uuid.New()
require.NoError(t, err)
for i := 0; i < credLen*2+3; i++ {
transactionID := "transID" + strconv.Itoa(i)
credit := payments.Credit{
UserID: *user2ID,
Amount: 5,
TransactionID: coinpayments.TransactionID(transactionID),
}
err = creditsDB.InsertCredit(ctx, credit)
require.NoError(t, err)
}
page2, err := creditsDB.ListCreditsPaged(ctx, 0, spendLen, time.Now(), *user2ID)
require.NoError(t, err)
require.Equal(t, spendLen, len(page2.Credits))
assert.True(t, page2.Next)
assert.Equal(t, int64(5), page2.NextOffset)
page2, err = creditsDB.ListCreditsPaged(ctx, page2.NextOffset, spendLen, time.Now(), *user2ID)
require.NoError(t, err)
require.Equal(t, spendLen, len(page2.Credits))
assert.True(t, page2.Next)
assert.Equal(t, int64(10), page2.NextOffset)
page2, err = creditsDB.ListCreditsPaged(ctx, page2.NextOffset, spendLen, time.Now(), *user2ID)
require.NoError(t, err)
require.Equal(t, 3, len(page2.Credits))
assert.False(t, page2.Next)
assert.Equal(t, int64(0), page2.NextOffset)
})
}

View File

@ -13,6 +13,8 @@ type DB interface {
Transactions() TransactionsDB
// ProjectRecords is getter for invoice project records db.
ProjectRecords() ProjectRecordsDB
// CouponsDB is getter for coupons db.
// Coupons is getter for coupons db.
Coupons() CouponsDB
// Credits is getter for credits db.
Credits() CreditsDB
}

View File

@ -58,6 +58,8 @@ type Service struct {
ByteHourCents decimal.Decimal
EgressByteCents decimal.Decimal
ObjectHourCents decimal.Decimal
// BonusRate amount of percents
BonusRate int64
mu sync.Mutex
rates coinpayments.CurrencyRateInfos
@ -65,7 +67,7 @@ type Service struct {
}
// NewService creates a Service instance.
func NewService(log *zap.Logger, config Config, db DB, projectsDB console.Projects, usageDB accounting.ProjectAccounting, storageTBPrice, egressTBPrice, objectPrice string) (*Service, error) {
func NewService(log *zap.Logger, config Config, db DB, projectsDB console.Projects, usageDB accounting.ProjectAccounting, storageTBPrice, egressTBPrice, objectPrice string, bonusRate int64) (*Service, error) {
backendConfig := &stripe.BackendConfig{
LeveledLogger: log.Sugar(),
}
@ -123,6 +125,7 @@ func NewService(log *zap.Logger, config Config, db DB, projectsDB console.Projec
ByteHourCents: byteHourCents,
EgressByteCents: egressByteCents,
ObjectHourCents: objectHourCents,
BonusRate: bonusRate,
}, nil
}
@ -299,7 +302,17 @@ func (service *Service) applyTransactionBalance(ctx context.Context, tx Transact
// TODO: 0 amount will return an error, how to handle that?
_, err = service.stripeClient.CustomerBalanceTransactions.New(params)
return err
if err != nil {
return err
}
credit := payments.Credit{
UserID: tx.AccountID,
Amount: cents / 100 * service.BonusRate,
TransactionID: tx.ID,
}
return service.db.Credits().InsertCredit(ctx, credit)
}
// UpdateRates fetches new rates and updates service rate cache.
@ -425,6 +438,8 @@ func (service *Service) createProjectRecords(ctx context.Context, projects []con
currentUsagePrice := service.calculateProjectUsagePrice(usage.Egress, usage.Storage, usage.ObjectCount).TotalInt64()
amountToChargeFromCoupon := currentUsagePrice
// TODO: only for 1 coupon per project
for _, coupon := range coupons {
if coupon.IsExpired() {
@ -441,13 +456,13 @@ func (service *Service) createProjectRecords(ctx context.Context, projects []con
}
remaining := coupon.Amount - alreadyChargedAmount
if currentUsagePrice >= remaining {
currentUsagePrice = remaining
if amountToChargeFromCoupon >= remaining {
amountToChargeFromCoupon = remaining
}
usages = append(usages, CouponUsage{
Period: start,
Amount: currentUsagePrice,
Amount: amountToChargeFromCoupon,
Status: CouponUsageStatusUnapplied,
CouponID: coupon.ID,
})

View File

@ -0,0 +1,275 @@
// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information.
package satellitedb
import (
"context"
"time"
"github.com/skyrings/skyring-common/tools/uuid"
"github.com/zeebo/errs"
"storj.io/storj/private/dbutil"
"storj.io/storj/satellite/payments"
"storj.io/storj/satellite/payments/coinpayments"
"storj.io/storj/satellite/payments/stripecoinpayments"
dbx "storj.io/storj/satellite/satellitedb/dbx"
)
// ensures that credit implements payments.CreditsDB.
var _ stripecoinpayments.CreditsDB = (*credit)(nil)
// credit is an implementation of payments.CreditsDB.
//
// architecture: Database
type credit struct {
db *satelliteDB
}
// InsertCredit inserts credit into the database.
func (credits *credit) InsertCredit(ctx context.Context, credit payments.Credit) (err error) {
defer mon.Task()(&ctx, credit)(&err)
_, err = credits.db.Create_Credit(
ctx,
dbx.Credit_UserId(credit.UserID[:]),
dbx.Credit_TransactionId(string(credit.TransactionID[:])),
dbx.Credit_Amount(credit.Amount),
)
return err
}
// GetCredit returns credit by transactionID.
func (credits *credit) GetCredit(ctx context.Context, transactionID coinpayments.TransactionID) (_ payments.Credit, err error) {
defer mon.Task()(&ctx, transactionID)(&err)
dbxCredit, err := credits.db.Get_Credit_By_TransactionId(ctx, dbx.Credit_TransactionId(string(transactionID)))
if err != nil {
return payments.Credit{}, err
}
return fromDBXCredit(dbxCredit)
}
// ListCredits returns all credits of specified user.
func (credits *credit) ListCredits(ctx context.Context, userID uuid.UUID) (_ []payments.Credit, err error) {
defer mon.Task()(&ctx, userID)(&err)
dbxCredits, err := credits.db.All_Credit_By_UserId_OrderBy_Desc_CreatedAt(
ctx,
dbx.Credit_UserId(userID[:]),
)
if err != nil {
return nil, err
}
return creditsFromDbxSlice(dbxCredits)
}
// ListCreditsPaged returns paginated list of user's credits.
func (credits *credit) ListCreditsPaged(ctx context.Context, offset int64, limit int, before time.Time, userID uuid.UUID) (_ payments.CreditsPage, err error) {
defer mon.Task()(&ctx)(&err)
var page payments.CreditsPage
dbxCredits, err := credits.db.Limited_Credit_By_UserId_And_CreatedAt_LessOrEqual_OrderBy_Desc_CreatedAt(
ctx,
dbx.Credit_UserId(userID[:]),
dbx.Credit_CreatedAt(before.UTC()),
limit+1,
offset,
)
if err != nil {
return payments.CreditsPage{}, err
}
if len(dbxCredits) == limit+1 {
page.Next = true
page.NextOffset = offset + int64(limit)
dbxCredits = dbxCredits[:len(dbxCredits)-1]
}
page.Credits, err = creditsFromDbxSlice(dbxCredits)
if err != nil {
return payments.CreditsPage{}, nil
}
return page, nil
}
// InsertCreditsSpending inserts spending into the database.
func (credits *credit) InsertCreditsSpending(ctx context.Context, spending stripecoinpayments.CreditsSpending) (err error) {
defer mon.Task()(&ctx, spending)(&err)
_, err = credits.db.Create_CreditsSpending(
ctx,
dbx.CreditsSpending_Id(spending.ID[:]),
dbx.CreditsSpending_UserId(spending.UserID[:]),
dbx.CreditsSpending_ProjectId(spending.ProjectID[:]),
dbx.CreditsSpending_Amount(spending.Amount),
dbx.CreditsSpending_Status(spending.Status),
)
return err
}
// ListCreditsSpendings returns all spendings of specified user.
func (credits *credit) ListCreditsSpendings(ctx context.Context, userID uuid.UUID) (_ []stripecoinpayments.CreditsSpending, err error) {
defer mon.Task()(&ctx, userID)(&err)
dbxSpendings, err := credits.db.All_CreditsSpending_By_UserId_OrderBy_Desc_CreatedAt(
ctx,
dbx.CreditsSpending_UserId(userID[:]),
)
if err != nil {
return nil, err
}
return creditsSpendingsFromDbxSlice(dbxSpendings)
}
// ApplyCreditsSpending applies spending and updates its status.
func (credits *credit) ApplyCreditsSpending(ctx context.Context, spendingID uuid.UUID, status int) (err error) {
defer mon.Task()(&ctx)(&err)
_, err = credits.db.Update_CreditsSpending_By_Id(
ctx,
dbx.CreditsSpending_Id(spendingID[:]),
dbx.CreditsSpending_Update_Fields{Status: dbx.CreditsSpending_Status(status)},
)
return err
}
// ListCreditsSpendingsPaged returns paginated list of user's spendings.
func (credits *credit) ListCreditsSpendingsPaged(ctx context.Context, status int, offset int64, limit int, before time.Time) (_ stripecoinpayments.CreditsSpendingsPage, err error) {
defer mon.Task()(&ctx)(&err)
var page stripecoinpayments.CreditsSpendingsPage
dbxSpendings, err := credits.db.Limited_CreditsSpending_By_CreatedAt_LessOrEqual_And_Status_OrderBy_Desc_CreatedAt(
ctx,
dbx.CreditsSpending_CreatedAt(before.UTC()),
dbx.CreditsSpending_Status(status),
limit+1,
offset,
)
if err != nil {
return stripecoinpayments.CreditsSpendingsPage{}, err
}
if len(dbxSpendings) == limit+1 {
page.Next = true
page.NextOffset = offset + int64(limit)
dbxSpendings = dbxSpendings[:len(dbxSpendings)-1]
}
page.Spendings, err = creditsSpendingsFromDbxSlice(dbxSpendings)
if err != nil {
return stripecoinpayments.CreditsSpendingsPage{}, nil
}
return page, nil
}
// Balance returns difference between earned for deposit and spent on invoices credits.
func (credits *credit) Balance(ctx context.Context, userID uuid.UUID) (balance int64, err error) {
defer mon.Task()(&ctx)(&err)
var creditsAmount, creditsSpendingsAmount int64
allCredits, err := credits.ListCredits(ctx, userID)
if err != nil {
return 0, err
}
allSpendings, err := credits.ListCreditsSpendings(ctx, userID)
if err != nil {
return 0, err
}
for i := range allCredits {
creditsAmount += allCredits[i].Amount
}
for j := range allSpendings {
creditsSpendingsAmount += allSpendings[j].Amount
}
balance = creditsAmount - creditsSpendingsAmount
return balance, nil
}
// fromDBXCredit converts *dbx.Credit to *payments.Credit.
func fromDBXCredit(dbxCredit *dbx.Credit) (credit payments.Credit, err error) {
credit.TransactionID = coinpayments.TransactionID(dbxCredit.TransactionId)
credit.UserID, err = dbutil.BytesToUUID(dbxCredit.UserId)
if err != nil {
return payments.Credit{}, err
}
credit.Created = dbxCredit.CreatedAt
credit.Amount = dbxCredit.Amount
return credit, nil
}
// creditsFromDbxSlice is used for creating []payments.CreditsDB entities from autogenerated []dbx.CreditsDB struct.
func creditsFromDbxSlice(creditsDbx []*dbx.Credit) (_ []payments.Credit, err error) {
var credits = make([]payments.Credit, 0)
var errors []error
// Generating []dbo from []dbx and collecting all errors
for _, creditDbx := range creditsDbx {
credit, err := fromDBXCredit(creditDbx)
if err != nil {
errors = append(errors, err)
continue
}
credits = append(credits, credit)
}
return credits, errs.Combine(errors...)
}
// fromDBXCreditsSpending converts *dbx.Spending to *payments.Spending.
func fromDBXSpending(dbxSpending *dbx.CreditsSpending) (spending stripecoinpayments.CreditsSpending, err error) {
spending.UserID, err = dbutil.BytesToUUID(dbxSpending.UserId)
if err != nil {
return stripecoinpayments.CreditsSpending{}, err
}
spending.ProjectID, err = dbutil.BytesToUUID(dbxSpending.ProjectId)
if err != nil {
return stripecoinpayments.CreditsSpending{}, err
}
spending.Status = dbxSpending.Status
spending.Created = dbxSpending.CreatedAt
spending.Amount = dbxSpending.Amount
return spending, nil
}
// creditsSpendingsFromDbxSlice is used for creating []payments.CreditSpendings entities from autogenerated []dbx.CreditsSpending struct.
func creditsSpendingsFromDbxSlice(spendingsDbx []*dbx.CreditsSpending) (_ []stripecoinpayments.CreditsSpending, err error) {
var spendings = make([]stripecoinpayments.CreditsSpending, 0)
var errors []error
// Generating []dbo from []dbx and collecting all errors
for _, spendingDbx := range spendingsDbx {
spending, err := fromDBXSpending(spendingDbx)
if err != nil {
errors = append(errors, err)
continue
}
spendings = append(spendings, spending)
}
return spendings, errs.Combine(errors...)
}

View File

@ -1107,3 +1107,58 @@ update coupon_usage (
where coupon_usage.coupon_id = ?
where coupon_usage.period = ?
)
model credit (
key transaction_id
field user_id blob
field transaction_id text
field amount int64
field created_at timestamp ( autoinsert )
)
create credit ()
read one (
select credit
where credit.transaction_id = ?
)
read all (
select credit
where credit.user_id = ?
orderby desc credit.created_at
)
read limitoffset (
select credit
where credit.user_id = ?
where credit.created_at <= ?
orderby desc credit.created_at
)
model credits_spending (
key id
field id blob
field user_id blob
field project_id blob
field amount int64
field status int ( updatable )
field created_at timestamp ( autoinsert )
)
create credits_spending ()
update credits_spending (
where credits_spending.id = ?
)
read all (
select credits_spending
where credits_spending.user_id = ?
orderby desc credits_spending.created_at
)
read limitoffset (
select credits_spending
where credits_spending.created_at <= ?
where credits_spending.status = ?
orderby desc credits_spending+.created_at
)

View File

@ -71,6 +71,22 @@ CREATE TABLE coupon_usages (
period timestamp with time zone NOT NULL,
PRIMARY KEY ( coupon_id, period )
);
CREATE TABLE credits (
user_id bytea NOT NULL,
transaction_id text NOT NULL,
amount bigint NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( transaction_id )
);
CREATE TABLE credits_spendings (
id bytea NOT NULL,
user_id bytea NOT NULL,
project_id bytea NOT NULL,
amount bigint NOT NULL,
status integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE graceful_exit_progress (
node_id bytea NOT NULL,
bytes_transferred bigint NOT NULL,

File diff suppressed because it is too large Load Diff

View File

@ -71,6 +71,22 @@ CREATE TABLE coupon_usages (
period timestamp with time zone NOT NULL,
PRIMARY KEY ( coupon_id, period )
);
CREATE TABLE credits (
user_id bytea NOT NULL,
transaction_id text NOT NULL,
amount bigint NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( transaction_id )
);
CREATE TABLE credits_spendings (
id bytea NOT NULL,
user_id bytea NOT NULL,
project_id bytea NOT NULL,
amount bigint NOT NULL,
status integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE graceful_exit_progress (
node_id bytea NOT NULL,
bytes_transferred bigint NOT NULL,

View File

@ -736,6 +736,29 @@ func (db *satelliteDB) PostgresMigration() *migrate.Migration {
`ALTER TABLE projects ADD COLUMN rate_limit integer;`,
},
},
{
DB: db.DB,
Description: "Create Credits related tables",
Version: 81,
Action: migrate.SQL{
`CREATE TABLE credits (
user_id bytea NOT NULL,
transaction_id text NOT NULL,
amount bigint NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( transaction_id )
);`,
`CREATE TABLE credits_spendings (
id bytea NOT NULL,
user_id bytea NOT NULL,
project_id bytea NOT NULL,
amount bigint NOT NULL,
status int NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);`,
},
},
},
}
}

View File

@ -32,7 +32,12 @@ func (db *stripeCoinPaymentsDB) ProjectRecords() stripecoinpayments.ProjectRecor
return &invoiceProjectRecords{db: db.db}
}
// CouponsDB is getter for coupons db.
// Coupons is getter for coupons db.
func (db *stripeCoinPaymentsDB) Coupons() stripecoinpayments.CouponsDB {
return &coupons{db: db.db}
}
//Credits is getter for credits db.
func (db *stripeCoinPaymentsDB) Credits() stripecoinpayments.CreditsDB {
return &credit{db: db.db}
}

View File

@ -0,0 +1,478 @@
-- AUTOGENERATED BY storj.io/dbx
-- DO NOT EDIT
CREATE TABLE accounting_rollups (
id bigserial NOT NULL,
node_id bytea NOT NULL,
start_time timestamp with time zone NOT NULL,
put_total bigint NOT NULL,
get_total bigint NOT NULL,
get_audit_total bigint NOT NULL,
get_repair_total bigint NOT NULL,
put_repair_total bigint NOT NULL,
at_rest_total double precision NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE accounting_timestamps (
name text NOT NULL,
value timestamp with time zone NOT NULL,
PRIMARY KEY ( name )
);
CREATE TABLE bucket_bandwidth_rollups (
bucket_name bytea NOT NULL,
project_id bytea NOT NULL,
interval_start timestamp NOT NULL,
interval_seconds integer NOT NULL,
action integer NOT NULL,
inline bigint NOT NULL,
allocated bigint NOT NULL,
settled bigint NOT NULL,
PRIMARY KEY ( bucket_name, project_id, interval_start, action )
);
CREATE TABLE bucket_storage_tallies (
bucket_name bytea NOT NULL,
project_id bytea NOT NULL,
interval_start timestamp NOT NULL,
inline bigint NOT NULL,
remote bigint NOT NULL,
remote_segments_count integer NOT NULL,
inline_segments_count integer NOT NULL,
object_count integer NOT NULL,
metadata_size bigint NOT NULL,
PRIMARY KEY ( bucket_name, project_id, interval_start )
);
CREATE TABLE coinpayments_transactions (
id text NOT NULL,
user_id bytea NOT NULL,
address text NOT NULL,
amount bytea NOT NULL,
received bytea NOT NULL,
status integer NOT NULL,
key text NOT NULL,
timeout integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE coupons (
id bytea NOT NULL,
project_id bytea NOT NULL,
user_id bytea NOT NULL,
amount bigint NOT NULL,
description text NOT NULL,
type integer NOT NULL,
status integer NOT NULL,
duration bigint NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE coupon_usages (
coupon_id bytea NOT NULL,
amount bigint NOT NULL,
status integer NOT NULL,
period timestamp with time zone NOT NULL,
PRIMARY KEY ( coupon_id, period )
);
CREATE TABLE graceful_exit_progress (
node_id bytea NOT NULL,
bytes_transferred bigint NOT NULL,
pieces_transferred bigint NOT NULL,
pieces_failed bigint NOT NULL,
updated_at timestamp NOT NULL,
PRIMARY KEY ( node_id )
);
CREATE TABLE graceful_exit_transfer_queue (
node_id bytea NOT NULL,
path bytea NOT NULL,
piece_num integer NOT NULL,
root_piece_id bytea,
durability_ratio double precision NOT NULL,
queued_at timestamp NOT NULL,
requested_at timestamp,
last_failed_at timestamp,
last_failed_code integer,
failed_count integer,
finished_at timestamp,
order_limit_send_count integer NOT NULL,
PRIMARY KEY ( node_id, path, piece_num )
);
CREATE TABLE injuredsegments (
path bytea NOT NULL,
data bytea NOT NULL,
attempted timestamp,
PRIMARY KEY ( path )
);
CREATE TABLE irreparabledbs (
segmentpath bytea NOT NULL,
segmentdetail bytea NOT NULL,
pieces_lost_count bigint NOT NULL,
seg_damaged_unix_sec bigint NOT NULL,
repair_attempt_count bigint NOT NULL,
PRIMARY KEY ( segmentpath )
);
CREATE TABLE nodes (
id bytea NOT NULL,
address text NOT NULL,
last_net text NOT NULL,
protocol integer NOT NULL,
type integer NOT NULL,
email text NOT NULL,
wallet text NOT NULL,
free_bandwidth bigint NOT NULL,
free_disk bigint NOT NULL,
piece_count bigint NOT NULL,
major bigint NOT NULL,
minor bigint NOT NULL,
patch bigint NOT NULL,
hash text NOT NULL,
timestamp timestamp with time zone NOT NULL,
release boolean NOT NULL,
latency_90 bigint NOT NULL,
audit_success_count bigint NOT NULL,
total_audit_count bigint NOT NULL,
uptime_success_count bigint NOT NULL,
total_uptime_count bigint NOT NULL,
created_at timestamp with time zone NOT NULL,
updated_at timestamp with time zone NOT NULL,
last_contact_success timestamp with time zone NOT NULL,
last_contact_failure timestamp with time zone NOT NULL,
contained boolean NOT NULL,
disqualified timestamp with time zone,
audit_reputation_alpha double precision NOT NULL,
audit_reputation_beta double precision NOT NULL,
uptime_reputation_alpha double precision NOT NULL,
uptime_reputation_beta double precision NOT NULL,
exit_initiated_at timestamp,
exit_loop_completed_at timestamp,
exit_finished_at timestamp,
exit_success boolean NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE nodes_offline_times (
node_id bytea NOT NULL,
tracked_at timestamp with time zone NOT NULL,
seconds integer NOT NULL,
PRIMARY KEY ( node_id, tracked_at )
);
CREATE TABLE offers (
id serial NOT NULL,
name text NOT NULL,
description text NOT NULL,
award_credit_in_cents integer NOT NULL,
invitee_credit_in_cents integer NOT NULL,
award_credit_duration_days integer,
invitee_credit_duration_days integer,
redeemable_cap integer,
expires_at timestamp with time zone NOT NULL,
created_at timestamp with time zone NOT NULL,
status integer NOT NULL,
type integer NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE peer_identities (
node_id bytea NOT NULL,
leaf_serial_number bytea NOT NULL,
chain bytea NOT NULL,
updated_at timestamp with time zone NOT NULL,
PRIMARY KEY ( node_id )
);
CREATE TABLE pending_audits (
node_id bytea NOT NULL,
piece_id bytea NOT NULL,
stripe_index bigint NOT NULL,
share_size bigint NOT NULL,
expected_share_hash bytea NOT NULL,
reverify_count bigint NOT NULL,
path bytea NOT NULL,
PRIMARY KEY ( node_id )
);
CREATE TABLE projects (
id bytea NOT NULL,
name text NOT NULL,
description text NOT NULL,
usage_limit bigint NOT NULL,
rate_limit integer,
partner_id bytea,
owner_id bytea NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE registration_tokens (
secret bytea NOT NULL,
owner_id bytea,
project_limit integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( secret ),
UNIQUE ( owner_id )
);
CREATE TABLE reported_serials (
expires_at timestamp with time zone NOT NULL,
storage_node_id bytea NOT NULL,
bucket_id bytea NOT NULL,
action integer NOT NULL,
serial_number bytea NOT NULL,
settled bigint NOT NULL,
observed_at timestamp with time zone NOT NULL,
PRIMARY KEY ( expires_at, storage_node_id, bucket_id, action, serial_number )
);
CREATE TABLE reset_password_tokens (
secret bytea NOT NULL,
owner_id bytea NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( secret ),
UNIQUE ( owner_id )
);
CREATE TABLE serial_numbers (
id serial NOT NULL,
serial_number bytea NOT NULL,
bucket_id bytea NOT NULL,
expires_at timestamp NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE storagenode_bandwidth_rollups (
storagenode_id bytea NOT NULL,
interval_start timestamp NOT NULL,
interval_seconds integer NOT NULL,
action integer NOT NULL,
allocated bigint DEFAULT 0,
settled bigint NOT NULL,
PRIMARY KEY ( storagenode_id, interval_start, action )
);
CREATE TABLE storagenode_storage_tallies (
id bigserial NOT NULL,
node_id bytea NOT NULL,
interval_end_time timestamp with time zone NOT NULL,
data_total double precision NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE stripe_customers (
user_id bytea NOT NULL,
customer_id text NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( user_id ),
UNIQUE ( customer_id )
);
CREATE TABLE stripecoinpayments_invoice_project_records (
id bytea NOT NULL,
project_id bytea NOT NULL,
storage double precision NOT NULL,
egress bigint NOT NULL,
objects bigint NOT NULL,
period_start timestamp with time zone NOT NULL,
period_end timestamp with time zone NOT NULL,
state integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id ),
UNIQUE ( project_id, period_start, period_end )
);
CREATE TABLE stripecoinpayments_tx_conversion_rates (
tx_id text NOT NULL,
rate bytea NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( tx_id )
);
CREATE TABLE users (
id bytea NOT NULL,
email text NOT NULL,
normalized_email text NOT NULL,
full_name text NOT NULL,
short_name text,
password_hash bytea NOT NULL,
status integer NOT NULL,
partner_id bytea,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE value_attributions (
project_id bytea NOT NULL,
bucket_name bytea NOT NULL,
partner_id bytea NOT NULL,
last_updated timestamp NOT NULL,
PRIMARY KEY ( project_id, bucket_name )
);
CREATE TABLE api_keys (
id bytea NOT NULL,
project_id bytea NOT NULL REFERENCES projects( id ) ON DELETE CASCADE,
head bytea NOT NULL,
name text NOT NULL,
secret bytea NOT NULL,
partner_id bytea,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id ),
UNIQUE ( head ),
UNIQUE ( name, project_id )
);
CREATE TABLE bucket_metainfos (
id bytea NOT NULL,
project_id bytea NOT NULL REFERENCES projects( id ),
name bytea NOT NULL,
partner_id bytea,
path_cipher integer NOT NULL,
created_at timestamp with time zone NOT NULL,
default_segment_size integer NOT NULL,
default_encryption_cipher_suite integer NOT NULL,
default_encryption_block_size integer NOT NULL,
default_redundancy_algorithm integer NOT NULL,
default_redundancy_share_size integer NOT NULL,
default_redundancy_required_shares integer NOT NULL,
default_redundancy_repair_shares integer NOT NULL,
default_redundancy_optimal_shares integer NOT NULL,
default_redundancy_total_shares integer NOT NULL,
PRIMARY KEY ( id ),
UNIQUE ( name, project_id )
);
CREATE TABLE project_invoice_stamps (
project_id bytea NOT NULL REFERENCES projects( id ) ON DELETE CASCADE,
invoice_id bytea NOT NULL,
start_date timestamp with time zone NOT NULL,
end_date timestamp with time zone NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( project_id, start_date, end_date ),
UNIQUE ( invoice_id )
);
CREATE TABLE project_members (
member_id bytea NOT NULL REFERENCES users( id ) ON DELETE CASCADE,
project_id bytea NOT NULL REFERENCES projects( id ) ON DELETE CASCADE,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( member_id, project_id )
);
CREATE TABLE stripecoinpayments_apply_balance_intents (
tx_id text NOT NULL REFERENCES coinpayments_transactions( id ) ON DELETE CASCADE,
state integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( tx_id )
);
CREATE TABLE used_serials (
serial_number_id integer NOT NULL REFERENCES serial_numbers( id ) ON DELETE CASCADE,
storage_node_id bytea NOT NULL,
PRIMARY KEY ( serial_number_id, storage_node_id )
);
CREATE TABLE user_credits (
id serial NOT NULL,
user_id bytea NOT NULL REFERENCES users( id ) ON DELETE CASCADE,
offer_id integer NOT NULL REFERENCES offers( id ),
referred_by bytea REFERENCES users( id ) ON DELETE SET NULL,
type text NOT NULL,
credits_earned_in_cents integer NOT NULL,
credits_used_in_cents integer NOT NULL,
expires_at timestamp with time zone NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id ),
UNIQUE ( id, offer_id )
);
CREATE TABLE credits (
user_id bytea NOT NULL,
transaction_id text NOT NULL,
amount bigint NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( transaction_id )
);
CREATE TABLE credits_spendings (
id bytea NOT NULL,
user_id bytea NOT NULL,
project_id bytea NOT NULL,
amount bigint NOT NULL,
status integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE INDEX injuredsegments_attempted_index ON injuredsegments ( attempted );
CREATE INDEX node_last_ip ON nodes ( last_net );
CREATE INDEX nodes_offline_times_node_id_index ON nodes_offline_times ( node_id );
CREATE UNIQUE INDEX serial_number ON serial_numbers ( serial_number );
CREATE INDEX serial_numbers_expires_at_index ON serial_numbers ( expires_at );
CREATE UNIQUE INDEX credits_earned_user_id_offer_id ON user_credits ( id, offer_id );
INSERT INTO "accounting_rollups"("id", "node_id", "start_time", "put_total", "get_total", "get_audit_total", "get_repair_total", "put_repair_total", "at_rest_total") VALUES (1, E'\\367M\\177\\251]t/\\022\\256\\214\\265\\025\\224\\204:\\217\\212\\0102<\\321\\374\\020&\\271Qc\\325\\261\\354\\246\\233'::bytea, '2019-02-09 00:00:00+00', 1000, 2000, 3000, 4000, 0, 5000);
INSERT INTO "accounting_timestamps" VALUES ('LastAtRestTally', '0001-01-01 00:00:00+00');
INSERT INTO "accounting_timestamps" VALUES ('LastRollup', '0001-01-01 00:00:00+00');
INSERT INTO "accounting_timestamps" VALUES ('LastBandwidthTally', '0001-01-01 00:00:00+00');
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_bandwidth", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90", "audit_success_count", "total_audit_count", "uptime_success_count", "total_uptime_count", "created_at", "updated_at", "last_contact_success", "last_contact_failure", "contained", "disqualified", "audit_reputation_alpha", "audit_reputation_beta", "uptime_reputation_alpha", "uptime_reputation_beta", "exit_success") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001', '127.0.0.1:55516', '', 0, 4, '', '', -1, -1, 0, 0, 1, 0, '', 'epoch', false, 0, 0, 5, 0, 5, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', false, NULL, 50, 0, 100, 5, false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_bandwidth", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90", "audit_success_count", "total_audit_count", "uptime_success_count", "total_uptime_count", "created_at", "updated_at", "last_contact_success", "last_contact_failure", "contained", "disqualified", "audit_reputation_alpha", "audit_reputation_beta", "uptime_reputation_alpha", "uptime_reputation_beta", "exit_success") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '127.0.0.1:55518', '', 0, 4, '', '', -1, -1, 0, 0, 1, 0, '', 'epoch', false, 0, 0, 0, 3, 3, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', false, NULL, 50, 0, 100, 0, false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_bandwidth", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90", "audit_success_count", "total_audit_count", "uptime_success_count", "total_uptime_count", "created_at", "updated_at", "last_contact_success", "last_contact_failure", "contained", "disqualified", "audit_reputation_alpha", "audit_reputation_beta", "uptime_reputation_alpha", "uptime_reputation_beta", "exit_success") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014', '127.0.0.1:55517', '', 0, 4, '', '', -1, -1, 0, 0, 1, 0, '', 'epoch', false, 0, 0, 0, 0, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', false, NULL, 50, 0, 100, 0, false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_bandwidth", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90", "audit_success_count", "total_audit_count", "uptime_success_count", "total_uptime_count", "created_at", "updated_at", "last_contact_success", "last_contact_failure", "contained", "disqualified", "audit_reputation_alpha", "audit_reputation_beta", "uptime_reputation_alpha", "uptime_reputation_beta", "exit_success") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\015', '127.0.0.1:55519', '', 0, 4, '', '', -1, -1, 0, 0, 1, 0, '', 'epoch', false, 0, 1, 2, 1, 2, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', false, NULL, 50, 0, 100, 1, false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_bandwidth", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90", "audit_success_count", "total_audit_count", "uptime_success_count", "total_uptime_count", "created_at", "updated_at", "last_contact_success", "last_contact_failure", "contained", "disqualified", "audit_reputation_alpha", "audit_reputation_beta", "uptime_reputation_alpha", "uptime_reputation_beta", "exit_success") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', '127.0.0.1:55520', '', 0, 4, '', '', -1, -1, 0, 0, 1, 0, '', 'epoch', false, 0, 300, 400, 300, 400, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', false, NULL, 300, 0, 300, 100, false);
INSERT INTO "users"("id", "full_name", "short_name", "email", "normalized_email", "password_hash", "status", "partner_id", "created_at") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 'Noahson', 'William', '1email1@mail.test', '1EMAIL1@MAIL.TEST', E'some_readable_hash'::bytea, 1, NULL, '2019-02-14 08:28:24.614594+00');
INSERT INTO "projects"("id", "name", "description", "usage_limit", "partner_id", "owner_id", "created_at") VALUES (E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, 'ProjectName', 'projects description', 0, NULL, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2019-02-14 08:28:24.254934+00');
INSERT INTO "projects"("id", "name", "description", "usage_limit", "partner_id", "owner_id", "created_at") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, 'projName1', 'Test project 1', 0, NULL, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2019-02-14 08:28:24.636949+00');
INSERT INTO "project_members"("member_id", "project_id", "created_at") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, '2019-02-14 08:28:24.677953+00');
INSERT INTO "project_members"("member_id", "project_id", "created_at") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, '2019-02-13 08:28:24.677953+00');
INSERT INTO "irreparabledbs" ("segmentpath", "segmentdetail", "pieces_lost_count", "seg_damaged_unix_sec", "repair_attempt_count") VALUES ('\x49616d5365676d656e746b6579696e666f30', '\x49616d5365676d656e7464657461696c696e666f30', 10, 1550159554, 10);
INSERT INTO "injuredsegments" ("path", "data") VALUES ('0', '\x0a0130120100');
INSERT INTO "injuredsegments" ("path", "data") VALUES ('here''s/a/great/path', '\x0a136865726527732f612f67726561742f70617468120a0102030405060708090a');
INSERT INTO "injuredsegments" ("path", "data") VALUES ('yet/another/cool/path', '\x0a157965742f616e6f746865722f636f6f6c2f70617468120a0102030405060708090a');
INSERT INTO "injuredsegments" ("path", "data") VALUES ('so/many/iconic/paths/to/choose/from', '\x0a23736f2f6d616e792f69636f6e69632f70617468732f746f2f63686f6f73652f66726f6d120a0102030405060708090a');
INSERT INTO "registration_tokens" ("secret", "owner_id", "project_limit", "created_at") VALUES (E'\\070\\127\\144\\013\\332\\344\\102\\376\\306\\056\\303\\130\\106\\132\\321\\276\\321\\274\\170\\264\\054\\333\\221\\116\\154\\221\\335\\070\\220\\146\\344\\216'::bytea, null, 1, '2019-02-14 08:28:24.677953+00');
INSERT INTO "serial_numbers" ("id", "serial_number", "bucket_id", "expires_at") VALUES (1, E'0123456701234567'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014/testbucket'::bytea, '2019-03-06 08:28:24.677953+00');
INSERT INTO "used_serials" ("serial_number_id", "storage_node_id") VALUES (1, E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n');
INSERT INTO "storagenode_bandwidth_rollups" ("storagenode_id", "interval_start", "interval_seconds", "action", "allocated", "settled") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '2019-03-06 08:00:00.000000+00', 3600, 1, 1024, 2024);
INSERT INTO "storagenode_storage_tallies" VALUES (1, E'\\3510\\323\\225"~\\036<\\342\\330m\\0253Jhr\\246\\233K\\246#\\2303\\351\\256\\275j\\212UM\\362\\207', '2019-02-14 08:16:57.812849+00', 1000);
INSERT INTO "bucket_bandwidth_rollups" ("bucket_name", "project_id", "interval_start", "interval_seconds", "action", "inline", "allocated", "settled") VALUES (E'testbucket'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea,'2019-03-06 08:00:00.000000+00', 3600, 1, 1024, 2024, 3024);
INSERT INTO "bucket_storage_tallies" ("bucket_name", "project_id", "interval_start", "inline", "remote", "remote_segments_count", "inline_segments_count", "object_count", "metadata_size") VALUES (E'testbucket'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea,'2019-03-06 08:00:00.000000+00', 4024, 5024, 0, 0, 0, 0);
INSERT INTO "bucket_bandwidth_rollups" ("bucket_name", "project_id", "interval_start", "interval_seconds", "action", "inline", "allocated", "settled") VALUES (E'testbucket'::bytea, E'\\170\\160\\157\\370\\274\\366\\113\\364\\272\\235\\301\\243\\321\\102\\321\\136'::bytea,'2019-03-06 08:00:00.000000+00', 3600, 1, 1024, 2024, 3024);
INSERT INTO "bucket_storage_tallies" ("bucket_name", "project_id", "interval_start", "inline", "remote", "remote_segments_count", "inline_segments_count", "object_count", "metadata_size") VALUES (E'testbucket'::bytea, E'\\170\\160\\157\\370\\274\\366\\113\\364\\272\\235\\301\\243\\321\\102\\321\\136'::bytea,'2019-03-06 08:00:00.000000+00', 4024, 5024, 0, 0, 0, 0);
INSERT INTO "reset_password_tokens" ("secret", "owner_id", "created_at") VALUES (E'\\070\\127\\144\\013\\332\\344\\102\\376\\306\\056\\303\\130\\106\\132\\321\\276\\321\\274\\170\\264\\054\\333\\221\\116\\154\\221\\335\\070\\220\\146\\344\\216'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2019-05-08 08:28:24.677953+00');
INSERT INTO "offers" ("id", "name", "description", "award_credit_in_cents", "invitee_credit_in_cents", "expires_at", "created_at", "status", "type", "award_credit_duration_days", "invitee_credit_duration_days") VALUES (1, 'Default referral offer', 'Is active when no other active referral offer', 300, 600, '2119-03-14 08:28:24.636949+00', '2019-07-14 08:28:24.636949+00', 1, 2, 365, 14);
INSERT INTO "offers" ("id", "name", "description", "award_credit_in_cents", "invitee_credit_in_cents", "expires_at", "created_at", "status", "type", "award_credit_duration_days", "invitee_credit_duration_days") VALUES (2, 'Default free credit offer', 'Is active when no active free credit offer', 0, 300, '2119-03-14 08:28:24.636949+00', '2019-07-14 08:28:24.636949+00', 1, 1, NULL, 14);
INSERT INTO "api_keys" ("id", "project_id", "head", "name", "secret", "partner_id", "created_at") VALUES (E'\\334/\\302;\\225\\355O\\323\\276f\\247\\354/6\\241\\033'::bytea, E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'\\111\\142\\147\\304\\132\\375\\070\\163\\270\\160\\251\\370\\126\\063\\351\\037\\257\\071\\143\\375\\351\\320\\253\\232\\220\\260\\075\\173\\306\\307\\115\\136'::bytea, 'key 2', E'\\254\\011\\315\\333\\273\\365\\001\\071\\024\\154\\253\\332\\301\\216\\361\\074\\221\\367\\251\\231\\274\\333\\300\\367\\001\\272\\327\\111\\315\\123\\042\\016'::bytea, NULL, '2019-02-14 08:28:24.267934+00');
INSERT INTO "project_invoice_stamps" ("project_id", "invoice_id", "start_date", "end_date", "created_at") VALUES (E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'\\363\\311\\033w\\222\\303,'::bytea, '2019-06-01 08:28:24.267934+00', '2019-06-29 08:28:24.267934+00', '2019-06-01 08:28:24.267934+00');
INSERT INTO "value_attributions" ("project_id", "bucket_name", "partner_id", "last_updated") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, E''::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea,'2019-02-14 08:07:31.028103+00');
INSERT INTO "user_credits" ("id", "user_id", "offer_id", "referred_by", "credits_earned_in_cents", "credits_used_in_cents", "type", "expires_at", "created_at") VALUES (1, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 1, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 200, 0, 'invalid', '2019-10-01 08:28:24.267934+00', '2019-06-01 08:28:24.267934+00');
INSERT INTO "bucket_metainfos" ("id", "project_id", "name", "partner_id", "created_at", "path_cipher", "default_segment_size", "default_encryption_cipher_suite", "default_encryption_block_size", "default_redundancy_algorithm", "default_redundancy_share_size", "default_redundancy_required_shares", "default_redundancy_repair_shares", "default_redundancy_optimal_shares", "default_redundancy_total_shares") VALUES (E'\\334/\\302;\\225\\355O\\323\\276f\\247\\354/6\\241\\033'::bytea, E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'testbucketuniquename'::bytea, NULL, '2019-06-14 08:28:24.677953+00', 1, 65536, 1, 8192, 1, 4096, 4, 6, 8, 10);
INSERT INTO "pending_audits" ("node_id", "piece_id", "stripe_index", "share_size", "expected_share_hash", "reverify_count", "path") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 5, 1024, E'\\070\\127\\144\\013\\332\\344\\102\\376\\306\\056\\303\\130\\106\\132\\321\\276\\321\\274\\170\\264\\054\\333\\221\\116\\154\\221\\335\\070\\220\\146\\344\\216'::bytea, 1, 'not null');
INSERT INTO "peer_identities" VALUES (E'\\334/\\302;\\225\\355O\\323\\276f\\247\\354/6\\241\\033'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2019-02-14 08:07:31.335028+00');
INSERT INTO "graceful_exit_progress" ("node_id", "bytes_transferred", "pieces_transferred", "pieces_failed", "updated_at") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', 1000000000000000, 0, 0, '2019-09-12 10:07:31.028103');
INSERT INTO "graceful_exit_transfer_queue" ("node_id", "path", "piece_num", "durability_ratio", "queued_at", "requested_at", "last_failed_at", "last_failed_code", "failed_count", "finished_at", "order_limit_send_count") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', E'f8419768-5baa-4901-b3ba-62808013ec45/s0/test3/\\240\\243\\223n \\334~b}\\2624)\\250m\\201\\202\\235\\276\\361\\3304\\323\\352\\311\\361\\353;\\326\\311', 8, 1.0, '2019-09-12 10:07:31.028103', '2019-09-12 10:07:32.028103', null, null, 0, '2019-09-12 10:07:33.028103', 0);
INSERT INTO "graceful_exit_transfer_queue" ("node_id", "path", "piece_num", "durability_ratio", "queued_at", "requested_at", "last_failed_at", "last_failed_code", "failed_count", "finished_at", "order_limit_send_count") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', E'f8419768-5baa-4901-b3ba-62808013ec45/s0/test3/\\240\\243\\223n \\334~b}\\2624)\\250m\\201\\202\\235\\276\\361\\3304\\323\\352\\311\\361\\353;\\326\\312', 8, 1.0, '2019-09-12 10:07:31.028103', '2019-09-12 10:07:32.028103', null, null, 0, '2019-09-12 10:07:33.028103', 0);
INSERT INTO "stripe_customers" ("user_id", "customer_id", "created_at") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 'stripe_id', '2019-06-01 08:28:24.267934+00');
INSERT INTO "graceful_exit_transfer_queue" ("node_id", "path", "piece_num", "durability_ratio", "queued_at", "requested_at", "last_failed_at", "last_failed_code", "failed_count", "finished_at", "order_limit_send_count") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', E'f8419768-5baa-4901-b3ba-62808013ec45/s0/test3/\\240\\243\\223n \\334~b}\\2624)\\250m\\201\\202\\235\\276\\361\\3304\\323\\352\\311\\361\\353;\\326\\311', 9, 1.0, '2019-09-12 10:07:31.028103', '2019-09-12 10:07:32.028103', null, null, 0, '2019-09-12 10:07:33.028103', 0);
INSERT INTO "graceful_exit_transfer_queue" ("node_id", "path", "piece_num", "durability_ratio", "queued_at", "requested_at", "last_failed_at", "last_failed_code", "failed_count", "finished_at", "order_limit_send_count") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', E'f8419768-5baa-4901-b3ba-62808013ec45/s0/test3/\\240\\243\\223n \\334~b}\\2624)\\250m\\201\\202\\235\\276\\361\\3304\\323\\352\\311\\361\\353;\\326\\312', 9, 1.0, '2019-09-12 10:07:31.028103', '2019-09-12 10:07:32.028103', null, null, 0, '2019-09-12 10:07:33.028103', 0);
INSERT INTO "stripecoinpayments_invoice_project_records"("id", "project_id", "storage", "egress", "objects", "period_start", "period_end", "state", "created_at") VALUES (E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'\\021\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, 0, 0, 0, '2019-06-01 08:28:24.267934+00', '2019-06-01 08:28:24.267934+00', 0, '2019-06-01 08:28:24.267934+00');
INSERT INTO "graceful_exit_transfer_queue" ("node_id", "path", "piece_num", "root_piece_id", "durability_ratio", "queued_at", "requested_at", "last_failed_at", "last_failed_code", "failed_count", "finished_at", "order_limit_send_count") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', E'f8419768-5baa-4901-b3ba-62808013ec45/s0/test3/\\240\\243\\223n \\334~b}\\2624)\\250m\\201\\202\\235\\276\\361\\3304\\323\\352\\311\\361\\353;\\326\\311', 10, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 1.0, '2019-09-12 10:07:31.028103', '2019-09-12 10:07:32.028103', null, null, 0, '2019-09-12 10:07:33.028103', 0);
INSERT INTO "stripecoinpayments_tx_conversion_rates" ("tx_id", "rate", "created_at") VALUES ('tx_id', E'\\363\\311\\033w\\222\\303Ci,'::bytea, '2019-06-01 08:28:24.267934+00');
INSERT INTO "coinpayments_transactions" ("id", "user_id", "address", "amount", "received", "status", "key", "timeout", "created_at") VALUES ('tx_id', E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 'address', E'\\363\\311\\033w'::bytea, E'\\363\\311\\033w'::bytea, 1, 'key', 60, '2019-06-01 08:28:24.267934+00');
INSERT INTO "nodes_offline_times" ("node_id", "tracked_at", "seconds") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001'::bytea, '2019-06-01 09:28:24.267934+00', 3600);
INSERT INTO "nodes_offline_times" ("node_id", "tracked_at", "seconds") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001'::bytea, '2017-06-01 09:28:24.267934+00', 100);
INSERT INTO "nodes_offline_times" ("node_id", "tracked_at", "seconds") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n'::bytea, '2019-06-01 09:28:24.267934+00', 3600);
INSERT INTO "storagenode_bandwidth_rollups" ("storagenode_id", "interval_start", "interval_seconds", "action", "settled") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '2020-01-11 08:00:00.000000+00', 3600, 1, 2024);
INSERT INTO "coupons" ("id", "project_id", "user_id", "amount", "description", "type", "status", "duration", "created_at") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 50, 'description', 0, 0, 2, '2019-06-01 08:28:24.267934+00');
INSERT INTO "coupon_usages" ("coupon_id", "amount", "status", "period") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, 22, 0, '2019-06-01 09:28:24.267934+00');
INSERT INTO "reported_serials" ("expires_at", "storage_node_id", "bucket_id", "action", "serial_number", "settled", "observed_at") VALUES ('2020-01-11 08:00:00.000000+00', E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014/testbucket'::bytea, 1, E'0123456701234567'::bytea, 100, '2020-01-11 08:00:00.000000+00');
INSERT INTO "stripecoinpayments_apply_balance_intents" ("tx_id", "state", "created_at") VALUES ('tx_id', 0, '2019-06-01 08:28:24.267934+00');
INSERT INTO "projects"("id", "name", "description", "usage_limit", "rate_limit", "partner_id", "owner_id", "created_at") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\347'::bytea, 'projName1', 'Test project 1', 0, 2000000, NULL, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2020-01-15 08:28:24.636949+00');
-- NEW DATA --
INSERT INTO "credits" ("user_id", "transaction_id", "amount", "created_at") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, 'transactionID', 10, '2019-06-01 08:28:24.267934+00');
INSERT INTO "credits_spendings" ("id", "user_id", "project_id", "amount", "status", "created_at") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\275|\\342N\\347\\014'::bytea, E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 5, 0, '2019-06-01 09:28:24.267934+00');

View File

@ -373,6 +373,9 @@ identity.key-path: /root/.local/share/storj/identity/satellite/identity.key
# number of update requests to process per transaction
# overlay.update-stats-batch-size: 100
# amount of percents that user will earn as bonus credits by depositing in STORJ tokens
# payments.bonus-rate: 10
# price user should pay for each TB of egress
# payments.egress-tb-price: "45"