escrow

package
v5.1.6-rc1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 30, 2024 License: MIT Imports: 22 Imported by: 0

README

Signatures used for Authorization in Daemon

High level flow

Details


Details of Signature



Type of Request Check for State or Execute Service Block chain Mode allowed User Flag Request Signature expected Method Called Response sent Comments
Paid Call Grpc State call true NA message ChannelStateRequest "__get_channel_state"+MpeAddress+channelID+CurrentBlockNumber
Bytes Constructed		 rpc GetChannelState(ChannelStateRequest) returns (ChannelStateReply) {} message ChannelStateReply Only channel signer/sender/receiver can get latest channel state . Current Block Number passed needs to be +-10 from the latest block number retrieved from the blockchain
Paid Call Grpc State call false NA message ChannelStateRequest NA rpc GetChannelState(ChannelStateRequest) returns (ChannelStateReply) {} message ChannelStateReply Same response is sent every time,Caller would not know if the block chain mode is enabled or disabled.The Signature sent is ignored.
Paid Call Execute Service true true or false Metadata Passed to Daemon should consist of the below header
"snet-payment-type"="escrow"
"snet-payment-channel-id" = "Channeld"
"snet-payment-channel-nonce"="Nonce"
"snet-payment-channel-amount" ="TotalAmount"
"snet-payment-channel-signature-bin"="Signature"		 "__MPE_claim_message"+MpeContractAddress+ChannelID+ChannelNonce+SignedAmount
Bytes Constructed		 Call to the method in Service Response sent by Service Only channel signer/sender can sign.
, Please note the Total Amount = Amount (retrieved from State call) + Price of the current call , latest nonce is also retrieved from the state call
if the allowed_user flag is true , then Make sure the Signer is also in the list of allowed users defined in the Daemon config.
Please note the allowed user flag is applicable only in test networks like sepolia/goerli etc; but not in mainnet
Free Call Execute Service true true or false Metadata Passed to Daemon should consist of the below header
"snet-payment-type"="free-call"
""snet-free-call-user-id" = "user-id"
"snet-free-call-auth-token-bin"="Auth Token downloaded"
"snet-free-call-token-expiry-block" ="Token Expiry date"
"snet-current-block-number"="CurrentBlockNumber"
"snet-payment-channel-signature-bin"="Signture"		 Signature = "__prefix_free_trial"+"user-id"+"organization_id"+"service_id"+BlockNumber+"AuthToken", now check if Auth-token = "user@mail"+"user-public-key"+ "token_issue_date"
from the first signature get the user-public-key, and use this to validate the AuthToken
Bytes Constructed		 Call to the method in Service Response sent by Service Only channel signer/sender can sign.
, Please note the Total Amount = Amount (retrieved from State call) + Price of the current call , latest nonce is also retrieved from the state call
if the allowed_user flag is true , then Make sure the Signer is also in the list of allowed users defined in the Daemon config.
Please note the allowed user flag is applicable only in test networks like sepolia/goerli etc; but not in mainnet


Details on headers

Documentation

Index

Constants

View Source 
const (
	USED_AMOUNT    string = "U"
	PLANNED_AMOUNT string = "P"
	REFUND_AMOUNT  string = "R"
)
View Source 
const (
	PrefixInSignature = "__MPE_claim_message"
	//Agreed constant value
	FreeCallPrefixSignature = "__prefix_free_trial"
	//Agreed constant value
	AllowedUserPrefixSignature = "__authorized_user"
)
View Source 
const (

	// EscrowPaymentType each call should have id and nonce of payment channel
	// in metadata.
	EscrowPaymentType = "escrow"
)
View Source 
const (

	// EscrowPaymentType each call should have id and nonce of payment channel
	// in metadata.
	FreeCallPaymentType = "free-call"
)
View Source 
const (
	PrePaidPaymentType = "prepaid-call"
)

Variables

This section is empty.

Functions

func AllowedUserPaymentHandler 

func AllowedUserPaymentHandler() handler.PaymentHandler

func BuildOldAndNewValuesForCAS 

func BuildOldAndNewValuesForCAS(data *PrePaidUsageData) (newValues []storage.TypedKeyValueData, err error)

func FreeCallPaymentHandler 

func FreeCallPaymentHandler(
	freeCallService FreeCallUserService, processor *blockchain.Processor, metadata *blockchain.OrganizationMetaData,
	pServiceMetaData *blockchain.ServiceMetadata) handler.PaymentHandler

NewPaymentHandler returns new MultiPartyEscrow contract payment handler.

func NewPaymentHandler 

func NewPaymentHandler(
	service PaymentChannelService,
	processor *blockchain.Processor,
	incomeValidator IncomeValidator) handler.PaymentHandler

NewPaymentHandler returns new MultiPartyEscrow contract payment handler.

func NewPrePaidPaymentHandler 

func NewPrePaidPaymentHandler(
	PrePaidService PrePaidService, metadata *blockchain.OrganizationMetaData,
	pServiceMetaData *blockchain.ServiceMetadata, pricing *pricing.PricingStrategy, manager token.Manager) handler.PaymentHandler

NewPaymentHandler returns new MultiPartyEscrow contract payment handler.

func NewPrepaidStorage 

func NewPrepaidStorage(atomicStorage storage.AtomicStorage) storage.TypedAtomicStorage

NewPrepaidStorage returns new instance of TypedAtomicStorage

func PaymentID 

func PaymentID(channelID *big.Int, channelNonce *big.Int) string

func PublishChannelStats 

func PublishChannelStats(payment handler.Payment) (grpcErr *handler.GrpcError)

func Uint64s 

func Uint64s(l []uint64)

Types

type AllowedUserPaymentValidator 

type AllowedUserPaymentValidator struct {
}

func (*AllowedUserPaymentValidator) Validate 

func (validator *AllowedUserPaymentValidator) Validate(payment *Payment) (err error)

type BlockChainDisabledFreeCallStateService 

type BlockChainDisabledFreeCallStateService struct {
}

func (*BlockChainDisabledFreeCallStateService) GetFreeCallsAvailable 

func (service *BlockChainDisabledFreeCallStateService) GetFreeCallsAvailable(context.Context, *FreeCallStateRequest) (*FreeCallStateReply, error)

type BlockChainDisabledProviderControlService 

type BlockChainDisabledProviderControlService struct {
}

func (*BlockChainDisabledProviderControlService) GetListInProgress 

func (service *BlockChainDisabledProviderControlService) GetListInProgress(ctx context.Context, request *GetPaymentsListRequest) (reply *PaymentsListReply, err error)

func (*BlockChainDisabledProviderControlService) GetListUnclaimed 

func (service *BlockChainDisabledProviderControlService) GetListUnclaimed(ctx context.Context, request *GetPaymentsListRequest) (paymentReply *PaymentsListReply, err error)

func (*BlockChainDisabledProviderControlService) StartClaim 

func (service *BlockChainDisabledProviderControlService) StartClaim(ctx context.Context, startClaim *StartClaimRequest) (paymentReply *PaymentReply, err error)

func (*BlockChainDisabledProviderControlService) StartClaimForMultipleChannels 

func (service *BlockChainDisabledProviderControlService) StartClaimForMultipleChannels(ctx context.Context, request *StartMultipleClaimRequest) (reply *PaymentsListReply, err error)

type BlockChainDisabledStateService 

type BlockChainDisabledStateService struct {
}

func (*BlockChainDisabledStateService) GetChannelState 

func (service *BlockChainDisabledStateService) GetChannelState(context context.Context, request *ChannelStateRequest) (reply *ChannelStateReply, err error)

type BlockChainDisabledTokenService 

type BlockChainDisabledTokenService struct {
}

func (BlockChainDisabledTokenService) GetToken 

func (service BlockChainDisabledTokenService) GetToken(ctx context.Context, request *TokenRequest) (reply *TokenReply, err error)

type BlockchainChannelReader 

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

BlockchainChannelReader reads channel state from blockchain

func NewBlockchainChannelReader 

func NewBlockchainChannelReader(processor *blockchain.Processor, cfg *viper.Viper,
	orgMetadata *blockchain.OrganizationMetaData) *BlockchainChannelReader

NewBlockchainChannelReader returns new instance of blockchain channel reader

func (*BlockchainChannelReader) GetChannelStateFromBlockchain 

func (reader *BlockchainChannelReader) GetChannelStateFromBlockchain(key *PaymentChannelKey) (channel *PaymentChannelData, ok bool, err error)

GetChannelStateFromBlockchain returns channel state from Ethereum blockchain. ok is false if channel was not found.

type ChannelPaymentValidator 

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

ChannelPaymentValidator validates payment using payment channel state.

func NewChannelPaymentValidator 

func NewChannelPaymentValidator(processor *blockchain.Processor, cfg *viper.Viper, metadata *blockchain.OrganizationMetaData) *ChannelPaymentValidator

NewChannelPaymentValidator returns new payment validator instance

func (*ChannelPaymentValidator) Validate 

func (validator *ChannelPaymentValidator) Validate(payment *Payment, channel *PaymentChannelData) (err error)

Validate returns instance of PaymentError as error if validation fails, nil otherwise.

type ChannelUpdate 

type ChannelUpdate func(channel *PaymentChannelData)

ChannelUpdate is an type of channel update which should be applied when StartClaim() method is called. 

var (
	// CloseChannel is an update which zeroes full amount of the channel to
	// designate that channel sender should add funds to the channel before
	// continue working.
	CloseChannel ChannelUpdate = func(channel *PaymentChannelData) {
		channel.FullAmount = big.NewInt(0)
	}
	// IncrementChannelNonce is an update which increments channel nonce and
	// decreases full amount to allow channel sender continue working with
	// remaining amount.
	IncrementChannelNonce ChannelUpdate = func(channel *PaymentChannelData) {
		channel.Nonce = (&big.Int{}).Add(channel.Nonce, big.NewInt(1))
		channel.FullAmount = (&big.Int{}).Sub(channel.FullAmount, channel.AuthorizedAmount)
		channel.AuthorizedAmount = big.NewInt(0)
		channel.Signature = nil
	}
)

type Claim 

type Claim interface {
	// Payment returns the payment which is being claimed, caller uses details of
	// the payment to start blockchain transaction.
	Payment() *Payment
	// Finish to be called after blockchain transaction is finished successfully.
	// Updates repository state.
	Finish() error
}

Claim is a handle of payment channel claim in progress. It is returned by StartClaim method and provides caller information about payment to call MultiPartyEscrow.channelClaim function. After transaction is written to blockchain caller should call Finish() method to update payment repository state.

type ConditionFunc 

type ConditionFunc func(conditionValues []storage.TypedKeyValueData, revisedAmount *big.Int, channelId *big.Int) ([]storage.TypedKeyValueData, error)

Defines the condition that needs to be met, it generates the respective typed Data when conditions are satisfied, you define your own validations in here It takes in the latest typed values read. 

var (
	IncrementUsedAmount ConditionFunc = func(conditionValues []storage.TypedKeyValueData, revisedAmount *big.Int, channelId *big.Int) (newValues []storage.TypedKeyValueData, err error) {
		oldState, err := convertTypedDataToPrePaidUsage(conditionValues)
		if err != nil {
			return nil, err
		}
		oldState.ChannelID = channelId
		newState := oldState.Clone()
		usageKey := PrePaidDataKey{UsageType: USED_AMOUNT, ChannelID: oldState.ChannelID}
		updateDetails(newState, usageKey, revisedAmount)
		if newState.UsedAmount.Cmp(oldState.PlannedAmount.Add(oldState.PlannedAmount, oldState.RefundAmount)) > 0 {
			return nil, fmt.Errorf("Usage Exceeded on channel Id %v", oldState.ChannelID)
		}
		return BuildOldAndNewValuesForCAS(newState)

	}
	//Make sure you update the planned amount ONLY when the new value is greater than what was last persisted
	IncrementPlannedAmount ConditionFunc = func(conditionValues []storage.TypedKeyValueData, revisedAmount *big.Int, channelId *big.Int) (newValues []storage.TypedKeyValueData, err error) {
		oldState, err := convertTypedDataToPrePaidUsage(conditionValues)
		if err != nil {
			return nil, err
		}

		oldState.ChannelID = channelId
		newState := oldState.Clone()
		usageKey := PrePaidDataKey{UsageType: PLANNED_AMOUNT, ChannelID: oldState.ChannelID}
		updateDetails(newState, usageKey, revisedAmount)
		return BuildOldAndNewValuesForCAS(newState)

	}
	//If there is no refund amount yet, put it , else add latest value in DB with the additional refund to be done
	IncrementRefundAmount ConditionFunc = func(conditionValues []storage.TypedKeyValueData, revisedAmount *big.Int, channelId *big.Int) (newValues []storage.TypedKeyValueData, err error) {
		newState, err := convertTypedDataToPrePaidUsage(conditionValues)
		if err != nil {
			return nil, err
		}
		newState.ChannelID = channelId
		usageKey := PrePaidDataKey{UsageType: REFUND_AMOUNT, ChannelID: newState.ChannelID}
		updateDetails(newState, usageKey, revisedAmount)
		return BuildOldAndNewValuesForCAS(newState)

	}
)

type FreeCallPayment 

type FreeCallPayment struct {
	// Has the ID of the user making the call
	UserId string
	// Service ID
	ServiceId string
	// Organization Id
	OrganizationId string
	// Current block number
	CurrentBlockNumber *big.Int
	// Signature passed
	Signature []byte
	// Group ID
	GroupId string
	// Auth Token Passed
	AuthToken []byte
	// Token expiration date in blocks
	AuthTokenExpiryBlockNumber *big.Int
}

To Support Free calls

func (*FreeCallPayment) String 

func (key *FreeCallPayment) String() string

type FreeCallPaymentValidator 

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

func NewFreeCallPaymentValidator 

func NewFreeCallPaymentValidator(funcCurrentBlock func() (currentBlock *big.Int, err error), signer common.Address) *FreeCallPaymentValidator

func (*FreeCallPaymentValidator) Validate 

func (validator *FreeCallPaymentValidator) Validate(payment *FreeCallPayment) (err error)

type FreeCallStateService 

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

func NewFreeCallStateService 

func NewFreeCallStateService(orgMetadata *blockchain.OrganizationMetaData,
	srvMetaData *blockchain.ServiceMetadata, service FreeCallUserService, validator *FreeCallPaymentValidator) *FreeCallStateService

func (*FreeCallStateService) GetFreeCallsAvailable 

func (service *FreeCallStateService) GetFreeCallsAvailable(context context.Context,
	request *FreeCallStateRequest) (reply *FreeCallStateReply, err error)

type FreeCallTransaction 

type FreeCallTransaction interface {
	FreeCallUser() *FreeCallUserData

	Commit() error

	Rollback() error
}

type FreeCallUserData 

type FreeCallUserData struct {
	UserId         string
	FreeCallsMade  int
	OrganizationId string
	ServiceId      string
	GroupID        string
}

func (*FreeCallUserData) String 

func (data *FreeCallUserData) String() string

type FreeCallUserKey 

type FreeCallUserKey struct {
	UserId         string
	OrganizationId string
	ServiceId      string
	GroupID        string
}

func (*FreeCallUserKey) String 

func (key *FreeCallUserKey) String() string

type FreeCallUserService 

type FreeCallUserService interface {
	GetFreeCallUserKey(payment *FreeCallPayment) (userKey *FreeCallUserKey, err error)

	//if the user details are not found, send back a new entry to be persisted
	FreeCallUser(key *FreeCallUserKey) (freeCallUser *FreeCallUserData, ok bool, err error)

	ListFreeCallUsers() (freeCallUsers []*FreeCallUserData, err error)

	StartFreeCallUserTransaction(payment *FreeCallPayment) (transaction FreeCallTransaction, err error)
}

func NewFreeCallUserService 

func NewFreeCallUserService(
	storage *FreeCallUserStorage,

	locker Locker,
	groupIdReader func() ([32]byte, error), metadata *blockchain.ServiceMetadata) FreeCallUserService

type FreeCallUserStorage 

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

func NewFreeCallUserStorage 

func NewFreeCallUserStorage(atomicStorage storage.AtomicStorage) *FreeCallUserStorage

func (*FreeCallUserStorage) CompareAndSwap 

func (storage *FreeCallUserStorage) CompareAndSwap(key *FreeCallUserKey, prevState *FreeCallUserData, newState *FreeCallUserData) (ok bool, err error)

func (*FreeCallUserStorage) Get 

func (storage *FreeCallUserStorage) Get(key *FreeCallUserKey) (state *FreeCallUserData, ok bool, err error)

func (*FreeCallUserStorage) GetAll 

func (storage *FreeCallUserStorage) GetAll() (states []*FreeCallUserData, err error)

func (*FreeCallUserStorage) Put 

func (storage *FreeCallUserStorage) Put(key *FreeCallUserKey, state *FreeCallUserData) (err error)

func (*FreeCallUserStorage) PutIfAbsent 

func (storage *FreeCallUserStorage) PutIfAbsent(key *FreeCallUserKey, state *FreeCallUserData) (ok bool, err error)

type FreeCallUserUpdate 

type FreeCallUserUpdate func(user *FreeCallUserData)
var (
	IncrementFreeCallCount FreeCallUserUpdate = func(user *FreeCallUserData) {
		user.FreeCallsMade = user.FreeCallsMade + 1
	}
)

type IncomeData 

type IncomeData struct {
	// Income is a difference between previous authorized amount and amount
	// which was received with current call.
	Income *big.Int
	// GrpcContext contains gRPC stream context information. For instance
	// metadata could be used to pass invoice id to check pricing.
	GrpcContext *handler.GrpcStreamContext
}

IncomeData is used to pass information to the pricing validation system. This system can use information about call to calculate price and verify income received.

type IncomeValidator 

type IncomeValidator interface {
	// Validate returns nil if validation is successful or correct PaymentError
	// status to be sent to client in case of validation error.
	Validate(*IncomeData) (err error)
}

IncomeValidator uses pricing information to check that call was paid correctly by channel sender. This interface can be implemented differently depending on pricing policy. For instance one can verify that call is paid according to invoice. Each RPC method can have different price and so on. To implement these strategies additional information from gRPC context can be required. In such case it should be added into handler.GrpcStreamContext.

func NewIncomeValidator 

func NewIncomeValidator(pricing *pricing.PricingStrategy) (validator IncomeValidator)

NewIncomeValidator returns new income validator instance

type Lock 

type Lock interface {
	// Unlock frees lock
	Unlock() (err error)
}

Lock is an acquired lock.

type Locker 

type Locker interface {
	// Lock acquires and returns lock. ok is false if lock cannot be acquired.
	Lock(name string) (lock Lock, ok bool, err error)
}

Locker is an interface to acquire lock

func NewEtcdLocker 

func NewEtcdLocker(storage storage.AtomicStorage) Locker

NewEtcdLocker returns new lock which is based on etcd storage.

type Payment 

type Payment struct {
	// MpeContractAddress is an address of the MultiPartyEscrow contract which
	// were used to open the payment channel.
	MpeContractAddress common.Address
	// ChannelID is an id of the payment channel used.
	ChannelID *big.Int
	// ChannelNonce is a nonce of the payment channel.
	ChannelNonce *big.Int
	// Amount is an amount of the payment.
	Amount *big.Int
	// Signature is a signature of the payment.
	Signature []byte
}

Payment contains MultiPartyEscrow payment details

func (*Payment) ID 

func (p *Payment) ID() string

func (*Payment) String 

func (p *Payment) String() string

type PaymentChannelData 

type PaymentChannelData struct {
	// ChannelID is an id of the channel
	ChannelID *big.Int
	// Nonce is a nonce of this channel state
	Nonce *big.Int
	// State is a payment channel state: Open or Closed.
	State PaymentChannelState
	// Sender is an Ethereum address of the client which created the channel.
	// It is and address to be charged for RPC call.
	Sender common.Address
	// Recipient is an address which can claim funds from channel using
	// signature. It is an address of service provider.
	Recipient common.Address
	// GroupID is an id of the group of service replicas which share the same
	// payment channel.
	GroupID [32]byte
	// FullAmount is an amount which is deposited in channel by Sender.
	FullAmount *big.Int
	// Expiration is a time at which channel will be expired. This time is
	// expressed in Ethereum block number. Since this block is added to
	// blockchain Sender can withdraw tokens from channel.
	Expiration *big.Int
	// Signer is and address to be used to sign the payments. Usually it is
	// equal to channel sender.
	Signer common.Address

	// service provider. This amount increments on price after each successful
	// RPC call.
	AuthorizedAmount *big.Int
	// Signature is a signature of last message containing Authorized amount.
	// It is required to claim tokens from channel.
	Signature []byte
}

PaymentChannelData is to keep all channel related information.

func MergeStorageAndBlockchainChannelState 

func MergeStorageAndBlockchainChannelState(storage, blockchain *PaymentChannelData) (merged *PaymentChannelData)

MergeStorageAndBlockchainChannelState merges two instances of payment channel: one read from storage, one from blockchain.

func (*PaymentChannelData) String 

func (data *PaymentChannelData) String() string

type PaymentChannelKey 

type PaymentChannelKey struct {
	ID *big.Int
}

PaymentChannelKey specifies the channel in MultiPartyEscrow contract. It consists of two parts: channel id and channel nonce. Channel nonce is incremented each time when amount of tokens in channel descreases. Nonce allows reusing channel id without risk of overexpenditure.

func (*PaymentChannelKey) String 

func (key *PaymentChannelKey) String() string

type PaymentChannelService 

type PaymentChannelService interface {
	// PaymentChannel returns latest payment channel state. This method uses
	// shared storage and blockchain to construct and return latest channel
	// state.
	PaymentChannel(key *PaymentChannelKey) (channel *PaymentChannelData, ok bool, err error)
	// ListChannels returns list of payment channels from payment channel
	// storage.
	ListChannels() (channels []*PaymentChannelData, err error)

	// StartClaim gets channel from storage, applies update on it and adds
	// payment for claiming into the storage.
	StartClaim(key *PaymentChannelKey, update ChannelUpdate) (claim Claim, err error)
	// ListClaims returns list of payment claims in progress
	ListClaims() (claim []Claim, err error)

	// StartPaymentTransaction validates payment and starts payment transaction
	StartPaymentTransaction(payment *Payment) (transaction PaymentTransaction, err error)

	//Get Channel from BlockChain
	PaymentChannelFromBlockChain(key *PaymentChannelKey) (channel *PaymentChannelData, ok bool, err error)
}

PaymentChannelService interface is API for payment channel functionality.

func NewPaymentChannelService 

func NewPaymentChannelService(
	storage *PaymentChannelStorage,
	paymentStorage *PaymentStorage,
	blockchainReader *BlockchainChannelReader,
	locker Locker,
	channelPaymentValidator *ChannelPaymentValidator, groupIdReader func() ([32]byte, error)) PaymentChannelService

NewPaymentChannelService returns instance of PaymentChannelService to work with payments via MultiPartyEscrow contract.

type PaymentChannelState 

type PaymentChannelState int

PaymentChannelState is a current state of a payment channel. Payment channel may be in Open or Closed state. 

const (
	// Open means that channel is open and can be used to pay for calls.
	Open PaymentChannelState = 0
	// Closed means that channel is closed cannot be used to pay for calls.
	Closed PaymentChannelState = 1
)

func (PaymentChannelState) String 

func (state PaymentChannelState) String() string

type PaymentChannelStateService 

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

PaymentChannelStateService is an implementation of PaymentChannelStateServiceServer gRPC interface

func NewPaymentChannelStateService 

func NewPaymentChannelStateService(channelService PaymentChannelService, paymentStorage *PaymentStorage, metaData *blockchain.ServiceMetadata) *PaymentChannelStateService

NewPaymentChannelStateService returns new instance of PaymentChannelStateService

func (*PaymentChannelStateService) GetChannelState 

func (service *PaymentChannelStateService) GetChannelState(context context.Context, request *ChannelStateRequest) (reply *ChannelStateReply, err error)

GetChannelState returns the latest state of the channel which id is passed in request. To authenticate sender request should also contain correct signature of the channel id. Simple case current_nonce == blockchain_nonce unspent_amount = blockchain_value - current_signed_amount Complex case current_nonce != blockchain_nonce Taking into account our assumptions, we know that current_nonce = blockchain_nonce + 1.

unspent_amount = blockchain_value - oldnonce_signed_amount - current_signed_amount It should be noted that in this case the server could send us smaller old nonce_signed_amount (not the actually last one which was used for channelClaim). In this case, the server can only make us believe that we have more money in the channel then we actually have. That means that one possible attack via unspent_amount is to make us believe that we have less tokens than we truly have, and therefore reject future calls (or force us to call channelAddFunds).

func (*PaymentChannelStateService) StorageNonceMatchesWithBlockchainNonce 

func (service *PaymentChannelStateService) StorageNonceMatchesWithBlockchainNonce(storageChannel *PaymentChannelData) (equal bool, err error)

verifies whether storage channel nonce is equal to blockchain nonce or not

type PaymentChannelStorage 

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

PaymentChannelStorage is a storage for PaymentChannelData by PaymentChannelKey based on TypedAtomicStorage implementation

func NewPaymentChannelStorage 

func NewPaymentChannelStorage(atomicStorage storage.AtomicStorage) *PaymentChannelStorage

NewPaymentChannelStorage returns new instance of PaymentChannelStorage implementation

func (*PaymentChannelStorage) CompareAndSwap 

func (storage *PaymentChannelStorage) CompareAndSwap(key *PaymentChannelKey, prevState *PaymentChannelData, newState *PaymentChannelData) (ok bool, err error)

CompareAndSwap compares previous storage value and set new value by key

func (*PaymentChannelStorage) Get 

func (storage *PaymentChannelStorage) Get(key *PaymentChannelKey) (state *PaymentChannelData, ok bool, err error)

Get returns payment channel by key

func (*PaymentChannelStorage) GetAll 

func (storage *PaymentChannelStorage) GetAll() (states []*PaymentChannelData, err error)

GetAll returns all channels from the storage

func (*PaymentChannelStorage) Put 

func (storage *PaymentChannelStorage) Put(key *PaymentChannelKey, state *PaymentChannelData) (err error)

Put stores payment channel by key

func (*PaymentChannelStorage) PutIfAbsent 

func (storage *PaymentChannelStorage) PutIfAbsent(key *PaymentChannelKey, state *PaymentChannelData) (ok bool, err error)

PutIfAbsent storage payment channel by key if key is absent

type PaymentError 

type PaymentError struct {
	// Code is error code
	Code PaymentErrorCode
	// Message is message
	Message string
}

PaymentError contains error code and message and implements Error interface.

func NewPaymentError 

func NewPaymentError(code PaymentErrorCode, format string, msg ...any) *PaymentError

NewPaymentError constructs new PaymentError instance with given error code and message.

func (*PaymentError) Error 

func (err *PaymentError) Error() string

type PaymentErrorCode 

type PaymentErrorCode int

PaymentErrorCode contains all types of errors which we need to handle on the client side. 

const (
	// Internal error code means that error is caused by improper daemon
	// configuration or functioning. Client cannot do anything with it.
	Internal PaymentErrorCode = 1
	// Unauthenticated error code means that client sent payment which cannot
	// be applied to the channel.
	Unauthenticated PaymentErrorCode = 2
	// FailedPrecondition means that request cannot be handled because system
	// is not in appropriate state.
	FailedPrecondition PaymentErrorCode = 3
	// IncorrectNonce is returned when nonce value sent by client is incorrect.
	IncorrectNonce PaymentErrorCode = 4
)

type PaymentStorage 

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

PaymentStorage is a storage for PaymentChannelData by PaymentChannelKey based on TypedAtomicStorage implementation

func NewPaymentStorage 

func NewPaymentStorage(atomicStorage storage.AtomicStorage) *PaymentStorage

NewPaymentStorage returns new instance of PaymentStorage implementation

func (*PaymentStorage) Delete 

func (storage *PaymentStorage) Delete(payment *Payment) (err error)

func (*PaymentStorage) Get 

func (storage *PaymentStorage) Get(paymentID string) (payment *Payment, ok bool, err error)

func (*PaymentStorage) GetAll 

func (storage *PaymentStorage) GetAll() (states []*Payment, err error)

func (*PaymentStorage) Put 

func (storage *PaymentStorage) Put(payment *Payment) (err error)

type PaymentTransaction 

type PaymentTransaction interface {
	// Channel returns the channel which is used to apply the payment
	Channel() *PaymentChannelData
	// Commit finishes transaction and applies payment.
	Commit() error
	// Rollback rolls transaction back.
	Rollback() error
}

PaymentTransaction is a payment transaction in progress.

type PrePaidData 

type PrePaidData struct {
	Amount *big.Int
}

Kept the bare minimum here , other details like group and sender address of this channel can always be retrieved from BlockChain

func (*PrePaidData) String 

func (data *PrePaidData) String() string

type PrePaidDataKey 

type PrePaidDataKey struct {
	ChannelID *big.Int
	UsageType string
}

func (*PrePaidDataKey) String 

func (key *PrePaidDataKey) String() string

type PrePaidPayment 

type PrePaidPayment struct {
	ChannelID      *big.Int
	OrganizationId string
	GroupId        string
	AuthToken      string
}

To Support PrePaid calls and also concurrency

func (*PrePaidPayment) String 

func (payment *PrePaidPayment) String() string

Used when the Request comes in

type PrePaidPaymentHandler 

type PrePaidPaymentHandler struct {
	PrePaidPaymentValidator *PrePaidPaymentValidator
	// contains filtered or unexported fields
}

func (*PrePaidPaymentHandler) Complete 

func (h *PrePaidPaymentHandler) Complete(payment handler.Payment) (err *handler.GrpcError)

Just logging , as we increase the usage before calling the service assuming the service call will be successful

func (*PrePaidPaymentHandler) CompleteAfterError 

func (h *PrePaidPaymentHandler) CompleteAfterError(payment handler.Payment, result error) (err *handler.GrpcError)

func (*PrePaidPaymentHandler) Payment 

func (h *PrePaidPaymentHandler) Payment(context *handler.GrpcStreamContext) (transaction handler.Payment,
	err *handler.GrpcError)

func (*PrePaidPaymentHandler) Type 

func (h *PrePaidPaymentHandler) Type() (typ string)

type PrePaidPaymentValidator 

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

func NewPrePaidPaymentValidator 

func NewPrePaidPaymentValidator(pricing *pricing.PricingStrategy, manager token.Manager) *PrePaidPaymentValidator

func (*PrePaidPaymentValidator) Validate 

func (validator *PrePaidPaymentValidator) Validate(payment *PrePaidPayment) (err error)

type PrePaidService 

type PrePaidService interface {
	GetUsage(key PrePaidDataKey) (*PrePaidData, bool, error)
	UpdateUsage(channelId *big.Int, revisedAmount *big.Int, updateUsageType string) error
}

func NewPrePaidService 

func NewPrePaidService(
	storage storage.TypedAtomicStorage,
	prepaidValidator *PrePaidPaymentValidator, groupIdReader func() ([32]byte, error)) PrePaidService

type PrePaidTransaction 

type PrePaidTransaction interface {
	ChannelId() *big.Int
	Price() *big.Int
	Commit() error
	Rollback() error
}

type PrePaidUsageData 

type PrePaidUsageData struct {
	ChannelID       *big.Int
	PlannedAmount   *big.Int
	UsedAmount      *big.Int
	RefundAmount    *big.Int
	UpdateUsageType string
}

This will ony be used for doing any business checks

func (PrePaidUsageData) Clone 

func (data PrePaidUsageData) Clone() *PrePaidUsageData

func (*PrePaidUsageData) GetAmountForUsageType 

func (data *PrePaidUsageData) GetAmountForUsageType() (*big.Int, error)

func (*PrePaidUsageData) String 

func (data *PrePaidUsageData) String() string

type ProviderControlService 

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

func NewProviderControlService 

func NewProviderControlService(channelService PaymentChannelService, serMetaData *blockchain.ServiceMetadata,
	orgMetadata *blockchain.OrganizationMetaData) *ProviderControlService

func (*ProviderControlService) GetListInProgress 

func (service *ProviderControlService) GetListInProgress(ctx context.Context, request *GetPaymentsListRequest) (reply *PaymentsListReply, err error)

Get the list of all claims that have been initiated but not completed yet. Verify that mpe_address is correct Verify that actual block_number is not very different (+-5 blocks) from the current_block_number from the signature Verify that message was signed by the service provider (“payment_address” in metadata should match to the signer). Check for any claims already done on block chain but have not been reflected in the storage yet, update the storage status by calling the Finish() method on such claims.

func (*ProviderControlService) GetListUnclaimed 

func (service *ProviderControlService) GetListUnclaimed(ctx context.Context, request *GetPaymentsListRequest) (paymentReply *PaymentsListReply, err error)
GetListUnclaimed

Get list of unclaimed payments, we do this by getting the list of channels in progress which have some amount to be claimed. Verify that mpe_address is correct Verify that actual block_number is not very different (+-5 blocks) from the current_block_number from the signature Verify that message was signed by the service provider (“payment_address” in metadata should match to the signer). Send list of unclaimed payments

func (*ProviderControlService) StartClaim 

func (service *ProviderControlService) StartClaim(ctx context.Context, startClaim *StartClaimRequest) (paymentReply *PaymentReply, err error)

Initialize the claim for specific channel Verify that the “payment_address” in meta data matches to that of the signer. Increase nonce and send last payment with old nonce to the caller. Begin the claim process on the current channel and Increment the channel nonce and decrease the full amount to allow channel sender to continue working with remaining amount. Check for any claims already done on block chain but have not been reflected in the storage yet, update the storage status by calling the Finish() method on such claims

func (*ProviderControlService) StartClaimForMultipleChannels 

func (service *ProviderControlService) StartClaimForMultipleChannels(ctx context.Context, request *StartMultipleClaimRequest) (reply *PaymentsListReply, err error)

We need to have an ability to StartClaims for multiple channels too! The User makes a Daemon call to the get all the pending claims The user then needs to call the start claim for every channel that he intends to claim ( thus a new signature again ) for every invocation of StartClaim ! PS You can make Multiple Claims in BlockChain in a single call multiChannelClaim You can now initiate multiple claims using this function StartClaimsOnMultipleChannels that takes a list of ChannelIds , What Daemon will do is invoke the StartClaim internally for every channel Id passed If an error is encountered , then we return back whatever was successful and stop with the channel ID that had an issue and return the error that was encountered.

type TokenService 

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

func NewTokenService 

func NewTokenService(paymentChannelService PaymentChannelService,
	usageService PrePaidService, tokenManager token.Manager, validator *ChannelPaymentValidator, metadata *blockchain.ServiceMetadata) *TokenService

func (*TokenService) GetToken 

func (service *TokenService) GetToken(ctx context.Context, request *TokenRequest) (reply *TokenReply, err error)

type Uint64Slice 

type Uint64Slice []uint64

func (Uint64Slice) Len 

func (p Uint64Slice) Len() int

func (Uint64Slice) Less 

func (p Uint64Slice) Less(i, j int) bool

func (Uint64Slice) Swap 

func (p Uint64Slice) Swap(i, j int)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.