{
  "trx_id": "6f5c1cf4dd7bc0c0770fbd4122d90aad1cc42f73",
  "block": 106151085,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-05-18T06:38:42",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "7108.301829 VESTS"
    }
  ]
}

{
  "trx_id": "be55e968c05de6d9bee4069198cfedafbc5b0df8",
  "block": 106006850,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-05-13T05:51:03",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "4396.091424 VESTS"
    }
  ]
}

{
  "trx_id": "ac3508cada45770e3d1f738aaefda2429b0ef4ce",
  "block": 105518559,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-04-26T05:49:57",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "7120.817585 VESTS"
    }
  ]
}

{
  "trx_id": "27a1321c88f47eb215b5a0ea4dab394674118fec",
  "block": 102872444,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-01-24T01:01:36",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "4437.638243 VESTS"
    }
  ]
}

{
  "trx_id": "370d82076d3ea419ec1612d5c96d0899dce86eeb",
  "block": 91318654,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2024-12-17T20:11:21",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "4601.857440 VESTS"
    }
  ]
}

{
  "trx_id": "bb8883b44e72a2153efc0f73842cf6e42bf54bab",
  "block": 79872789,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2023-11-14T11:52:00",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "4770.990972 VESTS"
    }
  ]
}

{
  "trx_id": "53da13e5966704fba930b2e74eaa7048b0f0a8b9",
  "block": 78363390,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2023-09-22T10:49:45",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "7707.899758 VESTS"
    }
  ]
}

{
  "trx_id": "8d2f02618dbf33bb09333d9665a06f7a878e1cd0",
  "block": 69121055,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2022-11-03T18:13:42",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "7929.951196 VESTS"
    }
  ]
}

{
  "trx_id": "9e2748c0ceda8038b073c0ed15434dbc0f4bba90",
  "block": 60824262,
  "trx_in_block": 40,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2022-01-17T23:23:30",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "8150.058797 VESTS"
    }
  ]
}

{
  "trx_id": "0cd1ded835d3cdfffd2391da153f808a7bdf7cab",
  "block": 54614563,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-06-14T06:33:18",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "8334.253085 VESTS"
    }
  ]
}

{
  "trx_id": "d5c3b3f2cedc12918c501bd3fed476b3bbb66c55",
  "block": 49361813,
  "trx_in_block": 8,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-12-11T16:45:06",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "8521.675059 VESTS"
    }
  ]
}

{
  "trx_id": "d45052532070e60193877d70934615931f48ff2e",
  "block": 49213329,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-12-06T10:20:39",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "1912.543513 VESTS"
    }
  ]
}

{
  "trx_id": "8564cf4f03331e6bbd2fb28d8faf7b523efd2a94",
  "block": 49196900,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-12-05T20:23:03",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "8527.882913 VESTS"
    }
  ]
}

{
  "trx_id": "120befabefee3d514f74182ca0731e79eaba8373",
  "block": 48271540,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-11-03T03:18:30",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "1920.017158 VESTS"
    }
  ]
}

{
  "trx_id": "1c977250dde649049d1f14580cc478dc9c37dba5",
  "block": 43223667,
  "trx_in_block": 14,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-05-09T11:24:12",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "8730.688272 VESTS"
    }
  ]
}

{
  "trx_id": "90769f5883fce553fc3f6959a43d39a3a0c945db",
  "block": 43200761,
  "trx_in_block": 15,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-05-08T15:51:00",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "1953.311140 VESTS"
    }
  ]
}

{
  "trx_id": "fc5610ba5e2b64a32f07e51c21ddda97d796b66b",
  "block": 36596247,
  "trx_in_block": 37,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-09-20T20:31:30",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "8861.697437 VESTS"
    }
  ]
}

{
  "trx_id": "bd2101a6fc1baf4eef41da7f6b98434d114d7b74",
  "block": 33781346,
  "trx_in_block": 10,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-06-14T03:32:24",
  "op": [
    "comment",
    {
      "parent_author": "slumber1122",
      "parent_permlink": "nodejs",
      "author": "steemitboard",
      "permlink": "steemitboard-notify-slumber1122-20190614t033224000z",
      "title": "",
      "body": "Congratulations @slumber1122! You received a personal award!\n\n<table><tr><td>https://steemitimages.com/70x70/http://steemitboard.com/@slumber1122/birthday2.png</td><td>Happy Birthday! - You are on the Steem blockchain for 2 years!</td></tr></table>\n\n<sub>_You can view [your badges on your Steem Board](https://steemitboard.com/@slumber1122) and compare to others on the [Steem Ranking](https://steemitboard.com/ranking/index.php?name=slumber1122)_</sub>\n\n\n###### [Vote for @Steemitboard as a witness](https://v2.steemconnect.com/sign/account-witness-vote?witness=steemitboard&approve=1) to get one more award and increased upvotes!",
      "json_metadata": "{\"image\":[\"https://steemitboard.com/img/notify.png\"]}"
    }
  ]
}

{
  "trx_id": "5f2acb6d119607bf8a7277b225a26ef03b08b09e",
  "block": 26718424,
  "trx_in_block": 12,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-10-11T16:08:06",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "9059.685317 VESTS"
    }
  ]
}

{
  "trx_id": "d5eea617fd6034efb5000c9a9b00e351a71d35cf",
  "block": 26154533,
  "trx_in_block": 9,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-22T01:44:33",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "29281.814707 VESTS"
    }
  ]
}

{
  "trx_id": "5f882869eb2cc32205851d03a3877d8bb130be55",
  "block": 24112633,
  "trx_in_block": 22,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-07-12T13:58:57",
  "op": [
    "account_update",
    {
      "account": "slumber1122",
      "memo_key": "STM8AxZU8ygFFWR25CCYWP5kidhMvax4doZjCwy4EHmjHsB6XEPcj",
      "json_metadata": "{\"profile\":{\"name\":\"wade\",\"about\":\"programer\",\"location\":\"nanjing\",\"website\":\"https://github.com/slumber1122\",\"profile_image\":\"http://pic.baike.soso.com/ugc/baikepic2/23868/cut-20140815161513-1150723709.jpg/0\"}}"
    }
  ]
}

{
  "trx_id": "173e98a824edf52a657cf21d63575f9d3fab45b4",
  "block": 24112593,
  "trx_in_block": 52,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-07-12T13:56:57",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "slumber1122"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"slumber1122\",\"following\":\"dantheman\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "ea4bb533640d4516db69dce8952bdf7999912687",
  "block": 22935387,
  "trx_in_block": 14,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-01T07:56:48",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "slumber1122"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"slumber1122\",\"following\":\"eostribe\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "1ec5e55492383e0645d19a4e65a1566554fc9100",
  "block": 22548203,
  "trx_in_block": 13,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-05-18T20:55:36",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "29484.161948 VESTS"
    }
  ]
}

{
  "trx_id": "1f3e892c4102bd839898fe0f5fbbe5d8c4e1f7f8",
  "block": 22415474,
  "trx_in_block": 13,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-05-14T06:18:12",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "slumber1122"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"slumber1122\",\"following\":\"lior-h\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "d92a77567db5d7effbf7dc3c003e414fd44154b7",
  "block": 21211031,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-04-02T09:53:06",
  "op": [
    "vote",
    {
      "voter": "slumber1122",
      "author": "tooooolong",
      "permlink": "eoscrowdsale-contract-inspect",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "0eda8d93e3cb3106cebedfd2172c499254588077",
  "block": 21211013,
  "trx_in_block": 29,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-04-02T09:52:12",
  "op": [
    "vote",
    {
      "voter": "slumber1122",
      "author": "slumber1122",
      "permlink": "re-tooooolong-eoscrowdsale-contract-inspect-20170628t135011447z",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "e371718ddb6c4597141eab0b6125f85e97bc3609",
  "block": 18820261,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-01-09T07:13:15",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "29689.795574 VESTS"
    }
  ]
}

{
  "trx_id": "9b8134b356b2684d3a165a8fcf6ed00d8920bffd",
  "block": 14271458,
  "trx_in_block": 8,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-04T05:19:03",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "slumber1122",
      "vesting_shares": "29940.642023 VESTS"
    }
  ]
}

{
  "trx_id": "4724a2391889a3e6d8242f0c26724dd550b7b2ea",
  "block": 13871733,
  "trx_in_block": 20,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-07-21T07:58:15",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "send",
      "author": "slumber1122",
      "permlink": "nodejs",
      "title": "使用Nodejs部署智能合约",
      "body": "##使用nodejs部署智能合约\n\n实现智能合约的方式很多种，可以用truffle框架来实现，编译，部署。\n这里介绍一种简单的使用nodejs来实现，编译，部署的方法。\n创建一个nodejs项目，实现一个简单的智能合约。\n```\nmkdir sm && cd sm\nnpm init\nmkdir contracts && cd contracts\nvi BaseToken.sol\n\n//BaseToken.sol\ncontract Token{\n    address public owner;\n    mapping (address => uint) public balances;\n    event Sent(address from, address to, uint amount)\n    function Token(){\n        owner = msg.sender;\n        balances[owner] = 100000000;\n    }\n    function send(address receiver, uint amount){\n        if (balances[msg.sender] < amount) return;\n        balances[msg.sender] -= amount;\n        balances[receiver] += amount;\n        Sent(msg.sender, receiver, amount);\n    }\n}\n```\n这个合约实现了一个造币和转币的逻辑。\n我们的合约是运行在evm上面的字节码，solidity是静态语言，需要通过编译器生成evm的字节码。\n```\n\nvi compile.js\n\n// compile.js\nconst fs = require('fs')\nconst solc = require('solc')\n//编译合约\nlet source = fs.readFileSync(\"./contracts/BaseToken.sol\", 'utf8')\nconsole.log('compiling contract...');\nlet compiledContract = solc.compile(source);\nconsole.log('done');\n\nfor (let contractName in compiledContract.contracts) {\n    var bytecode = compiledContract.contracts[contractName].bytecode;\n    var abi = JSON.parse(compiledContract.contracts[contractName].interface);\n}\nconsole.log(bytecode)\n\n```\n调用`node compile.js`,对BaseToken进行编译，生成字节码。web3中提供了一个部署合约的接口，使用如下，\n```\nlet gasEstimate = web3.eth.estimateGas({data: '0x' + bytecode});\nconsole.log('gasEstimate: ' + gasEstimate)\n\n\nlet MyContract = web3.eth.contract(abi);\n\nconsole.log('deploying contract...');\n\n\nlet myContractReturned = MyContract.new([], {\n  from: address,\n  data: '0x' + bytecode,\n  gas: gasEstimate+50000\n}, function(err, myContract){\n  if(!err){\n    if(!myContract.address){\n      console.log(`myContract.transactionHash = ${myContract.transactionHash}`);\n    }else{\n      console.log(`myContract.address = ${myContract.address}`); // the contract address\n      global.contractAddress = myContract.address;\n    }\n}else{\n    console.log(err);\n}\n});\n```\n利用编译生成的abi和bytecode，创建一个合约对象，然后进行发布，等待着异步执行的方法输出合约地址`contractAddress`，这样就完成了部署。不过这种方式有一个问题，就是在发布合约时，你的私钥处于联网状态，\n处于安全策略，我们需要尽量避免私钥在联网状态。\n\n以太坊上部署合约是向空地址发送一个附有字节码的签名交易，其中发送者就是这个合约的拥有者。因此我们只需要将合约构建成一笔交易，我们在无网状态下对这笔交易进行签名，然后将签名发送到以太坊网络中。这样能够降低我们私钥被泄漏的风险。\n对合约的签名方法如下：\n```\nvar Tx = require('ethereumjs-tx')\nconst rawTx = {\n    nonce: '0x6', //这个是你的地址的交易次数+1，0开始\n    gasPrice: '0x12a05f200',\n    gasLimit: '0x493e0',\n    data: bytecode,\n    from: address,\n    to: \"\"\n};\nconst tx = new Tx(rawTx);\ntx.sign(privateKey);\nconst serializedTx = tx.serialize();\nconsole.log(serializedTx.toString('hex'))\n```\n以上对一个合约签名，这里需要注意的问题是，to的地址需要是，空地址。\n完成签名之后，我们把这笔交易发送出去就好，最简单的方法就是使用[etherscan的发送Tx的方式](https://etherscan.io/pushTx)，一旦发送完成，部署完成，就可以看到合约地址。",
      "json_metadata": "{\"tags\":[\"ico\",\"contract\",\"nodejs\",\"send\"],\"links\":[\"https://etherscan.io/pushTx\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "0482b15e77cc22b17d1983960e0c975c0e9828f8",
  "block": 13814533,
  "trx_in_block": 16,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-07-19T08:15:36",
  "op": [
    "vote",
    {
      "voter": "proctologic",
      "author": "slumber1122",
      "permlink": "nodejs",
      "weight": 100
    }
  ]
}

{
  "trx_id": "82d7bb634ed3c5ce47c44612a7bfda467bd91ebb",
  "block": 13814532,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-07-19T08:15:33",
  "op": [
    "vote",
    {
      "voter": "ubg",
      "author": "slumber1122",
      "permlink": "nodejs",
      "weight": 100
    }
  ]
}

{
  "trx_id": "0ae2a283257cbadd9865ef9d5fedb4c7b8e86729",
  "block": 13814512,
  "trx_in_block": 3,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-07-19T08:14:33",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "send",
      "author": "slumber1122",
      "permlink": "nodejs",
      "title": "使用Nodejs部署智能合约",
      "body": "##使用nodejs部署智能合约\n\n实现智能合约的方式很多种，可以用truffle框架来实现，编译，部署。\n这里介绍一种简单的使用nodejs来实现，编译，部署的方法。\n创建一个nodejs项目，实现一个简单的智能合约。\n```\nmkdir sm && cd sm\nnpm init\nmkdir contracts && cd contracts\nvi BaseToken.sol\n\n//BaseToken.sol\ncontract Token{\n    address public owner;\n    mapping (address => uint) public balances;\n    event Sent(address from, address to, uint amount)\n    function Token(){\n        owner = msg.sender;\n        balances[owner] = 100000000;\n    }\n    function send(address receiver, uint amount){\n        if (balances[msg.sender] < amount) return;\n        balances[msg.sender] -= amount;\n        balances[receiver] += amount;\n        Sent(msg.sender, receiver, amount);\n    }\n}\n```\n这个合约实现了一个造币和转币的逻辑。\n我们的合约是运行在evm上面的字节码，solidity是静态语言，需要通过编译器生成evm的字节码。\n```\n\nvi compile.js\n\n// compile.js\nconst fs = require('fs')\nconst solc = require('solc')\n//编译合约\nlet source = fs.readFileSync(\"./contracts/BaseToken.sol\", 'utf8')\nconsole.log('compiling contract...');\nlet compiledContract = solc.compile(source);\nconsole.log('done');\n\nfor (let contractName in compiledContract.contracts) {\n    var bytecode = compiledContract.contracts[contractName].bytecode;\n    var abi = JSON.parse(compiledContract.contracts[contractName].interface);\n}\nconsole.log(bytecode)\n\n```\n调用`node compile.js`,对BaseToken进行编译，生成字节码。web3中提供了一个部署合约的接口，使用如下，\n```\nlet gasEstimate = web3.eth.estimateGas({data: '0x' + bytecode});\nconsole.log('gasEstimate: ' + gasEstimate)\n\n\nlet MyContract = web3.eth.contract(abi);\n\nconsole.log('deploying contract...');\n\n\nlet myContractReturned = MyContract.new([], {\n  from: address,\n  data: '0x' + bytecode,\n  gas: gasEstimate+50000\n}, function(err, myContract){\n  if(!err){\n    if(!myContract.address){\n      console.log(`myContract.transactionHash = ${myContract.transactionHash}`);\n    }else{\n      console.log(`myContract.address = ${myContract.address}`); // the contract address\n      global.contractAddress = myContract.address;\n    }\n}else{\n    console.log(err);\n}\n});\n```\n利用编译生成的abi和bytecode，创建一个合约对象，然后进行发布，等待着异步执行的方法输出合约地址`contractAddress`，这样就完成了部署。不过这种方式有一个问题，就是在发布合约时，你的私钥处于联网状态，\n处于安全策略，我们需要尽量避免私钥在联网状态。\n\n以太坊上部署合约是向空地址发送一个附有字节码的签名交易，其中发送者就是这个合约的拥有者。因此我们只需要将合约构建成一笔交易，我们在无网状态下对这笔交易进行签名，然后将签名发送到以太坊网络中。这样能够降低我们私钥被泄漏的风险。\n对合约的签名方法如下：\n```\nvar Tx = require('ethereumjs-tx')\nconst rawTx = {\n    nonce: '0x6', //这个是你的地址的交易次数+1，0开始\n    gasPrice: '0x12a05f200',\n    gasLimit: '0x493e0',\n    data: bytecode,\n    from: address,\n    to: \"\"\n};\nconst tx = new Tx(rawTx);\ntx.sign(privateKey);\nconst serializedTx = tx.serialize();\nconsole.log(serializedTx.toString('hex'))\n```\n以上对一个合约签名，这里需要注意的问题是，to的地址需要是，空地址。\n完成签名之后，我们把这笔交易发送出去就好，最简单的方法就是使用[etherscan的发送Tx的方式](https://etherscan.io/pushTx)，一旦发送完成，部署完成，就可以看到合约地址。",
      "json_metadata": "{\"tags\":[\"ico\",\"contract\",\"nodejs\",\"send\"],\"links\":[\"https://etherscan.io/pushTx\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "7ac8f85fca56c947a1f93ecc001f9fd26944c393",
  "block": 13814505,
  "trx_in_block": 11,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-07-19T08:14:12",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "send",
      "author": "slumber1122",
      "permlink": "nodejs",
      "title": "使用Nodejs部署智能合约",
      "body": "##使用nodejs部署智能合约\n\n实现智能合约的方式很多种，可以用truffle框架来实现，编译，部署。\n这里介绍一种简单的使用nodejs来实现，编译，部署的方法。\n创建一个nodejs项目，实现一个简单的智能合约。\n```\nmkdir sm && cd sm\nnpm init\nmkdir contracts && cd contracts\nvi BaseToken.sol\n\n//BaseToken.sol\ncontract Token{\n    address public owner;\n    mapping (address => uint) public balances;\n    event Sent(address from, address to, uint amount)\n    function Token(){\n        owner = msg.sender;\n        balances[owner] = 100000000;\n    }\n    function send(address receiver, uint amount){\n        if (balances[msg.sender] < amount) return;\n        balances[msg.sender] -= amount;\n        balances[receiver] += amount;\n        Sent(msg.sender, receiver, amount);\n    }\n}\n```\n这个合约实现了一个造币和转币的逻辑。\n我们的合约是运行在evm上面的字节码，solidity是静态语言，需要通过编译器生成evm的字节码。\n```\n\nvi compile.js\n\n// compile.js\nconst fs = require('fs')\nconst solc = require('solc')\n//编译合约\nlet source = fs.readFileSync(\"./contracts/BaseToken.sol\", 'utf8')\nconsole.log('compiling contract...');\nlet compiledContract = solc.compile(source);\nconsole.log('done');\n\nfor (let contractName in compiledContract.contracts) {\n    var bytecode = compiledContract.contracts[contractName].bytecode;\n    var abi = JSON.parse(compiledContract.contracts[contractName].interface);\n}\nconsole.log(bytecode)\n\n```\n调用`node compile.js`,对BaseToken进行编译，生成字节码。web3中提供了一个部署合约的接口，使用如下，\n```\nlet gasEstimate = web3.eth.estimateGas({data: '0x' + bytecode});\nconsole.log('gasEstimate: ' + gasEstimate)\n\n\nlet MyContract = web3.eth.contract(abi);\n\nconsole.log('deploying contract...');\n\n\nlet myContractReturned = MyContract.new([], {\n  from: address,\n  data: '0x' + bytecode,\n  gas: gasEstimate+50000\n}, function(err, myContract){\n  if(!err){\n    if(!myContract.address){\n      console.log(`myContract.transactionHash = ${myContract.transactionHash}`);\n    }else{\n      console.log(`myContract.address = ${myContract.address}`); // the contract address\n      global.contractAddress = myContract.address;\n    }\n}else{\n    console.log(err);\n}\n});\n```\n利用编译生成的abi和bytecode，创建一个合约对象，然后进行发布，等待着异步执行的方法输出合约地址`contractAddress`，这样就完成了部署。不过这种方式有一个问题，就是在发布合约时，你的私钥处于联网状态，\n处于安全策略，我们需要尽量避免私钥在联网状态。\n\n以太坊上部署合约是向空地址发送一个附有字节码的签名交易，其中发送者就是这个合约的拥有者。因此我们只需要将合约构建成一笔交易，我们在无网状态下对这笔交易进行签名，然后将签名发送到以太坊网络中。这样能够降低我们私钥被泄漏的风险。\n对合约的签名方法如下：\n```\nvar Tx = require('ethereumjs-tx')\nconst rawTx = {\n    nonce: '0x6', //这个是你的地址的交易次数+1，0开始\n    gasPrice: '0x12a05f200',\n    gasLimit: '0x493e0',\n    data: bytecode,\n    from: address,\n    to: \"\"\n};\nconst tx = new Tx(rawTx);\ntx.sign(privateKey);\nconst serializedTx = tx.serialize();\nconsole.log(serializedTx.toString('hex'))\n```\n以上对一个合约签名，这里需要注意的问题是，to的地址需要是，空地址。\n完成签名之后，我们把这笔交易发送出去就好，最简单的方法就是使用[etherscan的发送Tx的方式](https://etherscan.io/pushTx)，一旦发送完成，部署完成，就可以看到合约地址。",
      "json_metadata": "{\"tags\":[\"ico\",\"contract\",\"nodejs\",\"send\"],\"links\":[\"https://etherscan.io/pushTx\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "782df5b7a4f48777093ba07b5ab9b6264ab2238c",
  "block": 13785304,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-07-18T07:53:42",
  "op": [
    "comment",
    {
      "parent_author": "slumber1122",
      "parent_permlink": "nodejs",
      "author": "abumuhammad",
      "permlink": "re-slumber1122-nodejs-20170718t075340325z",
      "title": "",
      "body": "![STEEMIT.png](https://steemitimages.com/DQmXdVYzuqXjxi4665HD723Aw5FpJvHwsjf6oEh5jguA6sH/STEEMIT.png)",
      "json_metadata": "{\"tags\":[\"send\"],\"image\":[\"https://steemitimages.com/DQmXdVYzuqXjxi4665HD723Aw5FpJvHwsjf6oEh5jguA6sH/STEEMIT.png\"],\"app\":\"steemit/0.1\"}"
    }
  ]
}

{
  "trx_id": "887fe1ec0acabebe966af67db93cff53da7bd2a8",
  "block": 13784808,
  "trx_in_block": 14,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-07-18T07:28:54",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "send",
      "author": "slumber1122",
      "permlink": "nodejs",
      "title": "使用Nodejs部署智能合约",
      "body": "##使用nodejs部署智能合约\n\n实现智能合约的方式很多种，可以用truffle框架来实现，编译，部署。\n这里介绍一种简单的使用nodejs来实现，编译，部署的方法。\n创建一个nodejs项目，实现一个简单的智能合约。\n```\nmkdir sm && cd sm\nnpm init\nmkdir contracts && cd contracts\nvi BaseToken.sol\n\n//BaseToken.sol\ncontract Token{\n    address public owner;\n    mapping (address => uint) public balances;\n    event Sent(address from, address to, uint amount)\n    function Token(){\n        owner = msg.sender;\n        balances[owner] = 100000000;\n    }\n    function send(address receiver, uint amount){\n        if (balances[msg.sender] < amount) return;\n        balances[msg.sender] -= amount;\n        balances[receiver] += amount;\n        Sent(msg.sender, receiver, amount);\n    }\n}\n```\n这个合约实现了一个造币和转币的逻辑。\n我们的合约是运行在evm上面的字节码，solidity是静态语言，需要通过编译器生成evm的字节码。\n```\n\nvi compile.js\n\n// compile.js\nconst fs = require('fs')\nconst solc = require('solc')\n//编译合约\nlet source = fs.readFileSync(\"./contracts/BaseToken.sol\", 'utf8')\nconsole.log('compiling contract...');\nlet compiledContract = solc.compile(source);\nconsole.log('done');\n\nfor (let contractName in compiledContract.contracts) {\n    var bytecode = compiledContract.contracts[contractName].bytecode;\n    var abi = JSON.parse(compiledContract.contracts[contractName].interface);\n}\nconsole.log(bytecode)\n\n```\n调用`node compile.js`,对BaseToken进行编译，生成字节码。web3中提供了一个部署合约的接口，使用如下，\n```\nlet gasEstimate = web3.eth.estimateGas({data: '0x' + bytecode});\nconsole.log('gasEstimate: ' + gasEstimate)\n\n\nlet MyContract = web3.eth.contract(abi);\n\nconsole.log('deploying contract...');\n\n\nlet myContractReturned = MyContract.new([], {\n  from: address,\n  data: '0x' + bytecode,\n  gas: gasEstimate+50000\n}, function(err, myContract){\n  if(!err){\n    if(!myContract.address){\n      console.log(`myContract.transactionHash = ${myContract.transactionHash}`);\n    }else{\n      console.log(`myContract.address = ${myContract.address}`); // the contract address\n      global.contractAddress = myContract.address;\n    }\n}else{\n    console.log(err);\n}\n});\n```\n利用编译生成的abi和bytecode，创建一个合约对象，然后进行发布，等待着异步执行的方法输出合约地址`contractAddress`，这样就完成了部署。不过这种方式有一个问题，就是在发布合约时，你的私钥处于联网状态，\n处于安全策略，我们需要尽量避免私钥在联网状态。\n\n以太坊上部署合约是向空地址发送一个附有字节码的签名交易，其中发送者就是这个合约的拥有者。因此我们只需要将合约构建成一笔交易，我们在无网状态下对这笔交易进行签名，然后将签名发送到以太坊网络中。这样能够降低我们私钥被泄漏的风险。\n对合约的签名方法如下：\n```\nvar Tx = require('ethereumjs-tx')\nconst rawTx = {\n    nonce: '0x6', //这个是你的地址的交易次数+1，0开始\n    gasPrice: '0x12a05f200',\n    gasLimit: '0x493e0',\n    data: bytecode,\n    from: address,\n    to: \"\"\n};\nconst tx = new Tx(rawTx);\ntx.sign(privateKey);\nconst serializedTx = tx.serialize();\nconsole.log(serializedTx.toString('hex'))\n```\n以上对一个合约签名，这里需要注意的问题是，to的地址需要是，空地址。\n完成签名之后，我们把这笔交易发送出去就好，最简单的方法就是使用[etherscan的发送Tx的方式](https://etherscan.io/pushTx)，一旦发送完成，部署完成，就可以看到合约地址。",
      "json_metadata": "{\"tags\":[\"ico\",\"contract\",\"nodejs\",\"send\"],\"links\":[\"https://etherscan.io/pushTx\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "92866c886e5e1cb7f6cda2ad5e3a21c20d2b5cb1",
  "block": 13784798,
  "trx_in_block": 11,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-07-18T07:28:24",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "send",
      "author": "slumber1122",
      "permlink": "nodejs",
      "title": "使用Nodejs部署智能合约",
      "body": "##使用nodejs部署智能合约\n\n实现智能合约的方式很多种，可以用truffle框架来实现，编译，部署。\n这里介绍一种简单的使用nodejs来实现，编译，部署的方法。\n创建一个nodejs项目，实现一个简单的智能合约。\n```\nmkdir sm && cd sm\nnpm init\nmkdir contracts && cd contracts\nvi BaseToken.sol\n\n//BaseToken.sol\ncontract Token{\n    address public owner;\n    mapping (address => uint) public balances;\n    event Sent(address from, address to, uint amount)\n    function Token(){\n        owner = msg.sender;\n        balances[owner] = 100000000;\n    }\n    function send(address receiver, uint amount){\n        if (balances[msg.sender] < amount) return;\n        balances[msg.sender] -= amount;\n        balances[receiver] += amount;\n        Sent(msg.sender, receiver, amount);\n    }\n}\n```\n这个合约实现了一个造币和转币的逻辑。\n我们的合约是运行在evm上面的字节码，solidity是静态语言，需要通过编译器生成evm的字节码。\n```\n\nvi compile.js\n\n// compile.js\nconst fs = require('fs')\nconst solc = require('solc')\n//编译合约\nlet source = fs.readFileSync(\"./contracts/BaseToken.sol\", 'utf8')\nconsole.log('compiling contract...');\nlet compiledContract = solc.compile(source);\nconsole.log('done');\n\nfor (let contractName in compiledContract.contracts) {\n    var bytecode = compiledContract.contracts[contractName].bytecode;\n    var abi = JSON.parse(compiledContract.contracts[contractName].interface);\n}\nconsole.log(bytecode)\n\n```\n调用`node compile.js`,对BaseToken进行编译，生成字节码。web3中提供了一个部署合约的接口，使用如下，\n```\nlet gasEstimate = web3.eth.estimateGas({data: '0x' + bytecode});\nconsole.log('gasEstimate: ' + gasEstimate)\n\n\nlet MyContract = web3.eth.contract(abi);\n\nconsole.log('deploying contract...');\n\n\nlet myContractReturned = MyContract.new([], {\n  from: address,\n  data: '0x' + bytecode,\n  gas: gasEstimate+50000\n}, function(err, myContract){\n  if(!err){\n    if(!myContract.address){\n      console.log(`myContract.transactionHash = ${myContract.transactionHash}`);\n    }else{\n      console.log(`myContract.address = ${myContract.address}`); // the contract address\n      global.contractAddress = myContract.address;\n    }\n}else{\n    console.log(err);\n}\n});\n```\n利用编译生成的abi和bytecode，创建一个合约对象，然后进行发布，等待着异步执行的方法输出合约地址`contractAddress`，这样就完成了部署。不过这种方式有一个问题，就是在发布合约时，你的私钥处于联网状态，\n处于安全策略，我们需要尽量避免私钥在联网状态。\n\n以太坊上部署合约是向空地址发送一个附有字节码的签名交易，其中发送者就是这个合约的拥有者。因此我们只需要将合约构建成一笔交易，我们在无网状态下对这笔交易进行签名，然后将签名发送到以太坊网络中。这样能够降低我们私钥被泄漏的风险。\n对合约的签名方法如下：\n```\nvar Tx = require('ethereumjs-tx')\nconst rawTx = {\n    nonce: '0x6', //这个是你的地址的交易次数+1，0开始\n    gasPrice: '0x12a05f200',\n    gasLimit: '0x493e0',\n    data: bytecode,\n    from: address,\n    to: \"\"\n};\nconst tx = new Tx(rawTx);\ntx.sign(privateKey);\nconst serializedTx = tx.serialize();\nconsole.log(serializedTx.toString('hex'))\n```\n以上对一个合约签名，这里需要注意的问题是，to的地址需要是，空地址。\n完成签名之后，我们把这笔交易发送出去就好，最简单的方法就是使用[etherscan的发送Tx的方式](https://etherscan.io/pushTx)，一旦发送完成，部署完成，就可以看到合约地址。",
      "json_metadata": "{\"tags\":[\"contract\",\"send\"],\"links\":[\"https://etherscan.io/pushTx\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "490d557ac1445697f230cf11fe9492bc630ee158",
  "block": 13782447,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-07-18T05:30:48",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "send",
      "author": "slumber1122",
      "permlink": "nodejs",
      "title": "使用Nodejs部署智能合约",
      "body": "##使用nodejs部署智能合约\n\n实现智能合约的方式很多种，可以用truffle框架来实现，编译，部署。\n这里介绍一种简单的使用nodejs来实现，编译，部署的方法。\n创建一个nodejs项目，实现一个简单的智能合约。\n```\nmkdir sm && cd sm\nnpm init\nmkdir contracts && cd contracts\nvi BaseToken.sol\n\n//BaseToken.sol\ncontract Token{\n    address public owner;\n    mapping (address => uint) public balances;\n    event Sent(address from, address to, uint amount)\n    function Token(){\n        owner = msg.sender;\n        balances[owner] = 100000000;\n    }\n    function send(address receiver, uint amount){\n        if (balances[msg.sender] < amount) return;\n        balances[msg.sender] -= amount;\n        balances[receiver] += amount;\n        Sent(msg.sender, receiver, amount);\n    }\n}\n```\n这个合约实现了一个造币和转币的逻辑。\n我们的合约是运行在evm上面的字节码，solidity是静态语言，需要通过编译器生成evm的字节码。\n```\n\nvi compile.js\n\n// compile.js\nconst fs = require('fs')\nconst solc = require('solc')\n//编译合约\nlet source = fs.readFileSync(\"./contracts/BaseToken.sol\", 'utf8')\nconsole.log('compiling contract...');\nlet compiledContract = solc.compile(source);\nconsole.log('done');\n\nfor (let contractName in compiledContract.contracts) {\n    var bytecode = compiledContract.contracts[contractName].bytecode;\n    var abi = JSON.parse(compiledContract.contracts[contractName].interface);\n}\nconsole.log(bytecode)\n\n```\n调用`node compile.js`,对BaseToken进行编译，生成字节码。web3中提供了一个部署合约的接口，使用如下，\n```\nlet gasEstimate = web3.eth.estimateGas({data: '0x' + bytecode});\nconsole.log('gasEstimate: ' + gasEstimate)\n\n\nlet MyContract = web3.eth.contract(abi);\n\nconsole.log('deploying contract...');\n\n\nlet myContractReturned = MyContract.new([], {\n  from: address,\n  data: '0x' + bytecode,\n  gas: gasEstimate+50000\n}, function(err, myContract){\n  if(!err){\n    if(!myContract.address){\n      console.log(`myContract.transactionHash = ${myContract.transactionHash}`);\n    }else{\n      console.log(`myContract.address = ${myContract.address}`); // the contract address\n      global.contractAddress = myContract.address;\n    }\n}else{\n    console.log(err);\n}\n});\n```\n利用编译生成的abi和bytecode，创建一个合约对象，然后进行发布，等待着异步执行的方法输出合约地址`contractAddress`，这样就完成了部署。不过这种方式有一个问题，就是在发布合约时，你的私钥处于联网状态，\n处于安全策略，我们需要尽量避免私钥在联网状态。\n\n以太坊上部署合约是向空地址发送一个附有字节码的签名交易，其中发送者就是这个合约的拥有者。因此我们只需要将合约构建成一笔交易，我们在无网状态下对这笔交易进行签名，然后将签名发送到以太坊网络中。这样能够降低我们私钥被泄漏的风险。\n对合约的签名方法如下：\n```\nvar Tx = require('ethereumjs-tx')\nconst rawTx = {\n    nonce: '0x6', //这个是你的地址的交易次数+1，0开始\n    gasPrice: '0x12a05f200',\n    gasLimit: '0x493e0',\n    data: bytecode,\n    from: address,\n    to: \"\"\n};\nconst tx = new Tx(rawTx);\ntx.sign(privateKey);\nconst serializedTx = tx.serialize();\nconsole.log(serializedTx.toString('hex'))\n```\n以上对一个合约签名，这里需要注意的问题是，to的地址需要是，空地址。\n完成签名之后，我们把这笔交易发送出去就好，最简单的方法就是使用[etherscan的发送Tx的方式](https://etherscan.io/pushTx)，一旦发送完成，部署完成，就可以看到合约地址。",
      "json_metadata": "{\"tags\":[\"send\",\"offline\"],\"links\":[\"https://etherscan.io/pushTx\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "a4c4b39557fa5df2700b3e3740af7ba78a6b3b56",
  "block": 13217538,
  "trx_in_block": 15,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-28T13:56:15",
  "op": [
    "account_update",
    {
      "account": "slumber1122",
      "memo_key": "STM8AxZU8ygFFWR25CCYWP5kidhMvax4doZjCwy4EHmjHsB6XEPcj",
      "json_metadata": "{\"profile\":{\"name\":\"slumber1122\",\"about\":\"programer\",\"location\":\"nanjing\",\"website\":\"https://github.com/slumber1122\",\"profile_image\":\"http://pic.baike.soso.com/ugc/baikepic2/23868/cut-20140815161513-1150723709.jpg/0\"}}"
    }
  ]
}

{
  "trx_id": "c1c1c1cad7a42563e9ea7976f6d237e791abc7cd",
  "block": 13217517,
  "trx_in_block": 31,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-28T13:55:12",
  "op": [
    "account_update",
    {
      "account": "slumber1122",
      "memo_key": "STM8AxZU8ygFFWR25CCYWP5kidhMvax4doZjCwy4EHmjHsB6XEPcj",
      "json_metadata": "{\"profile\":{\"name\":\"wade\",\"about\":\"programer\",\"location\":\"nanjing\",\"website\":\"https://github.com/slumber1122\"}}"
    }
  ]
}

{
  "trx_id": "b0ddc3b791e868307442a9d712549a72ef4d6e3e",
  "block": 13217419,
  "trx_in_block": 27,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-28T13:50:00",
  "op": [
    "comment",
    {
      "parent_author": "tooooolong",
      "parent_permlink": "eoscrowdsale-contract-inspect",
      "author": "slumber1122",
      "permlink": "re-tooooolong-eoscrowdsale-contract-inspect-20170628t135011447z",
      "title": "",
      "body": "写的太好了，认真看了两遍，学到很多，谢谢博主！",
      "json_metadata": "{\"tags\":[\"eos\"],\"app\":\"steemit/0.1\"}"
    }
  ]
}

{
  "trx_id": "f7d932294a5f4a6fd3c9799b0163e95013ecb72a",
  "block": 13065040,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-23T06:36:39",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "slumber1122"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"slumber1122\",\"following\":\"trafalgar\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "123e05473f95d73e0a9a3f56db2a2d665129fea7",
  "block": 13065023,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-23T06:35:48",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "slumber1122"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"slumber1122\",\"following\":\"pressfortruth\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "250cab68678d8f2f2012ba91e53542afbd84fd2b",
  "block": 13036935,
  "trx_in_block": 24,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-22T07:10:45",
  "op": [
    "vote",
    {
      "voter": "slumber1122",
      "author": "oflyhigh",
      "permlink": "19-informal-translation-hf19-equality-coming-soon-linear-rewards",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "d6332c96be56ee53a3ed01ce24395a4d9679f8e8",
  "block": 13036932,
  "trx_in_block": 28,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-22T07:10:36",
  "op": [
    "vote",
    {
      "voter": "slumber1122",
      "author": "oflyhigh",
      "permlink": "19-informal-translation-hf19-equality-coming-soon-linear-rewards",
      "weight": 0
    }
  ]
}

{
  "trx_id": "de1573f2df4bebe7dc42063b96a5616144bff873",
  "block": 13036930,
  "trx_in_block": 17,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-22T07:10:30",
  "op": [
    "vote",
    {
      "voter": "slumber1122",
      "author": "oflyhigh",
      "permlink": "19-informal-translation-hf19-equality-coming-soon-linear-rewards",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "4f081e7452cec03b3f7b5f80f249c9efb06bc025",
  "block": 13036529,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-22T06:50:24",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "slumber1122"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"slumber1122\",\"following\":\"tooooolong\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "a7470e40944ff7b171ccbf57ba76e7a16cfe16ab",
  "block": 12801584,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-06-14T02:41:18",
  "op": [
    "account_create_with_delegation",
    {
      "fee": "0.500 STEEM",
      "delegation": "57000.000000 VESTS",
      "creator": "steem",
      "new_account_name": "slumber1122",
      "owner": {
        "weight_threshold": 1,
        "account_auths": [],
        "key_auths": [
          [
            "STM8hRQ89vGSSpP2aJk2D18nwimxQ6xmPptpdZKupzE43tJk1Ubqw",
            1
          ]
        ]
      },
      "active": {
        "weight_threshold": 1,
        "account_auths": [],
        "key_auths": [
          [
            "STM6eAeK81s42UNmK8EjrpLfMBmzqAEBnietLAtWnRcTUeMRrPtkS",
            1
          ]
        ]
      },
      "posting": {
        "weight_threshold": 1,
        "account_auths": [],
        "key_auths": [
          [
            "STM75gw8keSQojqvN8i1gLx1rg3ZqUsDfhw29mxUE1NHh9stM2wZ6",
            1
          ]
        ]
      },
      "memo_key": "STM8AxZU8ygFFWR25CCYWP5kidhMvax4doZjCwy4EHmjHsB6XEPcj",
      "json_metadata": "",
      "extensions": []
    }
  ]
}