JakeHillion/storj
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

satellite/payments: update account balance (#3379)

Browse Source
This commit is contained in:
Yaroslav Vorobiov 2019-10-29 18:04:34 +02:00 committed by GitHub
parent 8786a37f89
commit 30a3205745
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 1068 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
satellite/api.go
View File

@ -370,13 +370,12 @@ func NewAPI(log *zap.Logger, full *identity.FullIdentity, db DB, pointerDB metai
peer.DB.Customers(), peer.DB.Customers(),
peer.DB.CoinpaymentsTransactions()) peer.DB.CoinpaymentsTransactions())
clearing := stripecoinpayments.NewClearing( peer.Payments.Accounts = service.Accounts()
peer.Payments.Clearing = stripecoinpayments.NewChore(
peer.Log.Named("stripecoinpayments clearing loop"), peer.Log.Named("stripecoinpayments clearing loop"),
service, service,
config.StripeCoinPayments.TransactionUpdateInterval) config.StripeCoinPayments.TransactionUpdateInterval,
config.StripeCoinPayments.AccountBalanceUpdateInterval)
peer.Payments.Accounts = service.Accounts()
peer.Payments.Clearing = clearing
} }
{ // setup console { // setup console

63
satellite/payments/stripecoinpayments/clearing.go
View File

@ -9,53 +9,72 @@ import (
"github.com/zeebo/errs" "github.com/zeebo/errs"
"go.uber.org/zap" "go.uber.org/zap"
"golang.org/x/sync/errgroup"
"storj.io/storj/internal/sync2" "storj.io/storj/internal/sync2"
) )
// ErrClearing is stripecoinpayments clearing loop error class. // ErrChore is stripecoinpayments clearing loop chore error class.
var ErrClearing = errs.Class("stripecoinpayments clearing error") var ErrChore = errs.Class("stripecoinpayments chore error")
// Clearing runs process of reconciling transactions deposits, // Chore runs clearing process of reconciling transactions deposits,
// customer balance, invoices and usages. // customer balance, invoices and usages.
type Clearing struct { //
log *zap.Logger // architecture: Chore
service *Service type Chore struct {
TransactionCycle sync2.Cycle log *zap.Logger
service *Service
TransactionCycle sync2.Cycle
AccountBalanceCycle sync2.Cycle
} }
// NewClearing creates new clearing loop. // NewChore creates new clearing loop chore.
func NewClearing(log *zap.Logger, service *Service, txInterval time.Duration) *Clearing { func NewChore(log *zap.Logger, service *Service, txInterval time.Duration, accBalanceInterval time.Duration) *Chore {
return &Clearing{ return &Chore{
log: log, log: log,
service: service, service: service,
TransactionCycle: *sync2.NewCycle(txInterval), TransactionCycle: *sync2.NewCycle(txInterval),
AccountBalanceCycle: *sync2.NewCycle(accBalanceInterval),
} }
} }
// Run runs all clearing related cycles. // Run runs all clearing related cycles.
func (clearing *Clearing) Run(ctx context.Context) (err error) { func (chore *Chore) Run(ctx context.Context) (err error) {
defer mon.Task()(&ctx)(&err) defer mon.Task()(&ctx)(&err)
err = clearing.TransactionCycle.Run(ctx, var group errgroup.Group
func(ctx context.Context) error {
clearing.log.Info("running transactions update cycle")
if err := clearing.service.updateTransactionsLoop(ctx); err != nil { chore.TransactionCycle.Start(ctx, &group,
clearing.log.Error("transaction update cycle failed", zap.Error(ErrClearing.Wrap(err))) func(ctx context.Context) error {
chore.log.Info("running transactions update cycle")
if err := chore.service.updateTransactionsLoop(ctx); err != nil {
chore.log.Error("transaction update cycle failed", zap.Error(ErrChore.Wrap(err)))
}
return nil
},
)
chore.AccountBalanceCycle.Start(ctx, &group,
func(ctx context.Context) error {
chore.log.Info("running account balance update cycle")
if err := chore.service.updateAccountBalanceLoop(ctx); err != nil {
chore.log.Error("account balance update cycle failed", zap.Error(ErrChore.Wrap(err)))
} }
return nil return nil
}, },
) )
return ErrClearing.Wrap(err) return ErrChore.Wrap(group.Wait())
} }
// Close closes all underlying resources. // Close closes all underlying resources.
func (clearing *Clearing) Close() (err error) { func (chore *Chore) Close() (err error) {
defer mon.Task()(nil)(&err) defer mon.Task()(nil)(&err)
clearing.TransactionCycle.Close() chore.TransactionCycle.Close()
chore.AccountBalanceCycle.Close()
return nil return nil
} }

109
satellite/payments/stripecoinpayments/service.go
View File

@ -7,6 +7,7 @@ import (
"context" "context"
"time" "time"
"github.com/stripe/stripe-go"
"github.com/stripe/stripe-go/client" "github.com/stripe/stripe-go/client"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"go.uber.org/zap" "go.uber.org/zap"
@ -23,10 +24,11 @@ var Error = errs.Class("stripecoinpayments service error")
// Config stores needed information for payment service initialization. // Config stores needed information for payment service initialization.
type Config struct { type Config struct {
StripeSecretKey string `help:"stripe API secret key" default:""` StripeSecretKey string `help:"stripe API secret key" default:""`
CoinpaymentsPublicKey string `help:"coinpayments API public key" default:""` CoinpaymentsPublicKey string `help:"coinpayments API public key" default:""`
CoinpaymentsPrivateKey string `help:"coinpayments API preivate key key" default:""` CoinpaymentsPrivateKey string `help:"coinpayments API preivate key key" default:""`
TransactionUpdateInterval time.Duration `help:"amount of time we wait before running next transaction update loop" devDefault:"1m" releaseDefault:"30m"` TransactionUpdateInterval time.Duration `help:"amount of time we wait before running next transaction update loop" devDefault:"1m" releaseDefault:"30m"`
AccountBalanceUpdateInterval time.Duration `help:"amount of time we wait before running next account balance update loop" devDefault:"3m" releaseDefault:"1h30m"`
} }
// Service is an implementation for payment service via Stripe and Coinpayments. // Service is an implementation for payment service via Stripe and Coinpayments.
@ -67,10 +69,7 @@ func (service *Service) Accounts() payments.Accounts {
func (service *Service) updateTransactionsLoop(ctx context.Context) (err error) { func (service *Service) updateTransactionsLoop(ctx context.Context) (err error) {
defer mon.Task()(&ctx)(&err) defer mon.Task()(&ctx)(&err)
const ( const limit = 25
limit = 25
)
before := time.Now() before := time.Now()
txsPage, err := service.transactionsDB.ListPending(ctx, 0, limit, before) txsPage, err := service.transactionsDB.ListPending(ctx, 0, limit, before)
@ -83,10 +82,8 @@ func (service *Service) updateTransactionsLoop(ctx context.Context) (err error)
} }
for txsPage.Next { for txsPage.Next {
select { if err = ctx.Err(); err != nil {
case <-ctx.Done(): return err
return ctx.Err()
default:
} }
txsPage, err = service.transactionsDB.ListPending(ctx, txsPage.NextOffset, limit, before) txsPage, err = service.transactionsDB.ListPending(ctx, txsPage.NextOffset, limit, before)
@ -117,6 +114,8 @@ func (service *Service) updateTransactions(ctx context.Context, ids coinpayments
} }
var updates []TransactionUpdate var updates []TransactionUpdate
var applies coinpayments.TransactionIDList
for id, info := range infos { for id, info := range infos {
updates = append(updates, updates = append(updates,
TransactionUpdate{ TransactionUpdate{
@ -126,8 +125,90 @@ func (service *Service) updateTransactions(ctx context.Context, ids coinpayments
}, },
) )
// TODO: update stripe customer balance // moment of transition to received state, which indicates
// that customer funds were accepted, so we can apply this
// amount to customer balance. So we create intent to update
// customer balance in the future.
if info.Status == coinpayments.StatusReceived {
applies = append(applies, id)
}
} }
return service.transactionsDB.Update(ctx, updates) return service.transactionsDB.Update(ctx, updates, applies)
}
// applyAccountBalanceLoop fetches all unapplied transaction in a loop, applying transaction
// received amount to stripe customer balance.
func (service *Service) updateAccountBalanceLoop(ctx context.Context) (err error) {
defer mon.Task()(&ctx)(&err)
const limit = 25
before := time.Now()
txsPage, err := service.transactionsDB.ListUnapplied(ctx, 0, limit, before)
if err != nil {
return err
}
for _, tx := range txsPage.Transactions {
if err = ctx.Err(); err != nil {
return err
}
if err = service.applyTransactionBalance(ctx, tx); err != nil {
return err
}
}
for txsPage.Next {
if err = ctx.Err(); err != nil {
return err
}
txsPage, err := service.transactionsDB.ListUnapplied(ctx, txsPage.NextOffset, limit, before)
if err != nil {
return err
}
for _, tx := range txsPage.Transactions {
if err = ctx.Err(); err != nil {
return err
}
if err = service.applyTransactionBalance(ctx, tx); err != nil {
return err
}
}
}
return nil
}
// applyTransactionBalance applies transaction received amount to stripe customer balance.
func (service *Service) applyTransactionBalance(ctx context.Context, tx Transaction) (err error) {
defer mon.Task()(&ctx)(&err)
cusID, err := service.customers.GetCustomerID(ctx, tx.AccountID)
if err != nil {
return err
}
if err = service.transactionsDB.Consume(ctx, tx.ID); err != nil {
return err
}
// TODO: add conversion logic
amount, _ := tx.Received.Int64()
params := &stripe.CustomerBalanceTransactionParams{
Amount: stripe.Int64(amount),
Customer: stripe.String(cusID),
Currency: stripe.String(string(stripe.CurrencyUSD)),
Description: stripe.String("storj token deposit"),
}
params.AddMetadata("txID", tx.ID.String())
_, err = service.stripeClient.CustomerBalanceTransactions.New(params)
return err
} }

6
satellite/payments/stripecoinpayments/transactions.go
View File

@ -21,9 +21,13 @@ type TransactionsDB interface {
// Insert inserts new coinpayments transaction into DB. // Insert inserts new coinpayments transaction into DB.
Insert(ctx context.Context, tx Transaction) (*Transaction, error) Insert(ctx context.Context, tx Transaction) (*Transaction, error)
// Update updates status and received for set of transactions. // Update updates status and received for set of transactions.
Update(ctx context.Context, updates []TransactionUpdate) error Update(ctx context.Context, updates []TransactionUpdate, applies coinpayments.TransactionIDList) error
// Consume marks transaction as consumed, so it won't participate in apply account balance loop.
Consume(ctx context.Context, id coinpayments.TransactionID) error
// ListPending returns TransactionsPage with pending transactions. // ListPending returns TransactionsPage with pending transactions.
ListPending(ctx context.Context, offset int64, limit int, before time.Time) (TransactionsPage, error) ListPending(ctx context.Context, offset int64, limit int, before time.Time) (TransactionsPage, error)
// List Unapplied returns TransactionsPage with transactions completed transaction that should be applied to account balance.
ListUnapplied(ctx context.Context, offset int64, limit int, before time.Time) (TransactionsPage, error)
} }
// Transaction defines coinpayments transaction info that is stored in the DB. // Transaction defines coinpayments transaction info that is stored in the DB.

160
satellite/payments/stripecoinpayments/transactions_test.go
View File

@ -22,7 +22,7 @@ import (
"storj.io/storj/satellite/satellitedb/satellitedbtest" "storj.io/storj/satellite/satellitedb/satellitedbtest"
) )
func TestInsertUpdate(t *testing.T) { func TestInsertUpdateConsume(t *testing.T) {
satellitedbtest.Run(t, func(t *testing.T, db satellite.DB) { satellitedbtest.Run(t, func(t *testing.T, db satellite.DB) {
ctx := testcontext.New(t) ctx := testcontext.New(t)
defer ctx.Cleanup() defer ctx.Cleanup()
@ -62,7 +62,7 @@ func TestInsertUpdate(t *testing.T) {
Received: *received, Received: *received,
} }
err := transactions.Update(ctx, []stripecoinpayments.TransactionUpdate{update}) err := transactions.Update(ctx, []stripecoinpayments.TransactionUpdate{update}, nil)
require.NoError(t, err) require.NoError(t, err)
page, err := transactions.ListPending(ctx, 0, 1, time.Now()) page, err := transactions.ListPending(ctx, 0, 1, time.Now())
@ -73,60 +73,136 @@ func TestInsertUpdate(t *testing.T) {
assert.Equal(t, createTx.ID, page.Transactions[0].ID) assert.Equal(t, createTx.ID, page.Transactions[0].ID)
assert.Equal(t, update.Received, page.Transactions[0].Received) assert.Equal(t, update.Received, page.Transactions[0].Received)
assert.Equal(t, update.Status, page.Transactions[0].Status) assert.Equal(t, update.Status, page.Transactions[0].Status)
err = transactions.Update(ctx,
[]stripecoinpayments.TransactionUpdate{
{
TransactionID: createTx.ID,
Status: coinpayments.StatusReceived,
Received: *received,
},
},
coinpayments.TransactionIDList{
createTx.ID,
},
)
require.NoError(t, err)
page, err = transactions.ListUnapplied(ctx, 0, 1, time.Now())
require.NoError(t, err)
require.NotNil(t, page.Transactions)
require.Equal(t, 1, len(page.Transactions))
assert.Equal(t, createTx.ID, page.Transactions[0].ID)
assert.Equal(t, update.Received, page.Transactions[0].Received)
assert.Equal(t, coinpayments.StatusReceived, page.Transactions[0].Status)
})
t.Run("consume", func(t *testing.T) {
err := transactions.Consume(ctx, createTx.ID)
require.NoError(t, err)
page, err := transactions.ListUnapplied(ctx, 0, 1, time.Now())
require.NoError(t, err)
assert.Nil(t, page.Transactions)
assert.Equal(t, 0, len(page.Transactions))
}) })
}) })
} }
func TestList(t *testing.T) { func TestList(t *testing.T) {
satellitedbtest.Run(t, func(t *testing.T, db satellite.DB) { ctx := testcontext.New(t)
ctx := testcontext.New(t) defer ctx.Cleanup()
defer ctx.Cleanup()
transactions := db.CoinpaymentsTransactions() const (
transactionCount = 10
)
const ( // create transactions
transactionCount = 10 amount, ok := new(big.Float).SetPrec(1000).SetString("4.0000000000000000005")
) require.True(t, ok)
received, ok := new(big.Float).SetPrec(1000).SetString("5.0000000000000000003")
require.True(t, ok)
// create transactions var txs []stripecoinpayments.Transaction
amount, ok := new(big.Float).SetPrec(1000).SetString("4.0000000000000000005") for i := 0; i < transactionCount; i++ {
require.True(t, ok) id := base64.StdEncoding.EncodeToString(testrand.Bytes(4 * memory.B))
received, ok := new(big.Float).SetPrec(1000).SetString("5.0000000000000000003") addr := base64.StdEncoding.EncodeToString(testrand.Bytes(4 * memory.B))
require.True(t, ok) key := base64.StdEncoding.EncodeToString(testrand.Bytes(4 * memory.B))
var txs []stripecoinpayments.Transaction createTX := stripecoinpayments.Transaction{
for i := 0; i < transactionCount; i++ { ID: coinpayments.TransactionID(id),
id := base64.StdEncoding.EncodeToString(testrand.Bytes(4 * memory.B)) AccountID: uuid.UUID{},
addr := base64.StdEncoding.EncodeToString(testrand.Bytes(4 * memory.B)) Address: addr,
key := base64.StdEncoding.EncodeToString(testrand.Bytes(4 * memory.B)) Amount: *amount,
Received: *received,
createTX := stripecoinpayments.Transaction{ Status: coinpayments.StatusPending,
ID: coinpayments.TransactionID(id), Key: key,
AccountID: uuid.UUID{},
Address: addr,
Amount: *amount,
Received: *received,
Status: coinpayments.StatusPending,
Key: key,
}
_, err := transactions.Insert(ctx, createTX)
require.NoError(t, err)
txs = append(txs, createTX)
} }
page, err := transactions.ListPending(ctx, 0, transactionCount, time.Now()) txs = append(txs, createTX)
require.NoError(t, err) }
require.Equal(t, transactionCount, len(page.Transactions)) t.Run("pending transactions", func(t *testing.T) {
satellitedbtest.Run(t, func(t *testing.T, db satellite.DB) {
for _, tx := range txs {
_, err := db.CoinpaymentsTransactions().Insert(ctx, tx)
require.NoError(t, err)
}
for _, act := range page.Transactions { page, err := db.CoinpaymentsTransactions().ListPending(ctx, 0, transactionCount, time.Now())
for _, exp := range txs { require.NoError(t, err)
if act.ID == exp.ID { require.Equal(t, transactionCount, len(page.Transactions))
compareTransactions(t, exp, act)
for _, act := range page.Transactions {
for _, exp := range txs {
if act.ID == exp.ID {
compareTransactions(t, exp, act)
}
} }
} }
} })
})
t.Run("unapplied transaction", func(t *testing.T) {
satellitedbtest.Run(t, func(t *testing.T, db satellite.DB) {
var updatedTxs []stripecoinpayments.Transaction
var updates []stripecoinpayments.TransactionUpdate
var applies coinpayments.TransactionIDList
for _, tx := range txs {
_, err := db.CoinpaymentsTransactions().Insert(ctx, tx)
require.NoError(t, err)
tx.Status = coinpayments.StatusReceived
updates = append(updates,
stripecoinpayments.TransactionUpdate{
TransactionID: tx.ID,
Status: tx.Status,
Received: tx.Received,
},
)
applies = append(applies, tx.ID)
updatedTxs = append(updatedTxs, tx)
}
err := db.CoinpaymentsTransactions().Update(ctx, updates, applies)
require.NoError(t, err)
page, err := db.CoinpaymentsTransactions().ListUnapplied(ctx, 0, transactionCount, time.Now())
require.NoError(t, err)
require.Equal(t, transactionCount, len(page.Transactions))
for _, act := range page.Transactions {
for _, exp := range updatedTxs {
if act.ID == exp.ID {
compareTransactions(t, exp, act)
}
}
}
})
}) })
} }

9
satellite/peer.go
View File

@ -597,13 +597,12 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB, pointerDB metainfo
peer.DB.Customers(), peer.DB.Customers(),
peer.DB.CoinpaymentsTransactions()) peer.DB.CoinpaymentsTransactions())
clearing := stripecoinpayments.NewClearing( peer.Payments.Accounts = service.Accounts()
peer.Payments.Clearing = stripecoinpayments.NewChore(
peer.Log.Named("stripecoinpayments clearing loop"), peer.Log.Named("stripecoinpayments clearing loop"),
service, service,
config.StripeCoinPayments.TransactionUpdateInterval) config.StripeCoinPayments.TransactionUpdateInterval,
config.StripeCoinPayments.AccountBalanceUpdateInterval)
peer.Payments.Accounts = service.Accounts()
peer.Payments.Clearing = clearing
} }
{ // setup console { // setup console

119
satellite/satellitedb/coinpaymentstxs.go
View File

@ -18,6 +18,21 @@ import (
// ensure that coinpaymentsTransaction implements stripecoinpayments.TransactionsDB. // ensure that coinpaymentsTransaction implements stripecoinpayments.TransactionsDB.
var _ stripecoinpayments.TransactionsDB = (*coinpaymentsTransactions)(nil) var _ stripecoinpayments.TransactionsDB = (*coinpaymentsTransactions)(nil)
// applyBalanceIntentState defines states of the apply balance intents.
type applyBalanceIntentState int
const (
// apply balance intent waits to be applied.
applyBalanceIntentStateUnapplied applyBalanceIntentState = 0
// transaction which balance intent points to has been consumed.
applyBalanceIntentStateConsumed applyBalanceIntentState = 1
)
// Int returns intent state as int.
func (intent applyBalanceIntentState) Int() int {
return int(intent)
}
// coinpaymentsTransactions is Coinpayments transactions DB. // coinpaymentsTransactions is Coinpayments transactions DB.
// //
// architecture: Database // architecture: Database
@ -53,7 +68,7 @@ func (db *coinpaymentsTransactions) Insert(ctx context.Context, tx stripecoinpay
} }
// Update updates status and received for set of transactions. // Update updates status and received for set of transactions.
func (db *coinpaymentsTransactions) Update(ctx context.Context, updates []stripecoinpayments.TransactionUpdate) error { func (db *coinpaymentsTransactions) Update(ctx context.Context, updates []stripecoinpayments.TransactionUpdate, applies coinpayments.TransactionIDList) error {
if len(updates) == 0 { if len(updates) == 0 {
return nil return nil
} }
@ -77,10 +92,30 @@ func (db *coinpaymentsTransactions) Update(ctx context.Context, updates []stripe
} }
} }
for _, txID := range applies {
_, err := tx.Create_StripecoinpaymentsApplyBalanceIntent(ctx,
dbx.StripecoinpaymentsApplyBalanceIntent_TxId(txID.String()),
dbx.StripecoinpaymentsApplyBalanceIntent_State(applyBalanceIntentStateUnapplied.Int()))
if err != nil {
return err
}
}
return nil return nil
}) })
} }
// Consume marks transaction as consumed, so it won't participate in apply account balance loop.
func (db *coinpaymentsTransactions) Consume(ctx context.Context, id coinpayments.TransactionID) error {
_, err := db.db.Update_StripecoinpaymentsApplyBalanceIntent_By_TxId(ctx,
dbx.StripecoinpaymentsApplyBalanceIntent_TxId(id.String()),
dbx.StripecoinpaymentsApplyBalanceIntent_Update_Fields{
State: dbx.StripecoinpaymentsApplyBalanceIntent_State(applyBalanceIntentStateConsumed.Int()),
},
)
return err
}
// ListPending returns paginated list of pending transactions. // ListPending returns paginated list of pending transactions.
func (db *coinpaymentsTransactions) ListPending(ctx context.Context, offset int64, limit int, before time.Time) (stripecoinpayments.TransactionsPage, error) { func (db *coinpaymentsTransactions) ListPending(ctx context.Context, offset int64, limit int, before time.Time) (stripecoinpayments.TransactionsPage, error) {
var page stripecoinpayments.TransactionsPage var page stripecoinpayments.TransactionsPage
@ -117,6 +152,88 @@ func (db *coinpaymentsTransactions) ListPending(ctx context.Context, offset int6
return page, nil return page, nil
} }
// List Unapplied returns TransactionsPage with transactions completed transaction that should be applied to account balance.
func (db *coinpaymentsTransactions) ListUnapplied(ctx context.Context, offset int64, limit int, before time.Time) (_ stripecoinpayments.TransactionsPage, err error) {
query := db.db.Rebind(`SELECT
txs.id,
txs.user_id,
txs.address,
txs.amount,
txs.received,
txs.key,
txs.created_at
FROM coinpayments_transactions as txs
INNER JOIN stripecoinpayments_apply_balance_intents as ints
ON txs.id = ints.tx_id
WHERE txs.status = ?
AND txs.created_at <= ?
AND ints.state = ?
ORDER by txs.created_at DESC
LIMIT ? OFFSET ?`)
rows, err := db.db.QueryContext(ctx, query, coinpayments.StatusReceived, before, applyBalanceIntentStateUnapplied, limit+1, offset)
if err != nil {
return stripecoinpayments.TransactionsPage{}, err
}
defer func() {
err = errs.Combine(err, rows.Close())
}()
var page stripecoinpayments.TransactionsPage
for rows.Next() {
var id, address string
var userIDB []byte
var amountB, receivedB []byte
var key string
var createdAt time.Time
err := rows.Scan(&id, &userIDB, &address, &amountB, &receivedB, &key, &createdAt)
if err != nil {
return stripecoinpayments.TransactionsPage{}, err
}
userID, err := bytesToUUID(userIDB)
if err != nil {
return stripecoinpayments.TransactionsPage{}, errs.Wrap(err)
}
var amount, received big.Float
if err := amount.GobDecode(amountB); err != nil {
return stripecoinpayments.TransactionsPage{}, errs.Wrap(err)
}
if err := received.GobDecode(receivedB); err != nil {
return stripecoinpayments.TransactionsPage{}, errs.Wrap(err)
}
page.Transactions = append(page.Transactions,
stripecoinpayments.Transaction{
ID: coinpayments.TransactionID(id),
AccountID: userID,
Address: address,
Amount: amount,
Received: received,
Status: coinpayments.StatusReceived,
Key: key,
CreatedAt: createdAt,
},
)
}
if err = rows.Err(); err != nil {
return stripecoinpayments.TransactionsPage{}, err
}
if len(page.Transactions) == limit+1 {
page.Next = true
page.NextOffset = offset + int64(limit) + 1
page.Transactions = page.Transactions[:len(page.Transactions)-1]
}
return page, nil
}
// fromDBXCoinpaymentsTransaction converts *dbx.CoinpaymentsTransaction to *stripecoinpayments.Transaction. // fromDBXCoinpaymentsTransaction converts *dbx.CoinpaymentsTransaction to *stripecoinpayments.Transaction.
func fromDBXCoinpaymentsTransaction(dbxCPTX *dbx.CoinpaymentsTransaction) (*stripecoinpayments.Transaction, error) { func fromDBXCoinpaymentsTransaction(dbxCPTX *dbx.CoinpaymentsTransaction) (*stripecoinpayments.Transaction, error) {
userID, err := bytesToUUID(dbxCPTX.UserId) userID, err := bytesToUUID(dbxCPTX.UserId)

18
satellite/satellitedb/dbx/satellitedb.dbx
View File

@ -920,3 +920,21 @@ read limitoffset (
where coinpayments_transaction.status = ? where coinpayments_transaction.status = ?
orderby desc coinpayments_transaction.created_at orderby desc coinpayments_transaction.created_at
) )
model stripecoinpayments_apply_balance_intent (
key tx_id
field tx_id coinpayments_transaction.id cascade
field state int ( updatable )
field created_at timestamp ( autoinsert )
)
create stripecoinpayments_apply_balance_intent ()
update stripecoinpayments_apply_balance_intent (
where stripecoinpayments_apply_balance_intent.tx_id = ?
)
delete stripecoinpayments_apply_balance_intent (
where stripecoinpayments_apply_balance_intent.tx_id = ?
)

224
satellite/satellitedb/dbx/satellitedb.dbx.go
View File

@ -556,6 +556,12 @@ CREATE TABLE project_members (
created_at timestamp with time zone NOT NULL, created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( member_id, project_id ) 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 ( CREATE TABLE used_serials (
serial_number_id integer NOT NULL REFERENCES serial_numbers( id ) ON DELETE CASCADE, serial_number_id integer NOT NULL REFERENCES serial_numbers( id ) ON DELETE CASCADE,
storage_node_id bytea NOT NULL, storage_node_id bytea NOT NULL,
@ -5343,6 +5349,77 @@ func (f ProjectMember_CreatedAt_Field) value() interface{} {
func (ProjectMember_CreatedAt_Field) _Column() string { return "created_at" } func (ProjectMember_CreatedAt_Field) _Column() string { return "created_at" }
type StripecoinpaymentsApplyBalanceIntent struct {
TxId string
State int
CreatedAt time.Time
}
func (StripecoinpaymentsApplyBalanceIntent) _Table() string {
return "stripecoinpayments_apply_balance_intents"
}
type StripecoinpaymentsApplyBalanceIntent_Update_Fields struct {
State StripecoinpaymentsApplyBalanceIntent_State_Field
}
type StripecoinpaymentsApplyBalanceIntent_TxId_Field struct {
_set bool
_null bool
_value string
}
func StripecoinpaymentsApplyBalanceIntent_TxId(v string) StripecoinpaymentsApplyBalanceIntent_TxId_Field {
return StripecoinpaymentsApplyBalanceIntent_TxId_Field{_set: true, _value: v}
}
func (f StripecoinpaymentsApplyBalanceIntent_TxId_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (StripecoinpaymentsApplyBalanceIntent_TxId_Field) _Column() string { return "tx_id" }
type StripecoinpaymentsApplyBalanceIntent_State_Field struct {
_set bool
_null bool
_value int
}
func StripecoinpaymentsApplyBalanceIntent_State(v int) StripecoinpaymentsApplyBalanceIntent_State_Field {
return StripecoinpaymentsApplyBalanceIntent_State_Field{_set: true, _value: v}
}
func (f StripecoinpaymentsApplyBalanceIntent_State_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (StripecoinpaymentsApplyBalanceIntent_State_Field) _Column() string { return "state" }
type StripecoinpaymentsApplyBalanceIntent_CreatedAt_Field struct {
_set bool
_null bool
_value time.Time
}
func StripecoinpaymentsApplyBalanceIntent_CreatedAt(v time.Time) StripecoinpaymentsApplyBalanceIntent_CreatedAt_Field {
return StripecoinpaymentsApplyBalanceIntent_CreatedAt_Field{_set: true, _value: v}
}
func (f StripecoinpaymentsApplyBalanceIntent_CreatedAt_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (StripecoinpaymentsApplyBalanceIntent_CreatedAt_Field) _Column() string { return "created_at" }
type UsedSerial struct { type UsedSerial struct {
SerialNumberId int SerialNumberId int
StorageNodeId []byte StorageNodeId []byte
@ -6655,6 +6732,30 @@ func (obj *postgresImpl) Create_CoinpaymentsTransaction(ctx context.Context,
} }
func (obj *postgresImpl) Create_StripecoinpaymentsApplyBalanceIntent(ctx context.Context,
stripecoinpayments_apply_balance_intent_tx_id StripecoinpaymentsApplyBalanceIntent_TxId_Field,
stripecoinpayments_apply_balance_intent_state StripecoinpaymentsApplyBalanceIntent_State_Field) (
stripecoinpayments_apply_balance_intent *StripecoinpaymentsApplyBalanceIntent, err error) {
__now := obj.db.Hooks.Now().UTC()
__tx_id_val := stripecoinpayments_apply_balance_intent_tx_id.value()
__state_val := stripecoinpayments_apply_balance_intent_state.value()
__created_at_val := __now
var __embed_stmt = __sqlbundle_Literal("INSERT INTO stripecoinpayments_apply_balance_intents ( tx_id, state, created_at ) VALUES ( ?, ?, ? ) RETURNING stripecoinpayments_apply_balance_intents.tx_id, stripecoinpayments_apply_balance_intents.state, stripecoinpayments_apply_balance_intents.created_at")
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, __tx_id_val, __state_val, __created_at_val)
stripecoinpayments_apply_balance_intent = &StripecoinpaymentsApplyBalanceIntent{}
err = obj.driver.QueryRow(__stmt, __tx_id_val, __state_val, __created_at_val).Scan(&stripecoinpayments_apply_balance_intent.TxId, &stripecoinpayments_apply_balance_intent.State, &stripecoinpayments_apply_balance_intent.CreatedAt)
if err != nil {
return nil, obj.makeErr(err)
}
return stripecoinpayments_apply_balance_intent, nil
}
func (obj *postgresImpl) Get_ValueAttribution_By_ProjectId_And_BucketName(ctx context.Context, func (obj *postgresImpl) Get_ValueAttribution_By_ProjectId_And_BucketName(ctx context.Context,
value_attribution_project_id ValueAttribution_ProjectId_Field, value_attribution_project_id ValueAttribution_ProjectId_Field,
value_attribution_bucket_name ValueAttribution_BucketName_Field) ( value_attribution_bucket_name ValueAttribution_BucketName_Field) (
@ -9342,6 +9443,46 @@ func (obj *postgresImpl) Update_CoinpaymentsTransaction_By_Id(ctx context.Contex
return coinpayments_transaction, nil return coinpayments_transaction, nil
} }
func (obj *postgresImpl) Update_StripecoinpaymentsApplyBalanceIntent_By_TxId(ctx context.Context,
stripecoinpayments_apply_balance_intent_tx_id StripecoinpaymentsApplyBalanceIntent_TxId_Field,
update StripecoinpaymentsApplyBalanceIntent_Update_Fields) (
stripecoinpayments_apply_balance_intent *StripecoinpaymentsApplyBalanceIntent, err error) {
var __sets = &__sqlbundle_Hole{}
var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE stripecoinpayments_apply_balance_intents SET "), __sets, __sqlbundle_Literal(" WHERE stripecoinpayments_apply_balance_intents.tx_id = ? RETURNING stripecoinpayments_apply_balance_intents.tx_id, stripecoinpayments_apply_balance_intents.state, stripecoinpayments_apply_balance_intents.created_at")}}
__sets_sql := __sqlbundle_Literals{Join: ", "}
var __values []interface{}
var __args []interface{}
if update.State._set {
__values = append(__values, update.State.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("state = ?"))
}
if len(__sets_sql.SQLs) == 0 {
return nil, emptyUpdate()
}
__args = append(__args, stripecoinpayments_apply_balance_intent_tx_id.value())
__values = append(__values, __args...)
__sets.SQL = __sets_sql
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, __values...)
stripecoinpayments_apply_balance_intent = &StripecoinpaymentsApplyBalanceIntent{}
err = obj.driver.QueryRow(__stmt, __values...).Scan(&stripecoinpayments_apply_balance_intent.TxId, &stripecoinpayments_apply_balance_intent.State, &stripecoinpayments_apply_balance_intent.CreatedAt)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, obj.makeErr(err)
}
return stripecoinpayments_apply_balance_intent, nil
}
func (obj *postgresImpl) Delete_ValueAttribution_By_ProjectId_And_BucketName(ctx context.Context, func (obj *postgresImpl) Delete_ValueAttribution_By_ProjectId_And_BucketName(ctx context.Context,
value_attribution_project_id ValueAttribution_ProjectId_Field, value_attribution_project_id ValueAttribution_ProjectId_Field,
value_attribution_bucket_name ValueAttribution_BucketName_Field) ( value_attribution_bucket_name ValueAttribution_BucketName_Field) (
@ -9815,6 +9956,32 @@ func (obj *postgresImpl) Delete_GracefulExitTransferQueue_By_NodeId_And_Finished
} }
func (obj *postgresImpl) Delete_StripecoinpaymentsApplyBalanceIntent_By_TxId(ctx context.Context,
stripecoinpayments_apply_balance_intent_tx_id StripecoinpaymentsApplyBalanceIntent_TxId_Field) (
deleted bool, err error) {
var __embed_stmt = __sqlbundle_Literal("DELETE FROM stripecoinpayments_apply_balance_intents WHERE stripecoinpayments_apply_balance_intents.tx_id = ?")
var __values []interface{}
__values = append(__values, stripecoinpayments_apply_balance_intent_tx_id.value())
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, __values...)
__res, err := obj.driver.Exec(__stmt, __values...)
if err != nil {
return false, obj.makeErr(err)
}
__count, err := __res.RowsAffected()
if err != nil {
return false, obj.makeErr(err)
}
return __count > 0, nil
}
func (impl postgresImpl) isConstraintError(err error) ( func (impl postgresImpl) isConstraintError(err error) (
constraint string, ok bool) { constraint string, ok bool) {
if e, ok := err.(*pq.Error); ok { if e, ok := err.(*pq.Error); ok {
@ -9843,6 +10010,16 @@ func (obj *postgresImpl) deleteAll(ctx context.Context) (count int64, err error)
return 0, obj.makeErr(err) return 0, obj.makeErr(err)
} }
__count, err = __res.RowsAffected()
if err != nil {
return 0, obj.makeErr(err)
}
count += __count
__res, err = obj.driver.Exec("DELETE FROM stripecoinpayments_apply_balance_intents;")
if err != nil {
return 0, obj.makeErr(err)
}
__count, err = __res.RowsAffected() __count, err = __res.RowsAffected()
if err != nil { if err != nil {
return 0, obj.makeErr(err) return 0, obj.makeErr(err)
@ -10708,6 +10885,18 @@ func (rx *Rx) Create_StripeCustomer(ctx context.Context,
} }
func (rx *Rx) Create_StripecoinpaymentsApplyBalanceIntent(ctx context.Context,
stripecoinpayments_apply_balance_intent_tx_id StripecoinpaymentsApplyBalanceIntent_TxId_Field,
stripecoinpayments_apply_balance_intent_state StripecoinpaymentsApplyBalanceIntent_State_Field) (
stripecoinpayments_apply_balance_intent *StripecoinpaymentsApplyBalanceIntent, err error) {
var tx *Tx
if tx, err = rx.getTx(ctx); err != nil {
return
}
return tx.Create_StripecoinpaymentsApplyBalanceIntent(ctx, stripecoinpayments_apply_balance_intent_tx_id, stripecoinpayments_apply_balance_intent_state)
}
func (rx *Rx) Create_User(ctx context.Context, func (rx *Rx) Create_User(ctx context.Context,
user_id User_Id_Field, user_id User_Id_Field,
user_email User_Email_Field, user_email User_Email_Field,
@ -10920,6 +11109,16 @@ func (rx *Rx) Delete_StoragenodeStorageTally_By_Id(ctx context.Context,
return tx.Delete_StoragenodeStorageTally_By_Id(ctx, storagenode_storage_tally_id) return tx.Delete_StoragenodeStorageTally_By_Id(ctx, storagenode_storage_tally_id)
} }
func (rx *Rx) Delete_StripecoinpaymentsApplyBalanceIntent_By_TxId(ctx context.Context,
stripecoinpayments_apply_balance_intent_tx_id StripecoinpaymentsApplyBalanceIntent_TxId_Field) (
deleted bool, err error) {
var tx *Tx
if tx, err = rx.getTx(ctx); err != nil {
return
}
return tx.Delete_StripecoinpaymentsApplyBalanceIntent_By_TxId(ctx, stripecoinpayments_apply_balance_intent_tx_id)
}
func (rx *Rx) Delete_User_By_Id(ctx context.Context, func (rx *Rx) Delete_User_By_Id(ctx context.Context,
user_id User_Id_Field) ( user_id User_Id_Field) (
deleted bool, err error) { deleted bool, err error) {
@ -11515,6 +11714,17 @@ func (rx *Rx) Update_RegistrationToken_By_Secret(ctx context.Context,
return tx.Update_RegistrationToken_By_Secret(ctx, registration_token_secret, update) return tx.Update_RegistrationToken_By_Secret(ctx, registration_token_secret, update)
} }
func (rx *Rx) Update_StripecoinpaymentsApplyBalanceIntent_By_TxId(ctx context.Context,
stripecoinpayments_apply_balance_intent_tx_id StripecoinpaymentsApplyBalanceIntent_TxId_Field,
update StripecoinpaymentsApplyBalanceIntent_Update_Fields) (
stripecoinpayments_apply_balance_intent *StripecoinpaymentsApplyBalanceIntent, err error) {
var tx *Tx
if tx, err = rx.getTx(ctx); err != nil {
return
}
return tx.Update_StripecoinpaymentsApplyBalanceIntent_By_TxId(ctx, stripecoinpayments_apply_balance_intent_tx_id, update)
}
func (rx *Rx) Update_User_By_Id(ctx context.Context, func (rx *Rx) Update_User_By_Id(ctx context.Context,
user_id User_Id_Field, user_id User_Id_Field,
update User_Update_Fields) ( update User_Update_Fields) (
@ -11807,6 +12017,11 @@ type Methods interface {
stripe_customer_customer_id StripeCustomer_CustomerId_Field) ( stripe_customer_customer_id StripeCustomer_CustomerId_Field) (
stripe_customer *StripeCustomer, err error) stripe_customer *StripeCustomer, err error)
Create_StripecoinpaymentsApplyBalanceIntent(ctx context.Context,
stripecoinpayments_apply_balance_intent_tx_id StripecoinpaymentsApplyBalanceIntent_TxId_Field,
stripecoinpayments_apply_balance_intent_state StripecoinpaymentsApplyBalanceIntent_State_Field) (
stripecoinpayments_apply_balance_intent *StripecoinpaymentsApplyBalanceIntent, err error)
Create_User(ctx context.Context, Create_User(ctx context.Context,
user_id User_Id_Field, user_id User_Id_Field,
user_email User_Email_Field, user_email User_Email_Field,
@ -11899,6 +12114,10 @@ type Methods interface {
storagenode_storage_tally_id StoragenodeStorageTally_Id_Field) ( storagenode_storage_tally_id StoragenodeStorageTally_Id_Field) (
deleted bool, err error) deleted bool, err error)
Delete_StripecoinpaymentsApplyBalanceIntent_By_TxId(ctx context.Context,
stripecoinpayments_apply_balance_intent_tx_id StripecoinpaymentsApplyBalanceIntent_TxId_Field) (
deleted bool, err error)
Delete_User_By_Id(ctx context.Context, Delete_User_By_Id(ctx context.Context,
user_id User_Id_Field) ( user_id User_Id_Field) (
deleted bool, err error) deleted bool, err error)
@ -12164,6 +12383,11 @@ type Methods interface {
update RegistrationToken_Update_Fields) ( update RegistrationToken_Update_Fields) (
registration_token *RegistrationToken, err error) registration_token *RegistrationToken, err error)
Update_StripecoinpaymentsApplyBalanceIntent_By_TxId(ctx context.Context,
stripecoinpayments_apply_balance_intent_tx_id StripecoinpaymentsApplyBalanceIntent_TxId_Field,
update StripecoinpaymentsApplyBalanceIntent_Update_Fields) (
stripecoinpayments_apply_balance_intent *StripecoinpaymentsApplyBalanceIntent, err error)
Update_User_By_Id(ctx context.Context, Update_User_By_Id(ctx context.Context,
user_id User_Id_Field, user_id User_Id_Field,
update User_Update_Fields) ( update User_Update_Fields) (

6
satellite/satellitedb/dbx/satellitedb.dbx.postgres.sql
View File

@ -291,6 +291,12 @@ CREATE TABLE project_members (
created_at timestamp with time zone NOT NULL, created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( member_id, project_id ) 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 ( CREATE TABLE used_serials (
serial_number_id integer NOT NULL REFERENCES serial_numbers( id ) ON DELETE CASCADE, serial_number_id integer NOT NULL REFERENCES serial_numbers( id ) ON DELETE CASCADE,
storage_node_id bytea NOT NULL, storage_node_id bytea NOT NULL,

13
satellite/satellitedb/migrate.go
View File

@ -1328,6 +1328,19 @@ func (db *DB) PostgresMigration() *migrate.Migration {
`ALTER TABLE graceful_exit_transfer_queue ADD PRIMARY KEY ( node_id, path, piece_num );`, `ALTER TABLE graceful_exit_transfer_queue ADD PRIMARY KEY ( node_id, path, piece_num );`,
}, },
}, },
{
DB: db.db,
Description: "Add payments update balance intents",
Version: 63,
Action: migrate.SQL{
`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 )
);`,
},
},
}, },
} }
} }

422
satellite/satellitedb/testdata/postgres.v63.sql vendored Normal file
View File

@ -0,0 +1,422 @@
-- AUTOGENERATED BY gopkg.in/spacemonkeygo/dbx.v1
-- 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 bucket_usages
(
id bytea NOT NULL,
bucket_id bytea NOT NULL,
rollup_end_time timestamp with time zone NOT NULL,
remote_stored_data bigint NOT NULL,
inline_stored_data bigint NOT NULL,
remote_segments integer NOT NULL,
inline_segments integer NOT NULL,
objects integer NOT NULL,
metadata_size bigint NOT NULL,
repair_egress bigint NOT NULL,
get_egress bigint NOT NULL,
audit_egress bigint NOT NULL,
PRIMARY KEY (id)
);
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 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,
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 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 NOT NULL,
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 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 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)
);
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,
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,
PRIMARY KEY ( node_id, path, piece_num )
);
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 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,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( 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 INDEX bucket_name_project_id_interval_start_interval_seconds ON bucket_bandwidth_rollups ( bucket_name, project_id, interval_start, interval_seconds );
CREATE UNIQUE INDEX bucket_id_rollup ON bucket_usages ( bucket_id, rollup_end_time );
CREATE INDEX node_last_ip ON nodes ( last_net );
CREATE UNIQUE INDEX serial_number ON serial_numbers ( serial_number );
CREATE INDEX serial_numbers_expires_at_index ON serial_numbers ( expires_at );
CREATE INDEX storagenode_id_interval_start_interval_seconds ON storagenode_bandwidth_rollups ( storagenode_id, interval_start, interval_seconds );
CREATE UNIQUE INDEX credits_earned_user_id_offer_id ON user_credits (id, offer_id) WHERE credits_earned_in_cents=0;
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, 5, 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, 1, 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, 100, 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 "bucket_usages" ("id", "bucket_id", "rollup_end_time", "remote_stored_data", "inline_stored_data", "remote_segments", "inline_segments", "objects", "metadata_size", "repair_egress", "get_egress", "audit_egress") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001",'::bytea, E'\\366\\146\\032\\321\\316\\161\\070\\133\\302\\271",'::bytea, '2019-03-06 08:28:24.677953+00', 10, 11, 12, 13, 14, 15, 16, 17, 18);
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" ("name", "description", "award_credit_in_cents", "invitee_credit_in_cents", "award_credit_duration_days", "invitee_credit_duration_days", "redeemable_cap", "expires_at", "created_at", "status", "type") VALUES ('testOffer', 'Test offer 1', 0, 0, 14, 14, 50, '2019-03-14 08:28:24.636949+00', '2019-02-14 08:28:24.636949+00', 0, 0);
INSERT INTO "offers" ("name","description","award_credit_in_cents","award_credit_duration_days", "invitee_credit_in_cents","invitee_credit_duration_days", "expires_at","created_at","status","type") VALUES ('Default free credit offer','Is active when no active free credit offer',0, NULL,300, 14, '2119-03-14 08:28:24.636949+00','2019-07-14 08:28:24.636949+00',1,1);
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") 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');
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") 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');
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 "coinpayments_transactions" ("id", "user_id", "address", "amount", "received", "status", "key", "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', '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") 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');
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") 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');
-- NEW DATA --
INSERT INTO "stripecoinpayments_apply_balance_intents" ("tx_id", "state", "created_at") VALUES ('tx_id', 0, '2019-06-01 08:28:24.267934+00');