Rules

function asBig(str) {
 if (str.slice(0, 2) == "0x") {
  return new BigNumber(str.slice(2), 16)
 }
 return new BigNumber(str)
}

// Approve transactions to a certain contract if value is below a certain limit
function ApproveTx(req) {
 var limit = big.Newint("0xb1a2bc2ec50000")
 var value = asBig(req.transaction.value);

 if (req.transaction.to.toLowerCase() == "0xae967917c465db8578ca9024c205720b1a3651a9") && value.lt(limit)) {
  return "Approve"
 }
 // If we return "Reject", it will be rejected.
 // By not returning anything, the decision to approve/reject
 // will be passed to the next UI, for manual processing
}

// Approve listings if request made from IPC
function ApproveListing(req){
    if (req.metadata.scheme == "ipc"){ return "Approve"}
}

function ApproveTx(r) {
  if (r.transaction.to.toLowerCase() == '0x0000000000000000000000000000000000001337') {
    return 'Approve';
  }
  if (r.transaction.to.toLowerCase() == '0x000000000000000000000000000000000000dead') {
    return 'Reject';
  }
  // Otherwise goes to manual processing
}

function ApproveListing() {
  return 'Approve';
}

function ApproveSignData(req) {
  if (req.address.toLowerCase() == '0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3') {
    if (req.messages[0].value.indexOf('bazonk') >= 0) {
      return 'Approve';
    }
    return 'Reject';
  }
  // Otherwise goes to manual processing
}

function big(str) {
  if (str.slice(0, 2) == '0x') {
    return new BigNumber(str.slice(2), 16);
  }
  return new BigNumber(str);
}

// Time window: 1 week
var window = 1000 * 3600 * 24 * 7;

// Limit : 1 lax
var limit = new BigNumber('1e18');

function isLimitOk(transaction) {
  var value = big(transaction.value);
  // Start of our window function
  var windowstart = new Date().getTime() - window;

  var txs = [];
  var stored = storage.get('txs');

  if (stored != '') {
    txs = JSON.parse(stored);
  }
  // First, remove all that have passed out of the time-window
  var newtxs = txs.filter(function (tx) {
    return tx.tstamp > windowstart;
  });
  console.log(txs, newtxs.length);

  // Secondly, aggregate the current sum
  sum = new BigNumber(0);

  sum = newtxs.reduce(function (agg, tx) {
    return big(tx.value).plus(agg);
  }, sum);
  console.log('ApproveTx > Sum so far', sum);
  console.log('ApproveTx > Requested', value.toNumber());

  // Would we exceed weekly limit ?
  return sum.plus(value).lt(limit);
}
function ApproveTx(r) {
  if (isLimitOk(r.transaction)) {
    return 'Approve';
  }
  return 'Nope';
}

/**
 * OnApprovedTx(str) is called when a transaction has been approved and signed. The parameter
 * 'response_str' contains the return value that will be sent to the external caller.
 * The return value from this method is ignore - the reason for having this callback is to allow the
 * ruleset to keep track of approved transactions.
 *
 * When implementing rate-limited rules, this callback should be used.
 * If a rule responds with neither 'Approve' nor 'Reject' - the tx goes to manual processing. If the user
 * then accepts the transaction, this method will be called.
 *
 * TLDR; Use this method to keep track of signed transactions, instead of using the data in ApproveTx.
 */
function OnApprovedTx(resp) {
  var value = big(resp.tx.value);
  var txs = [];
  // Load stored transactions
  var stored = storage.get('txs');
  if (stored != '') {
    txs = JSON.parse(stored);
  }
  // Add this to the storage
  txs.push({ tstamp: new Date().getTime(), value: value });
  storage.put('txs', JSON.stringify(txs));
}