dequanto 0.0.1 → 0.0.7

package/src/evm/opcodes.ts

@@ -0,0 +1,207 @@
+const CODES = {
+  // 0x0 range - arithmetic ops
+  // name, baseCost, off stack, on stack, dynamic, async
+  0x00: ['STOP', 0, 0, 0, false],
+  0x01: ['ADD', 3, 2, 1, false],
+  0x02: ['MUL', 5, 2, 1, false],
+  0x03: ['SUB', 3, 2, 1, false],
+  0x04: ['DIV', 5, 2, 1, false],
+  0x05: ['SDIV', 5, 2, 1, false],
+  0x06: ['MOD', 5, 2, 1, false],
+  0x07: ['SMOD', 5, 2, 1, false],
+  0x08: ['ADDMOD', 8, 3, 1, false],
+  0x09: ['MULMOD', 8, 3, 1, false],
+  0x0a: ['EXP', 10, 2, 1, false],
+  0x0b: ['SIGNEXTEND', 5, 2, 1, false],
+
+  // 0x10 range - bit ops
+  0x10: ['LT', 3, 2, 1, false],
+  0x11: ['GT', 3, 2, 1, false],
+  0x12: ['SLT', 3, 2, 1, false],
+  0x13: ['SGT', 3, 2, 1, false],
+  0x14: ['EQ', 3, 2, 1, false],
+  0x15: ['ISZERO', 3, 1, 1, false],
+  0x16: ['AND', 3, 2, 1, false],
+  0x17: ['OR', 3, 2, 1, false],
+  0x18: ['XOR', 3, 2, 1, false],
+  0x19: ['NOT', 3, 1, 1, false],
+  0x1a: ['BYTE', 3, 2, 1, false],
+  0x1b: ['SHL', 3, 2, 1, false],
+  0x1c: ['SHR', 3, 2, 1, false],
+  0x1d: ['SAR', 3, 2, 1, false],
+
+  // 0x20 range - crypto
+  0x20: ['SHA3', 30, 2, 1, false],
+
+  // 0x30 range - closure state
+  0x30: ['ADDRESS', 2, 0, 1, true],
+  0x31: ['BALANCE', 400, 1, 1, true, true],
+  0x32: ['ORIGIN', 2, 0, 1, true],
+  0x33: ['CALLER', 2, 0, 1, true],
+  0x34: ['CALLVALUE', 2, 0, 1, true],
+  0x35: ['CALLDATALOAD', 3, 1, 1, true],
+  0x36: ['CALLDATASIZE', 2, 0, 1, true],
+  0x37: ['CALLDATACOPY', 3, 3, 0, true],
+  0x38: ['CODESIZE', 2, 0, 1, false],
+  0x39: ['CODECOPY', 3, 3, 0, false],
+  0x3a: ['GASPRICE', 2, 0, 1, false],
+  0x3b: ['EXTCODESIZE', 700, 1, 1, true, true],
+  0x3c: ['EXTCODECOPY', 700, 4, 0, true, true],
+  0x3d: ['RETURNDATASIZE', 2, 0, 1, true],
+  0x3e: ['RETURNDATACOPY', 3, 3, 0, true],
+  0x3f: ['EXTCODEHASH', 400, 1, 1, true, true],
+
+  // '0x40' range - block operations
+  0x40: ['BLOCKHASH', 20, 1, 1, true, true],
+  0x41: ['COINBASE', 2, 0, 1, true],
+  0x42: ['TIMESTAMP', 2, 0, 1, true],
+  0x43: ['NUMBER', 2, 0, 1, true],
+  0x44: ['DIFFICULTY', 2, 0, 1, true],
+  0x45: ['GASLIMIT', 2, 0, 1, true],
+
+  // 0x50 range - 'storage' and execution
+  0x50: ['POP', 2, 1, 0, false],
+  0x51: ['MLOAD', 3, 1, 1, false],
+  0x52: ['MSTORE', 3, 2, 0, false],
+  0x53: ['MSTORE8', 3, 2, 0, false],
+  0x54: ['SLOAD', 200, 1, 1, true, true],
+  0x55: ['SSTORE', 0, 2, 0, true, true],
+  0x56: ['JUMP', 8, 1, 0, false],
+  0x57: ['JUMPI', 10, 2, 0, false],
+  0x58: ['PC', 2, 0, 1, false],
+  0x59: ['MSIZE', 2, 0, 1, false],
+  0x5a: ['GAS', 2, 0, 1, false],
+  0x5b: ['JUMPDEST', 1, 0, 0, false],
+
+  // 0x60, range
+  0x60: ['PUSH', 3, 0, 1, false],
+  0x61: ['PUSH', 3, 0, 1, false],
+  0x62: ['PUSH', 3, 0, 1, false],
+  0x63: ['PUSH', 3, 0, 1, false],
+  0x64: ['PUSH', 3, 0, 1, false],
+  0x65: ['PUSH', 3, 0, 1, false],
+  0x66: ['PUSH', 3, 0, 1, false],
+  0x67: ['PUSH', 3, 0, 1, false],
+  0x68: ['PUSH', 3, 0, 1, false],
+  0x69: ['PUSH', 3, 0, 1, false],
+  0x6a: ['PUSH', 3, 0, 1, false],
+  0x6b: ['PUSH', 3, 0, 1, false],
+  0x6c: ['PUSH', 3, 0, 1, false],
+  0x6d: ['PUSH', 3, 0, 1, false],
+  0x6e: ['PUSH', 3, 0, 1, false],
+  0x6f: ['PUSH', 3, 0, 1, false],
+  0x70: ['PUSH', 3, 0, 1, false],
+  0x71: ['PUSH', 3, 0, 1, false],
+  0x72: ['PUSH', 3, 0, 1, false],
+  0x73: ['PUSH', 3, 0, 1, false],
+  0x74: ['PUSH', 3, 0, 1, false],
+  0x75: ['PUSH', 3, 0, 1, false],
+  0x76: ['PUSH', 3, 0, 1, false],
+  0x77: ['PUSH', 3, 0, 1, false],
+  0x78: ['PUSH', 3, 0, 1, false],
+  0x79: ['PUSH', 3, 0, 1, false],
+  0x7a: ['PUSH', 3, 0, 1, false],
+  0x7b: ['PUSH', 3, 0, 1, false],
+  0x7c: ['PUSH', 3, 0, 1, false],
+  0x7d: ['PUSH', 3, 0, 1, false],
+  0x7e: ['PUSH', 3, 0, 1, false],
+  0x7f: ['PUSH', 3, 0, 1, false],
+
+  0x80: ['DUP', 3, 0, 1, false],
+  0x81: ['DUP', 3, 0, 1, false],
+  0x82: ['DUP', 3, 0, 1, false],
+  0x83: ['DUP', 3, 0, 1, false],
+  0x84: ['DUP', 3, 0, 1, false],
+  0x85: ['DUP', 3, 0, 1, false],
+  0x86: ['DUP', 3, 0, 1, false],
+  0x87: ['DUP', 3, 0, 1, false],
+  0x88: ['DUP', 3, 0, 1, false],
+  0x89: ['DUP', 3, 0, 1, false],
+  0x8a: ['DUP', 3, 0, 1, false],
+  0x8b: ['DUP', 3, 0, 1, false],
+  0x8c: ['DUP', 3, 0, 1, false],
+  0x8d: ['DUP', 3, 0, 1, false],
+  0x8e: ['DUP', 3, 0, 1, false],
+  0x8f: ['DUP', 3, 0, 1, false],
+
+  0x90: ['SWAP', 3, 0, 0, false],
+  0x91: ['SWAP', 3, 0, 0, false],
+  0x92: ['SWAP', 3, 0, 0, false],
+  0x93: ['SWAP', 3, 0, 0, false],
+  0x94: ['SWAP', 3, 0, 0, false],
+  0x95: ['SWAP', 3, 0, 0, false],
+  0x96: ['SWAP', 3, 0, 0, false],
+  0x97: ['SWAP', 3, 0, 0, false],
+  0x98: ['SWAP', 3, 0, 0, false],
+  0x99: ['SWAP', 3, 0, 0, false],
+  0x9a: ['SWAP', 3, 0, 0, false],
+  0x9b: ['SWAP', 3, 0, 0, false],
+  0x9c: ['SWAP', 3, 0, 0, false],
+  0x9d: ['SWAP', 3, 0, 0, false],
+  0x9e: ['SWAP', 3, 0, 0, false],
+  0x9f: ['SWAP', 3, 0, 0, false],
+
+  0xa0: ['LOG', 375, 2, 0, false],
+  0xa1: ['LOG', 375, 3, 0, false],
+  0xa2: ['LOG', 375, 4, 0, false],
+  0xa3: ['LOG', 375, 5, 0, false],
+  0xa4: ['LOG', 375, 6, 0, false],
+
+  // '0xf0' range - closures
+  0xf0: ['CREATE', 32000, 3, 1, true, true],
+  0xf1: ['CALL', 700, 7, 1, true, true],
+  0xf2: ['CALLCODE', 700, 7, 1, true, true],
+  0xf3: ['RETURN', 0, 2, 0, false],
+  0xf4: ['DELEGATECALL', 700, 6, 1, true, true],
+  0xf5: ['CREATE2', 32000, 4, 1, true, true],
+  0xfa: ['STATICCALL', 700, 6, 1, true, true],
+  0xfd: ['REVERT', 0, 2, 0, false],
+
+  // '0x70', range - other
+  0xfe: ['INVALID', 0, 0, 0, false],
+  0xff: ['SELFDESTRUCT', 5000, 1, 0, false, true]
+};
+
+export function findOpcode(op, full, freeLogs?) {
+  var code = CODES[op] ? CODES[op] : ['INVALID', 0, 0, 0, false, false];
+  var opcode = code[0];
+
+  if (full) {
+    if (opcode === 'LOG') {
+      opcode += op - 0xa0;
+    }
+
+    if (opcode === 'PUSH') {
+      opcode += op - 0x5f;
+    }
+
+    if (opcode === 'DUP') {
+      opcode += op - 0x7f;
+    }
+
+    if (opcode === 'SWAP') {
+      opcode += op - 0x8f;
+    }
+  }
+
+  var fee = code[1];
+
+  if (freeLogs) {
+    if (opcode === 'LOG') {
+      fee = 0;
+    }
+  }
+
+  return {
+    name: opcode,
+    opcode: op,
+    fee: fee,
+    in: code[2],
+    out: code[3],
+    dynamic: code[4],
+    async: code[5],
+
+    pc: null,
+    pushData: null,
+  };
+};

package/src/evm/tx.class.ts

@@ -0,0 +1,137 @@
+import * as BigNumber from '../../node_modules/big-integer';
+import * as functionHashes from '../../data/functionHashes.json';
+
+const parseSingle = (data: any, type: any) => {
+    if (type === 'string') {
+        return '"' + Buffer.from(data, 'hex').toString('utf8') + '"';
+    } else if (type === 'address') {
+        return '0x' + data.substring(24);
+    } else if (type === 'uint256' || type === 'uint8') {
+        return BigNumber(data, 16).toString();
+    } else if (type === 'bool') {
+        return (!BigNumber(data, 16).isZero()).toString();
+    } else {
+        return data;
+    }
+};
+
+export default class Transaction {
+    blockHash?: string;
+    blockNumber?: number;
+    from?: string;
+    gas?: number;
+    gasPrice?: number;
+    input?: string;
+    to?: string;
+    value?: number;
+
+    constructor(transactionObject?: any) {
+        if (transactionObject) {
+            if ('blockHash' in transactionObject) {
+                this.blockHash = transactionObject.blockHash;
+            }
+            if ('blockNumber' in transactionObject) {
+                this.blockNumber = transactionObject.blockNumber;
+            }
+            if ('from' in transactionObject) {
+                this.from = transactionObject.from;
+            }
+            if ('gas' in transactionObject) {
+                this.gas = transactionObject.gas;
+            }
+            if ('gasPrice' in transactionObject) {
+                this.gasPrice = transactionObject.gasPrice;
+            }
+            if ('input' in transactionObject) {
+                this.input = transactionObject.input.replace('0x', '');
+            }
+            if ('to' in transactionObject) {
+                this.to = transactionObject.to;
+            }
+            if ('value' in transactionObject) {
+                this.value = transactionObject.value;
+            }
+        }
+    }
+
+    setInput(input: string): void {
+        this.input = input.replace('0x', '');
+    }
+
+    getFunctionHash(): string | false {
+        if (this.input && this.input.length >= 8) {
+            return this.input.substr(0, 8);
+        } else {
+            return false;
+        }
+    }
+
+    getFunction(): string | false {
+        const functionHash = this.getFunctionHash();
+        if (functionHash && functionHash in functionHashes) {
+            return (functionHashes as any)[functionHash];
+        } else {
+            return false;
+        }
+    }
+
+    getFunctionName(): string | false {
+        const rawFunction = this.getFunction();
+        if (rawFunction) {
+            return rawFunction.split('(')[0];
+        } else {
+            return false;
+        }
+    }
+
+    getRawArguments(): string[] {
+        if (this.input && this.input.length >= 70) {
+            return this.input.substr(8).match(/.{1,64}/g)!;
+        } else {
+            return [];
+        }
+    }
+
+    getArguments(descriptive: boolean = true): string[] {
+        const functionName = this.getFunction();
+        const functionArguments = this.getRawArguments();
+        if (functionName && this.input) {
+            const rawFunctionArguments = functionName
+                .split('(')[1]
+                .slice(0, -1)
+                .split(',');
+            if (
+                rawFunctionArguments.length === 1 &&
+                rawFunctionArguments[0] === '' &&
+                functionArguments.length === 0
+            ) {
+                return [];
+            } else {
+                const result: string[] = [];
+                for (let i = 0; i < rawFunctionArguments.length; i++) {
+                    const functionArgumentType = rawFunctionArguments[i] || 'unknown';
+                    const functionArgument = functionArguments[i];
+                    if (functionArgumentType === 'string') {
+                        const location = BigNumber(functionArgument, 16)
+                            .divide(32)
+                            .toJSNumber();
+                        const length = BigNumber(functionArguments[location], 16)
+                            .multiply(2)
+                            .toJSNumber();
+                        const data = this.input.substring(8).substr((location + 1) * 64, length);
+                        result.push(parseSingle(data, functionArgumentType));
+                    } else {
+                        result.push(parseSingle(functionArgument, functionArgumentType));
+                    }
+                }
+                return result;
+            }
+        } else {
+            return functionArguments;
+        }
+    }
+
+    isContractCreation(): boolean {
+        return this.to === null;
+    }
+}

package/src/evm/utils/BigNumber.ts

@@ -0,0 +1,9 @@
+export namespace BigNumber {
+    export function isInstance (mix): mix is bigint {
+        return typeof mix === 'bigint';
+    }
+
+    export function isZero (mix: bigint) {
+        return mix === 0n;
+    }
+}

package/src/evm/utils/hex.ts

@@ -0,0 +1,37 @@
+export function hex2a(hexx: any) {
+    const hex = hexx.toString();
+    let str = '';
+    for (let i = 0; i < hex.length && hex.substr(i, 2) !== '00'; i += 2) {
+        str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+    }
+    return str;
+}
+
+export function pad32(data: string) {
+    if (data.length >= 64) {
+        return data;
+    } else {
+        return '0'.repeat(64 - data.length) + data;
+    }
+}
+
+export function isHex(h: any) {
+    return /^[0-9a-f-]+$/.test(h);
+}
+
+export default (data: any) => {
+    if (isHex(data)) {
+        const pieces = data.match(/.{1,64}/g);
+        if (pieces.length === 3 && parseInt(pieces[0], 16) === 32) {
+            const stringLength = parseInt(pieces[1], 16) * 2;
+            const stringData = hex2a(pieces[2].substr(0, stringLength));
+            return '"' + stringData + '"';
+        } else if (!isNaN(parseInt(data, 16))) {
+            return parseInt(data, 16).toString();
+        } else {
+            return data;
+        }
+    } else {
+        return data;
+    }
+};

package/src/evm/utils/opcodes.ts

@@ -0,0 +1,213 @@
+import STOP from '../opcodes/stop';
+import ADD from '../opcodes/add';
+import MUL from '../opcodes/mul';
+import SUB from '../opcodes/sub';
+import DIV from '../opcodes/div';
+import MOD from '../opcodes/mod';
+import ADDMOD from '../opcodes/addmod';
+import MULMOD from '../opcodes/mulmod';
+import EXP from '../opcodes/exp';
+import SIGNEXTEND from '../opcodes/signextend';
+import LT from '../opcodes/lt';
+import GT from '../opcodes/gt';
+import EQ from '../opcodes/eq';
+import ISZERO from '../opcodes/iszero';
+import AND from '../opcodes/and';
+import OR from '../opcodes/or';
+import XOR from '../opcodes/xor';
+import NOT from '../opcodes/not';
+import BYTE from '../opcodes/byte';
+import SHL from '../opcodes/shl';
+import SHR from '../opcodes/shr';
+import SAR from '../opcodes/sar';
+import SHA3 from '../opcodes/sha3';
+import ADDRESS from '../opcodes/address';
+import BALANCE from '../opcodes/balance';
+import ORIGIN from '../opcodes/origin';
+import CALLER from '../opcodes/caller';
+import CALLVALUE from '../opcodes/callvalue';
+import CALLDATALOAD from '../opcodes/calldataload';
+import CALLDATASIZE from '../opcodes/calldatasize';
+import CALLDATACOPY from '../opcodes/calldatacopy';
+import CODESIZE from '../opcodes/codesize';
+import CODECOPY from '../opcodes/codecopy';
+import GASPRICE from '../opcodes/gasprice';
+import EXTCODESIZE from '../opcodes/extcodesize';
+import EXTCODECOPY from '../opcodes/extcodecopy';
+import RETURNDATASIZE from '../opcodes/returndatasize';
+import RETURNDATACOPY from '../opcodes/returndatacopy';
+import EXTCODEHASH from '../opcodes/extcodehash';
+import BLOCKHASH from '../opcodes/blockhash';
+import COINBASE from '../opcodes/coinbase';
+import TIMESTAMP from '../opcodes/timestamp';
+import NUMBER from '../opcodes/number';
+import DIFFICULTY from '../opcodes/difficulty';
+import GASLIMIT from '../opcodes/gaslimit';
+import POP from '../opcodes/pop';
+import MLOAD from '../opcodes/mload';
+import MSTORE from '../opcodes/mstore';
+import SLOAD from '../opcodes/sload';
+import SSTORE from '../opcodes/sstore';
+import JUMP from '../opcodes/jump';
+import JUMPI from '../opcodes/jumpi';
+import PC from '../opcodes/pc';
+import MSIZE from '../opcodes/msize';
+import GAS from '../opcodes/gas';
+import JUMPDEST from '../opcodes/jumpdest';
+import PUSH from '../opcodes/push';
+import DUP from '../opcodes/dup';
+import SWAP from '../opcodes/swap';
+import LOG from '../opcodes/log';
+import CREATE from '../opcodes/create';
+import CALL from '../opcodes/call';
+import CALLCODE from '../opcodes/callcode';
+import RETURN from '../opcodes/return';
+import DELEGATECALL from '../opcodes/delegatecall';
+import CREATE2 from '../opcodes/create2';
+import STATICCALL from '../opcodes/staticcall';
+import REVERT from '../opcodes/revert';
+import INVALID from '../opcodes/invalid';
+import SELFDESTRUCT from '../opcodes/selfdestruct';
+
+export default {
+    STOP,
+    ADD,
+    MUL,
+    SUB,
+    DIV,
+    SDIV: DIV,
+    MOD,
+    SMOD: MOD,
+    ADDMOD,
+    MULMOD,
+    EXP,
+    SIGNEXTEND,
+    LT,
+    GT,
+    SLT: LT,
+    SGT: GT,
+    EQ,
+    ISZERO,
+    AND,
+    OR,
+    XOR,
+    NOT,
+    BYTE,
+    SHL,
+    SHR,
+    SAR,
+    SHA3,
+    ADDRESS,
+    BALANCE,
+    ORIGIN,
+    CALLER,
+    CALLVALUE,
+    CALLDATALOAD,
+    CALLDATASIZE,
+    CALLDATACOPY,
+    CODESIZE,
+    CODECOPY,
+    GASPRICE,
+    EXTCODESIZE,
+    EXTCODECOPY,
+    RETURNDATASIZE,
+    RETURNDATACOPY,
+    EXTCODEHASH,
+    BLOCKHASH,
+    COINBASE,
+    TIMESTAMP,
+    NUMBER,
+    DIFFICULTY,
+    GASLIMIT,
+    POP,
+    MLOAD,
+    MSTORE,
+    MSTORE8: MSTORE,
+    SLOAD,
+    SSTORE,
+    JUMP,
+    JUMPI,
+    PC,
+    MSIZE,
+    GAS,
+    JUMPDEST,
+    PUSH1: PUSH,
+    PUSH2: PUSH,
+    PUSH3: PUSH,
+    PUSH4: PUSH,
+    PUSH5: PUSH,
+    PUSH6: PUSH,
+    PUSH7: PUSH,
+    PUSH8: PUSH,
+    PUSH9: PUSH,
+    PUSH10: PUSH,
+    PUSH11: PUSH,
+    PUSH12: PUSH,
+    PUSH13: PUSH,
+    PUSH14: PUSH,
+    PUSH15: PUSH,
+    PUSH16: PUSH,
+    PUSH17: PUSH,
+    PUSH18: PUSH,
+    PUSH19: PUSH,
+    PUSH20: PUSH,
+    PUSH21: PUSH,
+    PUSH22: PUSH,
+    PUSH23: PUSH,
+    PUSH24: PUSH,
+    PUSH25: PUSH,
+    PUSH26: PUSH,
+    PUSH27: PUSH,
+    PUSH28: PUSH,
+    PUSH29: PUSH,
+    PUSH30: PUSH,
+    PUSH31: PUSH,
+    PUSH32: PUSH,
+    DUP1: DUP,
+    DUP2: DUP,
+    DUP3: DUP,
+    DUP4: DUP,
+    DUP5: DUP,
+    DUP6: DUP,
+    DUP7: DUP,
+    DUP8: DUP,
+    DUP9: DUP,
+    DUP10: DUP,
+    DUP11: DUP,
+    DUP12: DUP,
+    DUP13: DUP,
+    DUP14: DUP,
+    DUP15: DUP,
+    DUP16: DUP,
+    SWAP1: SWAP,
+    SWAP2: SWAP,
+    SWAP3: SWAP,
+    SWAP4: SWAP,
+    SWAP5: SWAP,
+    SWAP6: SWAP,
+    SWAP7: SWAP,
+    SWAP8: SWAP,
+    SWAP9: SWAP,
+    SWAP10: SWAP,
+    SWAP11: SWAP,
+    SWAP12: SWAP,
+    SWAP13: SWAP,
+    SWAP14: SWAP,
+    SWAP15: SWAP,
+    SWAP16: SWAP,
+    LOG0: LOG,
+    LOG1: LOG,
+    LOG2: LOG,
+    LOG3: LOG,
+    LOG4: LOG,
+    CREATE,
+    CALL,
+    CALLCODE,
+    RETURN,
+    DELEGATECALL,
+    CREATE2,
+    STATICCALL,
+    REVERT,
+    INVALID,
+    SELFDESTRUCT
+};

package/src/evm/utils/stringify.ts

@@ -0,0 +1,12 @@
+import { $is } from '@dequanto/utils/$is';
+
+
+export default (item: any) => {
+    if ($is.BigInt(item)) {
+        return item.toString(16);
+    } else if (!item.wrapped) {
+        return item.toString();
+    } else {
+        return '(' + item.toString() + ')';
+    }
+};

package/src/evm/utils/stringifyEvents.ts

@@ -0,0 +1,37 @@
+export default (stateEvents: any, events: string[]) => {
+    const stateEventValues = Object.keys(stateEvents).map((key: string) => stateEvents[key]);
+    let output = '';
+
+    events.forEach((event: string) => {
+        const eventName = event.split('(')[0];
+        const eventArguments = event
+            .replace(eventName, '')
+            .substring(1)
+            .slice(0, -1);
+        output += 'event ';
+        if (eventArguments) {
+            output += eventName + '(';
+            output += eventArguments
+                .split(',')
+                .map((a: string, i: number) => {
+                    const stateEvent = stateEventValues.find((e: any) => e.label === event);
+                    if (stateEvent && i < stateEvent.indexedCount) {
+                        return a + ' indexed _arg' + i;
+                    } else {
+                        return a + ' _arg' + i;
+                    }
+                })
+                .join(', ');
+            output += ')';
+        } else {
+            output += event;
+        }
+        output += '\n';
+    });
+
+    if (events.length > 0) {
+        output += '\n';
+    }
+
+    return output;
+};

package/src/evm/utils/stringifyFunctions.ts

@@ -0,0 +1,41 @@
+import stringifyInstructions from './stringifyInstructions';
+import * as functionHashes from '../../data/functionHashes.json';
+
+export default (functionName: string, functionInstance: any): string => {
+    let output = '';
+    output += 'function ';
+    if (functionName in functionHashes) {
+        const fullFunction = (functionHashes as any)[functionName];
+        const fullFunctionName = fullFunction.split('(')[0];
+        const fullFunctionArguments = fullFunction
+            .replace(fullFunctionName, '')
+            .substring(1)
+            .slice(0, -1);
+        if (fullFunctionArguments) {
+            output += fullFunctionName + '(';
+            output += fullFunctionArguments
+                .split(',')
+                .map((a: string, i: number) => a + ' _arg' + i)
+                .join(', ');
+            output += ')';
+        } else {
+            output += fullFunction;
+        }
+    } else {
+        output += functionName + '()';
+    }
+    output += ' ' + functionInstance.visibility;
+    if (functionInstance.constant) {
+        output += ' view';
+    }
+    if (functionInstance.payable) {
+        output += ' payable';
+    }
+    if (functionInstance.returns.length > 0) {
+        output += ' returns (' + functionInstance.returns.join(', ') + ')';
+    }
+    output += ' {\n';
+    output += stringifyInstructions(functionInstance.items, 4);
+    output += '}\n\n';
+    return output;
+};