payments

Documentation

Index

• Constants
• Variables
• type Accounts
• type Balance
• type CardInfo
• type Charge
• type Coupon
  • func (coupon *Coupon) ExpirationDate() *time.Time
• type CouponStatus
• type CouponType
• type Coupons
• type CouponsPage
• type Credit
• type CreditCard
• type CreditCards
• type Credits
• type CreditsPage
• type DepositBonus
• type Invoice
• type Invoices
• type ProjectCharge
• type StorjTokens
• type TokenAmount
  • func NewTokenAmount() *TokenAmount
  • func ParseTokenAmount(s string) (*TokenAmount, error)
  • func TokenAmountFromBigFloat(f *big.Float) *TokenAmount
  • func (amount *TokenAmount) BigFloat() *big.Float
  • func (amount *TokenAmount) String() string
• type Transaction
• type TransactionID
  • func (id TransactionID) String() string
• type TransactionInfo
• type TransactionStatus
  • func (status TransactionStatus) String() string

Constants

const STORJTokenPrecision = 32

STORJTokenPrecision defines STORJ token precision.

Variables

var ErrAccountNotSetup = errs.Class("payment account is not set up")

ErrAccountNotSetup is an error type which indicates that payment account is not created.

Types

type Accounts

type Accounts interface {
	// Setup creates a payment account for the user.
	// If account is already set up it will return nil.
	Setup(ctx context.Context, userID uuid.UUID, email string) error

	// Balance returns an object that represents current free credits and coins balance in cents.
	Balance(ctx context.Context, userID uuid.UUID) (Balance, error)

	// ProjectCharges returns how much money current user will be charged for each project.
	ProjectCharges(ctx context.Context, userID uuid.UUID, since, before time.Time) ([]ProjectCharge, error)

	// CheckProjectInvoicingStatus returns true if for the given project there are outstanding project records and/or usage
	// which have not been applied/invoiced yet (meaning sent over to stripe).
	CheckProjectInvoicingStatus(ctx context.Context, projectID uuid.UUID) (unpaidUsage bool, err error)

	// Charges returns list of all credit card charges related to account.
	Charges(ctx context.Context, userID uuid.UUID) ([]Charge, error)

	// CreditCards exposes all needed functionality to manage account credit cards.
	CreditCards() CreditCards

	// StorjTokens exposes all storj token related functionality.
	StorjTokens() StorjTokens

	// Invoices exposes all needed functionality to manage account invoices.
	Invoices() Invoices

	// Coupons exposes all needed functionality to manage coupons.
	Coupons() Coupons

	// PaywallEnabled returns a true if a credit card or account
	// balance is required to create projects
	PaywallEnabled(uuid.UUID) bool
}

Accounts exposes all needed functionality to manage payment accounts.

architecture: Service

type Balance

type Balance struct {
	FreeCredits int64 `json:"freeCredits"`
	Coins       int64 `json:"coins"`
}

Balance is an entity that holds free credits and coins balance of user. Earned by applying of promotional coupon and coins depositing, respectively.

type CardInfo

type CardInfo struct {
	ID       string `json:"id"`
	Brand    string `json:"brand"`
	LastFour string `json:"lastFour"`
}

CardInfo holds information about credit card used for charge.

type Charge

type Charge struct {
	ID        string    `json:"id"`
	Amount    int64     `json:"amount"`
	CardInfo  CardInfo  `json:"card"`
	CreatedAt time.Time `json:"createdAt"`
}

Charge contains charge details.

type Coupon

type Coupon struct {
	ID          uuid.UUID    `json:"id"`
	UserID      uuid.UUID    `json:"userId"`
	Amount      int64        `json:"amount"`   // Amount is stored in cents.
	Duration    *int         `json:"duration"` // Duration is stored in number of billing periods.
	Description string       `json:"description"`
	Type        CouponType   `json:"type"`
	Status      CouponStatus `json:"status"`
	Created     time.Time    `json:"created"`
}

Coupon is an entity that adds some funds to Accounts balance for some fixed period. Coupon is attached to the project. At the end of the period, the entire remaining coupon amount will be returned from the account balance.

func (*Coupon) ExpirationDate

func (coupon *Coupon) ExpirationDate() *time.Time

ExpirationDate returns coupon expiration date.

A coupon is valid for Duration number of full months. The month the user signs up is not counted in the duration. The expirated date is at the last day of the last valid month.

type CouponStatus

type CouponStatus int

CouponStatus indicates the state of the coupon.

const (
	// CouponActive is a default coupon state.
	CouponActive CouponStatus = 0
	// CouponUsed status indicates that coupon was used.
	CouponUsed CouponStatus = 1
	// CouponExpired status indicates that coupon is expired and unavailable.
	CouponExpired CouponStatus = 2
)

type CouponType

type CouponType int

CouponType indicates the type of the coupon.

const (
	// CouponTypePromotional defines that this coupon is a promotional coupon.
	CouponTypePromotional CouponType = 0
)

type Coupons

type Coupons interface {
	// ListByUserID return list of all coupons of specified payment account.
	ListByUserID(ctx context.Context, userID uuid.UUID) ([]Coupon, error)

	// TotalUsage returns sum of all usage records for specified coupon.
	TotalUsage(ctx context.Context, couponID uuid.UUID) (int64, error)

	// Create attaches a coupon for payment account.
	Create(ctx context.Context, coupon Coupon) (coup Coupon, err error)

	// AddPromotionalCoupon is used to add a promotional coupon for specified users who already have
	// a project and do not have a promotional coupon yet.
	// And updates project limits to selected size.
	AddPromotionalCoupon(ctx context.Context, userID uuid.UUID) error

	// PopulatePromotionalCoupons is used to populate promotional coupons through all active users who already have
	// a project, payment method and do not have a promotional coupon yet.
	// And updates project limits to selected size.
	PopulatePromotionalCoupons(ctx context.Context, duration *int, amount int64, projectLimit memory.Size) error
}

Coupons exposes all needed functionality to manage coupons.

architecture: Service

type CouponsPage

type CouponsPage struct {
	Coupons    []Coupon
	Next       bool
	NextOffset int64
}

CouponsPage holds set of coupon and indicates if there are more coupons to fetch.

type Credit

type Credit struct {
	UserID        uuid.UUID                  `json:"userId"`
	Amount        int64                      `json:"credit"`
	TransactionID coinpayments.TransactionID `json:"transactionId"`
	Created       time.Time                  `json:"created"`
}

Credit is an entity that holds bonus balance of user, earned by depositing with storj coins.

type CreditCard

type CreditCard struct {
	ID        string `json:"id"`
	ExpMonth  int    `json:"expMonth"`
	ExpYear   int    `json:"expYear"`
	Brand     string `json:"brand"`
	Last4     string `json:"last4"`
	IsDefault bool   `json:"isDefault"`
}

CreditCard holds all public information about credit card.

type CreditCards

type CreditCards interface {
	// List returns a list of credit cards for a given payment account.
	List(ctx context.Context, userID uuid.UUID) ([]CreditCard, error)

	// Add is used to save new credit card and attach it to payment account.
	Add(ctx context.Context, userID uuid.UUID, cardToken string) error

	// Remove is used to detach a credit card from payment account.
	Remove(ctx context.Context, userID uuid.UUID, cardID string) error

	// RemoveAll is used to detach all credit cards from payment account.
	// It should only be used in case of a user deletion.
	RemoveAll(ctx context.Context, userID uuid.UUID) error

	// MakeDefault makes a credit card default payment method.
	// this credit card should be attached to account before make it default.
	MakeDefault(ctx context.Context, userID uuid.UUID, cardID string) error
}

CreditCards exposes all needed functionality to manage account credit cards.

architecture: Service

type Credits

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)
}

Credits exposes all needed functionality to manage credits.

architecture: Service

type CreditsPage

type CreditsPage struct {
	Credits    []Credit
	Next       bool
	NextOffset int64
}

CreditsPage holds set of credits and indicates if there are more credits to fetch.

type DepositBonus

type DepositBonus struct {
	TransactionID TransactionID
	AmountCents   int64
	Percentage    int64
	CreatedAt     time.Time
}

DepositBonus defines a bonus received for depositing tokens.

type Invoice

type Invoice struct {
	ID          string    `json:"id"`
	Description string    `json:"description"`
	Amount      int64     `json:"amount"`
	Status      string    `json:"status"`
	Link        string    `json:"link"`
	Start       time.Time `json:"start"`
	End         time.Time `json:"end"`
}

Invoice holds all public information about invoice.

type Invoices

type Invoices interface {
	// List returns a list of invoices for a given payment account.
	List(ctx context.Context, userID uuid.UUID) ([]Invoice, error)
	// CheckPendingItems returns if pending invoice items for a given payment account exist.
	CheckPendingItems(ctx context.Context, userID uuid.UUID) (existingItems bool, err error)
}

Invoices exposes all needed functionality to manage account invoices.

architecture: Service

type ProjectCharge

type ProjectCharge struct {
	accounting.ProjectUsage

	ProjectID uuid.UUID `json:"projectId"`
	// StorageGbHrs shows how much cents we should pay for storing GB*Hrs.
	StorageGbHrs int64 `json:"storagePrice"`
	// Egress shows how many cents we should pay for Egress.
	Egress int64 `json:"egressPrice"`
	// ObjectCount shows how many cents we should pay for objects count.
	ObjectCount int64 `json:"objectPrice"`
}

ProjectCharge shows project usage and how much money current project will charge in the end of the month.

type StorjTokens

type StorjTokens interface {
	// Deposit creates deposit transaction for specified amount in cents.
	Deposit(ctx context.Context, userID uuid.UUID, amount int64) (*Transaction, error)
	// ListTransactionInfos returns all transactions associated with user.
	ListTransactionInfos(ctx context.Context, userID uuid.UUID) ([]TransactionInfo, error)
	// ListDepositBonuses returns all deposit bonuses associated with user.
	ListDepositBonuses(ctx context.Context, userID uuid.UUID) ([]DepositBonus, error)
}

StorjTokens defines all payments STORJ token related functionality.

architecture: Service

type TokenAmount

type TokenAmount struct {
	// contains filtered or unexported fields
}

TokenAmount is a wrapper type for STORJ token amount. Uses big.Float as inner representation. Precision is set to 32 so it can properly handle 8 digits after point which is STORJ token decimal set.

func NewTokenAmount

func NewTokenAmount() *TokenAmount

NewTokenAmount creates new zeroed TokenAmount with fixed precision.

func ParseTokenAmount

func ParseTokenAmount(s string) (*TokenAmount, error)

ParseTokenAmount parses string representing floating point and returns TokenAmount.

func TokenAmountFromBigFloat

func TokenAmountFromBigFloat(f *big.Float) *TokenAmount

TokenAmountFromBigFloat converts big.Float to TokenAmount.

func (*TokenAmount) BigFloat

func (amount *TokenAmount) BigFloat() *big.Float

BigFloat returns inner representation of TokenAmount.

func (*TokenAmount) String

func (amount *TokenAmount) String() string

String representation of TokenValue.

type Transaction

type Transaction struct {
	ID        TransactionID
	Amount    TokenAmount
	Rate      big.Float
	Address   string
	Status    TransactionStatus
	Timeout   time.Duration
	Link      string
	CreatedAt time.Time
}

Transaction defines deposit transaction which accepts user funds on a specific wallet address.

type TransactionID

type TransactionID []byte

TransactionID is a transaction ID type.

func (TransactionID) String

func (id TransactionID) String() string

String returns string representation of transaction id.

type TransactionInfo

type TransactionInfo struct {
	ID            TransactionID
	Amount        TokenAmount
	Received      TokenAmount
	AmountCents   int64
	ReceivedCents int64
	Address       string
	Status        TransactionStatus
	Link          string
	ExpiresAt     time.Time
	CreatedAt     time.Time
}

TransactionInfo holds transaction data with additional information such as links and expiration time.

type TransactionStatus

type TransactionStatus string

TransactionStatus defines allowed statuses for deposit transactions.

const (
	// TransactionStatusPaid is a transaction which successfully received required funds.
	TransactionStatusPaid TransactionStatus = "paid"
	// TransactionStatusPending is a transaction which accepts funds.
	TransactionStatusPending TransactionStatus = "pending"
	// TransactionStatusCancelled is a transaction that is cancelled and no longer accepting new funds.
	TransactionStatusCancelled TransactionStatus = "cancelled"
)

func (TransactionStatus) String

func (status TransactionStatus) String() string

String returns string representation of transaction status.