func (this *transactor) TransactNameReg(privKey []byte, name, data string, amount, fee int64) (*Receipt, error) {
if len(privKey) != 64 {
return nil, fmt.Errorf("Private key is not of the right length: %d\n", len(privKey))
}
pk := &[64]byte{}
copy(pk[:], privKey)
this.txMtx.Lock()
defer this.txMtx.Unlock()
pa := account.GenPrivAccountFromPrivKeyBytes(pk)
cache := this.mempoolReactor.Mempool.GetCache()
acc := cache.GetAccount(pa.Address)
var sequence int
if acc == nil {
sequence = 1
} else {
sequence = acc.Sequence + 1
}
tx := types.NewNameTxWithNonce(pa.PubKey, name, data, amount, fee, sequence)
// Got ourselves a tx.
txS, errS := this.SignTx(tx, []*account.PrivAccount{pa})
if errS != nil {
return nil, errS
}
return this.BroadcastTx(txS)
}
func (this *transactor) SendAndHold(privKey, toAddress []byte, amount int64) (*Receipt, error) {
rec, tErr := this.Send(privKey, toAddress, amount)
if tErr != nil {
return nil, tErr
}
wc := make(chan *types.SendTx)
subId := fmt.Sprintf("%X", rec.TxHash)
this.eventEmitter.Subscribe(subId, types.EventStringAccOutput(toAddress), func(evt types.EventData) {
event := evt.(types.EventDataTx)
tx := event.Tx.(*types.SendTx)
wc <- tx
})
timer := time.NewTimer(300 * time.Second)
toChan := timer.C
var rErr error
pa := account.GenPrivAccountFromPrivKeyBytes(privKey)
select {
case <-toChan:
rErr = fmt.Errorf("Transaction timed out. Hash: " + subId)
case e := <-wc:
if bytes.Equal(e.Inputs[0].Address, pa.Address) && e.Inputs[0].Amount == amount {
timer.Stop()
this.eventEmitter.Unsubscribe(subId)
return rec, rErr
}
}
return nil, rErr
}
// Generate a new Private Key Account.
func (this *accounts) GenPrivAccountFromKey(privKey []byte) (*account.PrivAccount, error) {
if len(privKey) != 64 {
return nil, fmt.Errorf("Private key is not 64 bytes long.")
}
fmt.Printf("PK BYTES FROM ACCOUNTS: %x\n", privKey)
pa := account.GenPrivAccountFromPrivKeyBytes(privKey)
return pa, nil
}
func (this *transactor) Send(privKey, toAddress []byte, amount int64) (*Receipt, error) {
var toAddr []byte
if len(toAddress) == 0 {
toAddr = nil
} else if len(toAddress) != 20 {
return nil, fmt.Errorf("To-address is not of the right length: %d\n", len(toAddress))
} else {
toAddr = toAddress
}
if len(privKey) != 64 {
return nil, fmt.Errorf("Private key is not of the right length: %d\n", len(privKey))
}
pk := &[64]byte{}
copy(pk[:], privKey)
this.txMtx.Lock()
defer this.txMtx.Unlock()
pa := account.GenPrivAccountFromPrivKeyBytes(privKey)
cache := this.mempoolReactor.Mempool.GetCache()
acc := cache.GetAccount(pa.Address)
var sequence int
if acc == nil {
sequence = 1
} else {
sequence = acc.Sequence + 1
}
tx := types.NewSendTx()
txInput := &types.TxInput{
Address: pa.Address,
Amount: amount,
Sequence: sequence,
PubKey: pa.PubKey,
}
tx.Inputs = append(tx.Inputs, txInput)
txOutput := &types.TxOutput{toAddr, amount}
tx.Outputs = append(tx.Outputs, txOutput)
// Got ourselves a tx.
txS, errS := this.SignTx(tx, []*account.PrivAccount{pa})
if errS != nil {
return nil, errS
}
return this.BroadcastTx(txS)
}
func (this *transactor) Transact(privKey, address, data []byte, gasLimit, fee int64) (*Receipt, error) {
var addr []byte
if len(address) == 0 {
addr = nil
} else if len(address) != 20 {
return nil, fmt.Errorf("Address is not of the right length: %d\n", len(address))
} else {
addr = address
}
if len(privKey) != 64 {
return nil, fmt.Errorf("Private key is not of the right length: %d\n", len(privKey))
}
pk := &[64]byte{}
copy(pk[:], privKey)
this.txMtx.Lock()
defer this.txMtx.Unlock()
pa := account.GenPrivAccountFromPrivKeyBytes(pk)
cache := this.mempoolReactor.Mempool.GetCache()
acc := cache.GetAccount(pa.Address)
var sequence int
if acc == nil {
sequence = 1
} else {
sequence = acc.Sequence + 1
}
// fmt.Printf("Sequence %d\n", sequence)
txInput := &types.TxInput{
Address: pa.Address,
Amount: 1,
Sequence: sequence,
PubKey: pa.PubKey,
}
tx := &types.CallTx{
Input: txInput,
Address: addr,
GasLimit: gasLimit,
Fee: fee,
Data: data,
}
// Got ourselves a tx.
txS, errS := this.SignTx(tx, []*account.PrivAccount{pa})
if errS != nil {
return nil, errS
}
return this.BroadcastTx(txS)
}
func TestBondTxSignable(t *testing.T) {
privKeyBytes := make([]byte, 64)
var privKeyArray [64]byte
copy(privKeyArray[:], privKeyBytes)
privAccount := acm.GenPrivAccountFromPrivKeyBytes(&privKeyArray)
bondTx := &BondTx{
PubKey: privAccount.PubKey.(acm.PubKeyEd25519),
Inputs: []*TxInput{
&TxInput{
Address: []byte("input1"),
Amount: 12345,
Sequence: 67890,
},
&TxInput{
Address: []byte("input2"),
Amount: 111,
Sequence: 222,
},
},
UnbondTo: []*TxOutput{
&TxOutput{
Address: []byte("output1"),
Amount: 333,
},
&TxOutput{
Address: []byte("output2"),
Amount: 444,
},
},
}
signBytes := acm.SignBytes(chainID, bondTx)
signStr := string(signBytes)
expected := Fmt(`{"chain_id":"%s","tx":[17,{"inputs":[{"address":"696E70757431","amount":12345,"sequence":67890},{"address":"696E70757432","amount":111,"sequence":222}],"pub_key":[1,"3B6A27BCCEB6A42D62A3A8D02A6F0D73653215771DE243A63AC048A18B59DA29"],"unbond_to":[{"address":"6F757470757431","amount":333},{"address":"6F757470757432","amount":444}]}]}`,
config.GetString("chain_id"))
if signStr != expected {
t.Errorf("Unexpected sign string for BondTx. \nGot %s\nExpected %s", signStr, expected)
}
}