func TestNegotiateContract(t *testing.T) {
if testing.Short() {
t.SkipNow()
}
rt, err := newRenterTester("TestNegotiateContract")
if err != nil {
t.Fatal(err)
}
payout := types.NewCurrency64(1e16)
fc := types.FileContract{
FileSize: 0,
FileMerkleRoot: crypto.Hash{}, // no proof possible without data
WindowStart: 100,
WindowEnd: 1000,
Payout: payout,
ValidProofOutputs: []types.SiacoinOutput{
{Value: payout, UnlockHash: types.UnlockHash{}},
{Value: types.ZeroCurrency, UnlockHash: types.UnlockHash{}},
},
MissedProofOutputs: []types.SiacoinOutput{
// same as above
{Value: payout, UnlockHash: types.UnlockHash{}},
// goes to the void, not the renter
{Value: types.ZeroCurrency, UnlockHash: types.UnlockHash{}},
},
UnlockHash: types.UnlockHash{},
RevisionNumber: 0,
}
fc.ValidProofOutputs[0].Value = fc.ValidProofOutputs[0].Value.Sub(fc.Tax())
fc.MissedProofOutputs[0].Value = fc.MissedProofOutputs[0].Value.Sub(fc.Tax())
txnBuilder := rt.wallet.StartTransaction()
err = txnBuilder.FundSiacoins(fc.Payout)
if err != nil {
t.Fatal(err)
}
txnBuilder.AddFileContract(fc)
signedTxnSet, err := txnBuilder.Sign(true)
if err != nil {
t.Fatal(err)
}
err = rt.tpool.AcceptTransactionSet(signedTxnSet)
if err != nil {
t.Fatal(err)
}
}
// 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
}
func TestReviseContract(t *testing.T) {
if testing.Short() {
t.SkipNow()
}
rt, err := newRenterTester("TestNegotiateContract")
if err != nil {
t.Fatal(err)
}
// get an address
ourAddr, err := rt.wallet.NextAddress()
if err != nil {
t.Fatal(err)
}
// generate keys
sk, pk, err := crypto.GenerateSignatureKeys()
if err != nil {
t.Fatal(err)
}
renterPubKey := types.SiaPublicKey{
Algorithm: types.SignatureEd25519,
Key: pk[:],
}
uc := types.UnlockConditions{
PublicKeys: []types.SiaPublicKey{renterPubKey, renterPubKey},
SignaturesRequired: 1,
}
// create file contract
payout := types.NewCurrency64(1e16)
fc := types.FileContract{
FileSize: 0,
FileMerkleRoot: crypto.Hash{}, // no proof possible without data
WindowStart: 100,
WindowEnd: 1000,
Payout: payout,
UnlockHash: uc.UnlockHash(),
RevisionNumber: 0,
}
// outputs need account for tax
fc.ValidProofOutputs = []types.SiacoinOutput{
{Value: payout.Sub(fc.Tax()), UnlockHash: ourAddr.UnlockHash()},
{Value: types.ZeroCurrency, UnlockHash: types.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{}},
}
txnBuilder := rt.wallet.StartTransaction()
err = txnBuilder.FundSiacoins(fc.Payout)
if err != nil {
t.Fatal(err)
}
txnBuilder.AddFileContract(fc)
signedTxnSet, err := txnBuilder.Sign(true)
if err != nil {
t.Fatal(err)
}
// submit contract
err = rt.tpool.AcceptTransactionSet(signedTxnSet)
if err != nil {
t.Fatal(err)
}
// create revision
fcid := signedTxnSet[len(signedTxnSet)-1].FileContractID(0)
rev := types.FileContractRevision{
ParentID: fcid,
UnlockConditions: uc,
NewFileSize: 10,
NewWindowStart: 100,
NewWindowEnd: 1000,
NewRevisionNumber: 1,
NewValidProofOutputs: fc.ValidProofOutputs,
NewMissedProofOutputs: fc.MissedProofOutputs,
}
// create transaction containing the revision
signedTxn := types.Transaction{
FileContractRevisions: []types.FileContractRevision{rev},
TransactionSignatures: []types.TransactionSignature{{
ParentID: crypto.Hash(fcid),
CoveredFields: types.CoveredFields{FileContractRevisions: []uint64{0}},
PublicKeyIndex: 0, // renter key is always first -- see negotiateContract
}},
}
// sign the transaction
encodedSig, err := crypto.SignHash(signedTxn.SigHash(0), sk)
if err != nil {
t.Fatal(err)
}
signedTxn.TransactionSignatures[0].Signature = encodedSig[:]
err = signedTxn.StandaloneValid(rt.renter.blockHeight)
if err != nil {
t.Fatal(err)
}
// submit revision
err = rt.tpool.AcceptTransactionSet([]types.Transaction{signedTxn})
if err != nil {
t.Fatal(err)
}
}
