// generateSpendableKey creates the keys and unlock conditions a given index of a
// seed.
func generateSpendableKey(seed modules.Seed, index uint64) spendableKey {
// Generate the keys and unlock conditions.
entropy := crypto.HashAll(seed, index)
sk, pk := crypto.DeterministicSignatureKeys(entropy)
return spendableKey{
UnlockConditions: generateUnlockConditions(pk),
SecretKeys: []crypto.SecretKey{sk},
}
}
// negotiateContract establishes a connection to a host and negotiates an
// initial file contract according to the terms of the host.
func (hu *hostUploader) negotiateContract(filesize uint64, duration types.BlockHeight) error {
conn, err := net.DialTimeout("tcp", string(hu.settings.IPAddress), 15*time.Second)
if err != nil {
return err
}
defer conn.Close()
// inital calculations before connecting to host
lockID := hu.renter.mu.RLock()
height := hu.renter.blockHeight
hu.renter.mu.RUnlock(lockID)
renterCost := hu.settings.Price.Mul(types.NewCurrency64(filesize)).Mul(types.NewCurrency64(uint64(duration)))
renterCost = renterCost.MulFloat(1.05) // extra buffer to guarantee we won't run out of money during revision
payout := renterCost // no collateral
// get an address from the wallet
ourAddr, err := hu.renter.wallet.NextAddress()
if err != nil {
return err
}
// write rpcID
if err := encoding.WriteObject(conn, modules.RPCUpload); err != nil {
return err
}
// read host key
// TODO: need to save this?
var hostPublicKey types.SiaPublicKey
if err := encoding.ReadObject(conn, &hostPublicKey, 256); err != nil {
return err
}
// create our own key by combining the renter entropy with the host key
entropy := crypto.HashAll(hu.renter.entropy, hostPublicKey)
ourSK, ourPK := crypto.DeterministicSignatureKeys(entropy)
ourPublicKey := types.SiaPublicKey{
Algorithm: types.SignatureEd25519,
Key: ourPK[:],
}
hu.secretKey = ourSK // used to sign future revisions
// send our public key
if err := encoding.WriteObject(conn, ourPublicKey); err != nil {
return err
}
// create unlock conditions
hu.unlockConditions = types.UnlockConditions{
PublicKeys: []types.SiaPublicKey{ourPublicKey, hostPublicKey},
SignaturesRequired: 2,
}
// create file contract
fc := types.FileContract{
FileSize: 0,
FileMerkleRoot: crypto.Hash{}, // no proof possible without data
WindowStart: height + duration,
WindowEnd: height + duration + hu.settings.WindowSize,
Payout: payout,
UnlockHash: hu.unlockConditions.UnlockHash(),
RevisionNumber: 0,
}
// outputs need account for tax
fc.ValidProofOutputs = []types.SiacoinOutput{
{Value: renterCost.Sub(fc.Tax()), UnlockHash: ourAddr.UnlockHash()},
{Value: types.ZeroCurrency, UnlockHash: hu.settings.UnlockHash}, // no collateral
}
fc.MissedProofOutputs = []types.SiacoinOutput{
// same as above
fc.ValidProofOutputs[0],
// goes to the void, not the renter
{Value: types.ZeroCurrency, UnlockHash: types.UnlockHash{}},
}
// build transaction containing fc
txnBuilder := hu.renter.wallet.StartTransaction()
err = txnBuilder.FundSiacoins(fc.Payout)
if err != nil {
return err
}
txnBuilder.AddFileContract(fc)
txn, parents := txnBuilder.View()
txnSet := append(parents, txn)
// calculate contract ID
fcid := txn.FileContractID(0) // TODO: is it actually 0?
// send txn
if err := encoding.WriteObject(conn, txnSet); err != nil {
txnBuilder.Drop()
return err
}
// read back acceptance
var response string
if err := encoding.ReadObject(conn, &response, 128); err != nil {
txnBuilder.Drop()
return err
}
if response != modules.AcceptResponse {
txnBuilder.Drop()
return errors.New("host rejected proposed contract: " + response)
}
// read back txn with host collateral.
var hostTxnSet []types.Transaction
if err := encoding.ReadObject(conn, &hostTxnSet, types.BlockSizeLimit); err != nil {
txnBuilder.Drop()
return err
}
// check that txn is okay. For now, no collateral will be added, so the
// transaction sets should be identical.
if len(hostTxnSet) != len(txnSet) {
txnBuilder.Drop()
return errors.New("host sent bad collateral transaction")
}
for i := range hostTxnSet {
if hostTxnSet[i].ID() != txnSet[i].ID() {
txnBuilder.Drop()
return errors.New("host sent bad collateral transaction")
}
}
// sign the txn and resend
// NOTE: for now, we are assuming that the transaction has not changed
// since we sent it. Otherwise, the txnBuilder would have to be updated
// with whatever fields were added by the host.
signedTxnSet, err := txnBuilder.Sign(true)
if err != nil {
txnBuilder.Drop()
return err
}
if err := encoding.WriteObject(conn, signedTxnSet); err != nil {
txnBuilder.Drop()
return err
}
// read signed txn from host
var signedHostTxnSet []types.Transaction
if err := encoding.ReadObject(conn, &signedHostTxnSet, types.BlockSizeLimit); err != nil {
txnBuilder.Drop()
return err
}
// submit to blockchain
err = hu.renter.tpool.AcceptTransactionSet(signedHostTxnSet)
if err == modules.ErrDuplicateTransactionSet {
// this can happen if the renter is uploading to itself
err = nil
}
if err != nil {
txnBuilder.Drop()
return err
}
// create initial fileContract object
hu.contract = fileContract{
ID: fcid,
IP: hu.settings.IPAddress,
WindowStart: fc.WindowStart,
}
lockID = hu.renter.mu.Lock()
hu.renter.contracts[fcid] = fc
hu.renter.mu.Unlock(lockID)
return nil
}