proto

package
v0.0.0-...-c98baff Latest Latest
Warning

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

 Go to latest Published: Mar 30, 2020 License: MIT Imports: 25 Imported by: 0

README

Proto

Coming Soon...

Documentation

Index

Constants

View Source 
const (
	// FCSignedIdentiferSize is the size of a ContractSignedIdentifier
	FCSignedIdentiferSize = 80 // 32 bytes identifier, 32 bytes signature, 16 bytes prefix
)

Variables

View Source 
var (
	// ErrBadHostVersion indicates that the host is using an older, incompatible
	// version of the renter-host protocol.
	ErrBadHostVersion = errors.New("Bad host version; host does not support required protocols")
)
View Source 
var ErrCSIDoesNotMatchSeed = errors.New("ContractSignedIdentifier signature bytes not equal")

ErrCSIDoesNotMatchSeed is returned when a ContractSignedIdentifier was not created with the current seed used by the renter.

Functions

func GenerateKeyPair 

func GenerateKeyPair(renterSeed EphemeralRenterSeed, txn types.Transaction) (sk crypto.SecretKey, pk crypto.PublicKey)

GenerateKeyPair generates a secret and a public key for a contract to be used in its unlock conditions.

func GenerateKeyPairWithOutputID 

func GenerateKeyPairWithOutputID(renterSeed EphemeralRenterSeed, inputParentID types.I3vcoinOutputID) (sk crypto.SecretKey, pk crypto.PublicKey)

GenerateKeyPairWithOutputID generates a secret and a public key for a contract to be used in its unlock conditions.

func IsRevisionMismatch 

func IsRevisionMismatch(err error) bool

IsRevisionMismatch returns true if err was caused by the host reporting a different revision number than expected.

Types

type ContractParams 

type ContractParams struct {
	Allowance     modules.Allowance
	Host          modules.HostDBEntry
	Funding       types.Currency
	StartHeight   types.BlockHeight
	EndHeight     types.BlockHeight
	RefundAddress types.UnlockHash
	RenterSeed    EphemeralRenterSeed
}

ContractParams are supplied as an argument to FormContract.

type ContractSet 

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

A ContractSet provides safe concurrent access to a set of contracts. Its purpose is to serialize modifications to individual contracts, as well as to provide operations on the set as a whole.

func NewContractSet 

func NewContractSet(dir string, deps modules.Dependencies) (*ContractSet, error)

NewContractSet returns a ContractSet storing its contracts in the specified dir.

func (*ContractSet) Acquire 

func (cs *ContractSet) Acquire(id types.FileContractID) (*SafeContract, bool)

Acquire looks up the contract for the specified host key and locks it before returning it. If the contract is not present in the set, Acquire returns false and a zero-valued RenterContract.

func (*ContractSet) Close 

func (cs *ContractSet) Close() error

Close closes all contracts in a contract set, this means rendering it unusable for I/O

func (*ContractSet) ConvertV130Contract 

func (cs *ContractSet) ConvertV130Contract(c V130Contract, cr V130CachedRevision) error

ConvertV130Contract creates a contract file for a v130 contract.

func (*ContractSet) Delete 

func (cs *ContractSet) Delete(c *SafeContract)

Delete removes a contract from the set. The contract must have been previously acquired by Acquire. If the contract is not present in the set, Delete is a no-op.

func (*ContractSet) FormContract 

func (cs *ContractSet) FormContract(params ContractParams, txnBuilder transactionBuilder, tpool transactionPool, hdb hostDB, cancel <-chan struct{}) (rc modules.RenterContract, formationTxnSet []types.Transaction, sweepTxn types.Transaction, sweepParents []types.Transaction, err error)

FormContract forms a contract with a host and submits the contract transaction to tpool. The contract is added to the ContractSet and its metadata is returned.

func (*ContractSet) IDs 

func (cs *ContractSet) IDs() []types.FileContractID

IDs returns the fcid of each contract with in the set. The contracts are not locked.

func (*ContractSet) InsertContract 

func (cs *ContractSet) InsertContract(rc modules.RecoverableContract, revTxn types.Transaction, roots []crypto.Hash, sk crypto.SecretKey) (modules.RenterContract, error)

InsertContract inserts an existing contract into the set.

func (*ContractSet) Len 

func (cs *ContractSet) Len() int

Len returns the number of contracts in the set.

func (*ContractSet) NewDownloader 

func (cs *ContractSet) NewDownloader(host modules.HostDBEntry, id types.FileContractID, currentHeight types.BlockHeight, hdb hostDB, cancel <-chan struct{}) (_ *Downloader, err error)

NewDownloader initiates the download request loop with a host, and returns a Downloader.

func (*ContractSet) NewEditor 

func (cs *ContractSet) NewEditor(host modules.HostDBEntry, id types.FileContractID, currentHeight types.BlockHeight, hdb hostDB, cancel <-chan struct{}) (_ *Editor, err error)

NewEditor initiates the contract revision process with a host, and returns an Editor.

func (*ContractSet) NewRawSession 

func (cs *ContractSet) NewRawSession(host modules.HostDBEntry, currentHeight types.BlockHeight, hdb hostDB, cancel <-chan struct{}) (_ *Session, err error)

NewRawSession creates a new session unassociated with any contract.

func (*ContractSet) NewSession 

func (cs *ContractSet) NewSession(host modules.HostDBEntry, id types.FileContractID, currentHeight types.BlockHeight, hdb hostDB, cancel <-chan struct{}) (_ *Session, err error)

NewSession initiates the RPC loop with a host and returns a Session.

func (*ContractSet) RateLimits 

func (cs *ContractSet) RateLimits() (readBPS int64, writeBPS int64, packetSize uint64)

RateLimits sets the bandwidth limits for connections created by the contractSet.

func (*ContractSet) Renew 

func (cs *ContractSet) Renew(oldContract *SafeContract, params ContractParams, txnBuilder transactionBuilder, tpool transactionPool, hdb hostDB, cancel <-chan struct{}) (rc modules.RenterContract, formationTxnSet []types.Transaction, sweepTxn types.Transaction, sweepParents []types.Transaction, err error)

Renew negotiates a new contract for data already stored with a host, and submits the new contract transaction to tpool. The new contract is added to the ContractSet and its metadata is returned.

func (*ContractSet) Return 

func (cs *ContractSet) Return(c *SafeContract)

Return returns a locked contract to the set and unlocks it. The contract must have been previously acquired by Acquire. If the contract is not present in the set, Return panics.

func (*ContractSet) SetRateLimits 

func (cs *ContractSet) SetRateLimits(readBPS int64, writeBPS int64, packetSize uint64)

SetRateLimits sets the bandwidth limits for connections created by the contractSet.

func (*ContractSet) View 

func (cs *ContractSet) View(id types.FileContractID) (modules.RenterContract, bool)

View returns a copy of the contract with the specified host key. The contracts is not locked. Certain fields, including the MerkleRoots, are set to nil for safety reasons. If the contract is not present in the set, View returns false and a zero-valued RenterContract.

func (*ContractSet) ViewAll 

func (cs *ContractSet) ViewAll() []modules.RenterContract

ViewAll returns the metadata of each contract in the set. The contracts are not locked.

type ContractSignedIdentifier 

type ContractSignedIdentifier [FCSignedIdentiferSize]byte

ContractSignedIdentifier is an identifier with a prefix and appended signature, ready to be stored in the arbitrary data section of a transaction.

func PrefixedSignedIdentifier 

func PrefixedSignedIdentifier(renterSeed EphemeralRenterSeed, txn types.Transaction, hostKey types.I3vPublicKey) (ContractSignedIdentifier, crypto.Ciphertext)

PrefixedSignedIdentifier is a helper function that creates a prefixed and signed identifier using a renter key and the first i3vcoin input of a transaction. NOTE: Always use PrefixedSignedIdentifier when creating identifiers for filecontracts. It wipes all the secrets required for creating the identifier from memory safely.

func (ContractSignedIdentifier) IsValid 

func (csi ContractSignedIdentifier) IsValid(renterSeed EphemeralRenterSeed, txn types.Transaction, hostKey crypto.Ciphertext) (types.I3vPublicKey, bool, error)

IsValid checks the signature against a seed and contract to determine if it was created using the specified seed.

type Downloader 

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

A Downloader retrieves sectors by calling the download RPC on a host. Downloaders are NOT thread- safe; calls to Sector must be serialized.

func (*Downloader) Close 

func (hd *Downloader) Close() error

Close cleanly terminates the download loop with the host and closes the connection.

func (*Downloader) Download 

func (hd *Downloader) Download(root crypto.Hash, offset, length uint32) (_ modules.RenterContract, _ []byte, err error)

Download retrieves the requested sector data and revises the underlying contract to pay the host proportionally to the data retrieved.

type Editor 

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

A Editor modifies a Contract by calling the revise RPC on a host. It Editors are NOT thread-safe; calls to Upload must happen in serial.

func (*Editor) Close 

func (he *Editor) Close() error

Close cleanly terminates the revision loop with the host and closes the connection.

func (*Editor) HostSettings 

func (he *Editor) HostSettings() modules.HostExternalSettings

HostSettings returns the settings that are active in the current session.

func (*Editor) Upload 

func (he *Editor) Upload(data []byte) (_ modules.RenterContract, _ crypto.Hash, err error)

Upload negotiates a revision that adds a sector to a file contract.

type EphemeralRenterSeed 

type EphemeralRenterSeed RenterSeed

EphemeralRenterSeed is a renter seed derived from the master renter seed. The master seed should never be used directly.

type MerkleRootSet 

type MerkleRootSet []crypto.Hash

MerkleRootSet is a set of Merkle roots, and gets encoded more efficiently.

func (MerkleRootSet) MarshalJSON 

func (mrs MerkleRootSet) MarshalJSON() ([]byte, error)

MarshalJSON defines a JSON encoding for a MerkleRootSet.

func (*MerkleRootSet) UnmarshalJSON 

func (mrs *MerkleRootSet) UnmarshalJSON(b []byte) error

UnmarshalJSON attempts to decode a MerkleRootSet, falling back on the legacy decoding of a []crypto.Hash if that fails.

type RenterSeed 

type RenterSeed modules.Seed

RenterSeed is the master seed of the renter which is used to derive other seeds.

func DeriveRenterSeed 

func DeriveRenterSeed(walletSeed modules.Seed) RenterSeed

DeriveRenterSeed creates a renterSeed for creating file contracts. NOTE: The seed returned by this function should be wiped once it's no longer in use.

func (RenterSeed) EphemeralRenterSeed 

func (rs RenterSeed) EphemeralRenterSeed(windowStart types.BlockHeight) EphemeralRenterSeed

EphemeralRenterSeed creates a renterSeed for creating file contracts. NOTE: The seed returned by this function should be wiped once it's no longer in use.

type SafeContract 

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

A SafeContract contains the most recent revision transaction negotiated with a host, and the secret key used to sign it.

func (*SafeContract) Metadata 

func (c *SafeContract) Metadata() modules.RenterContract

Metadata returns the metadata of a renter contract

func (*SafeContract) UpdateUtility 

func (c *SafeContract) UpdateUtility(utility modules.ContractUtility) error

UpdateUtility updates the utility field of a contract.

func (*SafeContract) Utility 

func (c *SafeContract) Utility() modules.ContractUtility

Utility returns the contract utility for the contract.

type Session 

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

A Session is an ongoing exchange of RPCs via the renter-host protocol.

TODO: The session type needs access to a logger. Probably the renter logger.

func (*Session) Append 

func (s *Session) Append(data []byte) (_ modules.RenterContract, _ crypto.Hash, err error)

Append calls the Write RPC with a single Append action, returning the updated contract and the Merkle root of the appended sector.

func (*Session) Close 

func (s *Session) Close() error

Close cleanly terminates the protocol session with the host and closes the connection.

func (*Session) HostSettings 

func (s *Session) HostSettings() modules.HostExternalSettings

HostSettings returns the currently active host settings of the session.

func (*Session) Lock 

func (s *Session) Lock(id types.FileContractID, secretKey crypto.SecretKey) (types.FileContractRevision, []types.TransactionSignature, error)

Lock calls the Lock RPC, locking the supplied contract and returning its most recent revision.

func (*Session) Read 

func (s *Session) Read(w io.Writer, req modules.LoopReadRequest, cancel <-chan struct{}) (_ modules.RenterContract, err error)

Read calls the Read RPC, writing the requested data to w. The RPC can be cancelled (with a granularity of one section) via the cancel channel.

func (*Session) ReadSection 

func (s *Session) ReadSection(root crypto.Hash, offset, length uint32) (_ modules.RenterContract, _ []byte, err error)

ReadSection calls the Read RPC with a single section and returns the requested data. A Merkle proof is always requested.

func (*Session) RecoverSectorRoots 

func (s *Session) RecoverSectorRoots(lastRev types.FileContractRevision, sk crypto.SecretKey) (_ types.Transaction, _ []crypto.Hash, err error)

RecoverSectorRoots calls the contract roots download RPC and returns the requested sector roots. The Revision and Signature fields of req are filled in automatically. If a Merkle proof is requested, it is verified.

func (*Session) Replace 

func (s *Session) Replace(data []byte, sectorIndex uint64, trim bool) (_ modules.RenterContract, _ crypto.Hash, err error)

Replace calls the Write RPC with a series of actions that replace the sector at the specified index with data, returning the updated contract and the Merkle root of the new sector.

func (*Session) SectorRoots 

func (s *Session) SectorRoots(req modules.LoopSectorRootsRequest) (_ modules.RenterContract, _ []crypto.Hash, err error)

SectorRoots calls the contract roots download RPC and returns the requested sector roots. The Revision and Signature fields of req are filled in automatically. If a Merkle proof is requested, it is verified.

func (*Session) Settings 

func (s *Session) Settings() (modules.HostExternalSettings, error)

Settings calls the Settings RPC, returning the host's reported settings.

func (*Session) Unlock 

func (s *Session) Unlock() error

Unlock calls the Unlock RPC, unlocking the currently-locked contract.

func (*Session) Write 

func (s *Session) Write(actions []modules.LoopWriteAction) (_ modules.RenterContract, err error)

Write implements the Write RPC, except for ActionUpdate. A Merkle proof is always requested.

type V130CachedRevision 

type V130CachedRevision struct {
	Revision    types.FileContractRevision `json:"revision"`
	MerkleRoots modules.MerkleRootSet      `json:"merkleroots"`
}

A V130CachedRevision contains changes that would be applied to a RenterContract if a contract revision succeeded.

type V130Contract 

type V130Contract struct {
	HostPublicKey    types.I3vPublicKey         `json:"hostpublickey"`
	ID               types.FileContractID       `json:"id"`
	LastRevision     types.FileContractRevision `json:"lastrevision"`
	LastRevisionTxn  types.Transaction          `json:"lastrevisiontxn"`
	MerkleRoots      MerkleRootSet              `json:"merkleroots"`
	SecretKey        crypto.SecretKey           `json:"secretkey"`
	StartHeight      types.BlockHeight          `json:"startheight"`
	DownloadSpending types.Currency             `json:"downloadspending"`
	StorageSpending  types.Currency             `json:"storagespending"`
	UploadSpending   types.Currency             `json:"uploadspending"`
	TotalCost        types.Currency             `json:"totalcost"`
	ContractFee      types.Currency             `json:"contractfee"`
	TxnFee           types.Currency             `json:"txnfee"`
	I3vfundFee       types.Currency             `json:"i3vfundfee"`
}

A V130Contract specifies the v130 contract format.

func (*V130Contract) EndHeight 

func (c *V130Contract) EndHeight() types.BlockHeight

EndHeight returns the height at which the host is no longer obligated to store contract data.

func (*V130Contract) RenterFunds 

func (c *V130Contract) RenterFunds() types.Currency

RenterFunds returns the funds remaining in the contract's Renter payout as of the most recent revision.

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.