D-Nice

/* Converts a hexadecimal string, whose bytes equivalent length 
can be up to 32 bytes (at least only tested and meant for up to 32 bytes)
into a bytes32 type.

EXAMPLE I/O
I: "a0c3689df9ce9c3aee5c1ba34dd1649098e2a10f6b2b337bf26695318cc0b958"
O: bytes32: 0xa0c3689df9ce9c3aee5c1ba34dd1649098e2a10f6b2b337bf26695318cc0b958

Currently assumes the 0x prefix is omitted from the string.

D-Nice

contract stringArrayToBytes {
    string[] x = ["qs2333332222222222222222222222222233333311", "q2", "q3", "5025", 
    "anotherquery", "oisjgsodjgdsogjsdgsdgsdgsdoigjsdiogjsodigjsdoigjsdog",
    "777777777", "88888888", "99999", "TEN"];

    function convert(string[] x, uint from, uint to) internal returns (bytes) {
        bytes memory z;
        uint zlen = 0;
        for (var i = from; i <= to; i++) {
            bytes memory y = bytes(x[i]);

D-Nice

// <ORACLIZE_API>
/*
Copyright (c) 2015-2016 Oraclize SRL
Copyright (c) 2016 Oraclize LTD



Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights

D-Nice

/*
   Kraken-based ETH/XBT price ticker

   This contract keeps in storage an updated ETH/XBT price,
   which is updated every ~60 seconds.
*/

pragma solidity ^0.4.0;
import "oraclizeLib.sol";

D-Nice

pragma solidity ^0.4.0;

contract ERC20 {
    function totalSupply() constant returns (uint totalSupply);
    function balanceOf(address _owner) constant returns (uint balance);
    function transfer(address _to, uint _value) returns (bool success);
    function transferFrom(address _from, address _to, uint _value) returns (bool success);
    function approve(address _spender, uint _value) returns (bool success);
    function allowance(address _owner, address _spender) constant returns (uint remaining);
    event Transfer(address indexed _from, address indexed _to, uint _value);

D-Nice

import { Architect, Config, Methods, Network, Neat } from 'neataptic'
import Parallel from 'paralleljs'

Config.warnings = false

const trainingSet = [
  { input: [0, 0], output: [0] },
  { input: [0, 1], output: [1] },
  { input: [1, 0], output: [1] },
  { input: [1, 1], output: [0] },

D-Nice

contract Precompile {
  function foo (bytes) returns (bytes32);
}

contract Testcontract {
  bytes32 last;

  event Debug(string message, bytes32 res);

  Precompile prec = Precompile(0x0000000000000000000000000000000000000002);

D-Nice

Keybase proof

I hereby claim:

• I am d-nice on github.
• I am dnice (https://keybase.io/dnice) on keybase.
• I have a public key ASCtj_8nf-4wse-7bAJeiOcnm0ItHHH7sW-VW7VwWoS0awo

To claim this, I am signing this object:

D-Nice

from datetime import datetime, timedelta
from hashlib import md5
from copy import deepcopy
import json

# creates an md5 hash dict for caching in memory
class Cache:
  # args expect seconds
  def __init__(self, expiry, clearInterval):
    if (not type(expiry) == int) or (not type(clearInterval) == int):

D-Nice

contract t {
    function getFirstCsv() returns (string c) {
        string memory _s = "1525452452,2,3,4,5";
        //return 1;
        assembly {
            /*mstore(add(mload(0x40), 0x20), mload(_s))
            mstore(add(mload(0x40), 0x40), mload(add(_s, 0x20)))
            mstore(mload(0x40), 0x20)
            return(mload(0x40), 0x60)*/
            let x := 0