Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
p2pClient.on('status-changed', (s) => {
// console.log('STATUS', s)
if (s === 'connected') {
start = Date.now();
for (var i = 0; i < 1000; i++) {
transferredAmount = transferredAmount.add(new util.BN(1));
engine.sendDirectTransfer(util.toBuffer(acct4), transferredAmount);
//var msg = sendQueue[sendQueue.length -1];
}
end = Date.now();
cl("Direct Transfers Sent Per SECOND per USER " + 1000 / ((end - start) / 1000));
}
}
)
assert(exitRecord[6].toNumber() === 0)
assert(exitRecord[7] === true)
assert(exitRecord[8] === false)
//now lets offer a buyoyt for half of the amount
// function publishPreacceptedBuyout(
// bytes22 _index,
// uint256 _amount,
// address _beneficiary,
// uint8 v,
// bytes32 r,
// bytes32 s
// )
const valueBuffer = (new BN(50)).toBuffer("be", 32)
const dataToSign = Buffer.concat([ethUtil.toBuffer(exitRecordHash), valueBuffer, ethUtil.toBuffer(bob)])
const hashToSign = ethUtil.hashPersonalMessage(dataToSign)
const signature = ethUtil.ecsign(hashToSign, aliceKey)
const {v, r, s} = signature
let oldBalanceAlice = await web3.eth.getBalance(alice);
submissionReceipt = await plasma.publishPreacceptedBuyout(
exitRecordHash,
50,
bob,
v,
ethUtil.bufferToHex(r),
ethUtil.bufferToHex(s),
{from: bob, value: 50})
assert(submissionReceipt.logs.length == 1);
let offer = await plasma.exitBuyoutOffers(exitRecordHash);
assert(offer[1] === bob);
assert(offer[0].toString(10) === "50");
function compareDefaultHeader(st: tape.Test, header: BlockHeader) {
st.deepEqual(header.parentHash, utils.zeros(32))
st.equal(header.uncleHash.toString('hex'), utils.KECCAK256_RLP_ARRAY_S)
st.deepEqual(header.coinbase, utils.zeros(20))
st.deepEqual(header.stateRoot, utils.zeros(32))
st.equal(header.transactionsTrie.toString('hex'), utils.KECCAK256_RLP_S)
st.equal(header.receiptTrie.toString('hex'), utils.KECCAK256_RLP_S)
st.deepEqual(header.bloom, utils.zeros(256))
st.deepEqual(header.difficulty, Buffer.from([]))
st.deepEqual(header.number, utils.toBuffer(1150000))
st.deepEqual(header.gasLimit, Buffer.from('ffffffffffffff', 'hex'))
st.deepEqual(header.gasUsed, Buffer.from([]))
st.deepEqual(header.timestamp, Buffer.from([]))
st.deepEqual(header.extraData, Buffer.from([]))
st.deepEqual(header.mixHash, utils.zeros(32))
st.deepEqual(header.nonce, utils.zeros(8))
}
toRpc() {
const res = {
blockNum: toRPC(this.blockNum),
txIdx: toRPC(this.txIdx),
outIdx: toRPC(this.outIdx),
owner: ejs.toBuffer(this.owner),
depositNonce: toRPC(this.depositNonce)
};
return res;
}
function signResetRecoveryOwner(
recoveryModuleAddress, oldRecoveryOwner, newRecoveryOwner, recoveryOwnerPrivateKey,
) {
const resetRecoveryOwnerHash = hashRecoveryModuleResetOwner(
recoveryModuleAddress, oldRecoveryOwner, newRecoveryOwner,
);
const signature = EthUtils.ecsign(
EthUtils.toBuffer(resetRecoveryOwnerHash),
EthUtils.toBuffer(recoveryOwnerPrivateKey),
);
return {
resetRecoveryOwnerHash,
signature,
};
}
Object.keys(data).forEach(function(i) {
if (i !== 'homestead' && typeof data[i] === 'string') {
data[i] = isHexPrefixed(data[i]) ? new BN(utils.toBuffer(data[i])) : new BN(data[i])
}
})
}
function toBufferBlock (jsonBlock) {
return {
number: ethUtil.toBuffer(jsonBlock.number),
hash: ethUtil.toBuffer(jsonBlock.hash),
parentHash: ethUtil.toBuffer(jsonBlock.parentHash),
nonce: ethUtil.toBuffer(jsonBlock.nonce),
sha3Uncles: ethUtil.toBuffer(jsonBlock.sha3Uncles),
logsBloom: ethUtil.toBuffer(jsonBlock.logsBloom),
transactionsRoot: ethUtil.toBuffer(jsonBlock.transactionsRoot),
stateRoot: ethUtil.toBuffer(jsonBlock.stateRoot),
receiptsRoot: ethUtil.toBuffer(jsonBlock.receiptRoot || jsonBlock.receiptsRoot),
miner: ethUtil.toBuffer(jsonBlock.miner),
difficulty: ethUtil.toBuffer(jsonBlock.difficulty),
totalDifficulty: ethUtil.toBuffer(jsonBlock.totalDifficulty),
size: ethUtil.toBuffer(jsonBlock.size),
extraData: ethUtil.toBuffer(jsonBlock.extraData),
gasLimit: ethUtil.toBuffer(jsonBlock.gasLimit),
gasUsed: ethUtil.toBuffer(jsonBlock.gasUsed),
timestamp: ethUtil.toBuffer(jsonBlock.timestamp),
async function putBlocks(blockchain: any, hardfork: string, testData: any) {
for (const blockData of testData.blocks) {
const block = new Block(utils.toBuffer(blockData.rlp), { hardfork })
await promisify(blockchain.putBlock.bind(blockchain))(block)
}
}
async function getUTXOforAddressWithIndex(addressString, cb) {
addressString = ethUtil.addHexPrefix(addressString)
if (!ethUtil.isValidAddress(addressString)){
cb(true, null);
}
address = ethUtil.toBuffer(addressString);
const utxos = [];
const start = Buffer.concat([utxoIncludingAddressPrefix,
address,
Buffer.alloc(blockNumberLength),
Buffer.alloc(txNumberLength),
Buffer.alloc(txOutputNumberLength)])
const stop = Buffer.concat([utxoIncludingAddressPrefix,
address,
Buffer.from("ff".repeat(blockNumberLength), 'hex'),
Buffer.from("ff".repeat(txNumberLength), 'hex'),
Buffer.from("ff".repeat(txOutputNumberLength), 'hex')])
const sliceStart = utxoIncludingAddressPrefix.length + address.length;
levelDB.createReadStream({gte: start,
lte: stop,
reversed:true})
.on('data', function (data) {