Contract 0xab908bd1f8e31064eae1130cee30fd30eae9f47f

Contract Overview

Balance:
0 Ether

Latest 25 internal transaction, Click here to view more Internal Transactions as a result of Contract Execution

Parent TxHash Block Age From To Value
0x44b2d66914037432a9fd04df3e63f567b6910b5c5363b598576442aab4b859b32760740228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x0d62e0b72366bf94fd9934ab9df80aea7cf0b5983b4afbb7047f312016a1a1f82760740228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xd3d562ba36fe9179150a77f4b9ddee43197903e1b55612408bc1215f1dba339c2760738228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xcb90258dd310430f77300cff76f3608b5727c1ebd3788ca920576a48f2dee40a2760738228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x6e98178e91096c64404c246a35a4c906508850619ba268dd423367e02af578d92760738228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x8693a73705601f0209d99ad5a434d6cf34c90446d69bd751c5555bfc3dbba2852760738228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xbf60a18d136a76f6c58a20555f173786cc178b25f5043dc782a66bc2600091b62760738228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x697021bafeffebcd929779902faa3219e5a7264172451e537416941a51962efc2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x03ddd4df4f02aa8154e453f3142b3d6d0f10618e7f0f521b29c07b6467699e022760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xf884c783e6dbb0c1c4a4dbcc920a487b97254ab6ec609ede5b79edfa153c9d252760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x1a63a8e3784af837e50eb42f6b504ef615edd18facdb51bf785e8a6126c9abe82760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xc5f196c19fb01c72651b9ad2112366de26a62dfce79329f3f96954b00d229d5d2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x9c758de0b05e90650682603da85dfec413f6e302ce89891f34f91db5ba598df82760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xd210705444edeb722111a166b086ee2edf7ff91ca6dbb50b7504bcee2246164c2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x268a7b7eada90019a569872dda6e3000279964e1ccd5420cfed736f18f9ea8e32760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x565fee65ef59337f780c29179727f84c3c17d26530652fcf3817eefd424c52c32760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xd3df48cd061a008145708e707132d3f10aed42d1a180fb2ef43ff356a9a30d152760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xff413cd0966c0d8f852357b1f0fa831d739693d855bdbcffb87b250bdff27c5d2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x1c6acd3ade667b378a9c7e932dbfed6ccf1974f60b4ae2297569580b5c15519e2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xe8f0ee39667a32b760675abc2188006cb2ff65a30e59443173bdfad576311b0c2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x279ab1c99aaa5a94b477af7392024752c64de8ffa9faf84e1d4b8a20878460af2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x138b04a9f72d24238e7f6add900a4c341ae9089f769de751c626129870fb52712760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0x8c7825a3641627f9f4ebe0ccfefed9de0d0d0efdd77c5d1706497ba0a84dd99e2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xaec64269f8712a22c1b420fbb802782e2ef671f24b2a7fd5e684eafcec0b9a5f2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
0xab2231e0a3bb301b5793d3b66478539280d13f7a2103aa1625e7729f8b470ddb2760737228 days 6 hrs ago0xfe2149773b3513703e79ad23d05a778a185016ee0xab908bd1f8e31064eae1130cee30fd30eae9f47f0 Ether
[ Download CSV Export 

Contract Source Code Verified (Exact Match)

Contract Name:
FusionFactory

Compiler Version
v0.4.18+commit.9cf6e910

Optimization Enabled:
No

Runs (Optimizer):
200

Contract Source Code

pragma solidity ^0.4.0;

// TODO: comment out `assert` statements before deployment to main net.
contract FusionFactory {
    // since setFusionFactoryAddress is OnlyCEO,
    // we just need to check that we do not make stupid mistake.
    bool public constant isFusionFactory = true;

    uint256 constant alleleNum = 2;

    uint256 constant noiseNum = 128;
    uint256 constant bitPerNoise = 2;
    uint256 constant noiseValueRange = 2 ** bitPerNoise;

    uint256 constant exclusiveAttrsNum = 3;
    uint256 constant bitPerExclusiveAttrs = 4;
    uint256 constant totalExclusiveAttrsBitNum = exclusiveAttrsNum * bitPerExclusiveAttrs * alleleNum;

    uint256 constant binAttrsNum = 7;
    uint256 constant bitPerBinAttrs = 1;

    uint256 constant attrsNum = exclusiveAttrsNum + binAttrsNum;

    uint256 constant bitPerAttrsSwap = 2;
    uint256 constant attrsPerSwap = 2 ** bitPerAttrsSwap;

    uint256 constant bitPerNoiseMutationPos = 4;
    uint256 constant noisePerMutation = 2 ** bitPerNoiseMutationPos;

    uint256 constant bitPerAttrsMutationPos = 4;
    uint256 constant attrsPerMutation = 2 ** bitPerAttrsMutationPos;


    /// @dev given code of crypko 1 & 2, return a genetic combination - may have a random factor
    /// @param noise1 of matron
    /// @param attrs1 of matron
    /// @param noise2 of sire
    /// @param attrs2 of sire
    /// @return the code that are supposed to be passed down the derivative
    function mixCode(
        uint256 noise1,
        uint256 attrs1,
        uint256 noise2,
        uint256 attrs2
    )
    public
    view   // TODO: use global function in function body and change view to pure
    returns (uint256, uint256) {
        // The derivative crypko's noise and attributes. Initialized to 0 as default.
        uint256 newNoise;
        uint256 newAttrs;

        // naively and boldly use block timestamp for randomness
        // however, this should works fine, since it is one of the strongest sources of entropy in solidity
        // and the entropy of the mapping from noise/attrs to the value of the crypko is too high
        // to be manipulated by miner.
        // potentially we can split the concatenation below to get more random numbers
        uint256 rand = uint256(keccak256( // TODO: add back `abi.encodePacked(` for solidity v0.5+
                noise1,
                attrs1,
                noise2,
                attrs2,
                now,
                block.blockhash(block.number - 1),  // TODO: remove `block.` for higher solidity version
                block.coinbase,
                block.difficulty
            ));


        // 1. recombine noise
        // merge origins' noise into derivative's noise
        (newNoise, rand) = recombineBatch(
            noise1,
            noise2,
            noiseNum,
            bitPerNoise,
            0,
            rand
        );

        // since recombining the noise only used
        // 128 bits of the random number (at the end)
        // we can use the remaining 128 bits (at the front)
//        require(rand >> noiseNum == 0);

        // recombine origins' exclusive attributes, dominant and recessive, into derivative's
        // Note: since dominant gene is on the left, and here we work reversed
        // so we recombine the recessive attributes first, and then the dominant
		// use exclusiveAttrsNum * alleleNum = 6 bits
        uint256 exclusiveAttrs;
        (exclusiveAttrs, rand) = recombine(
            attrs1,
            attrs2,
            exclusiveAttrsNum * alleleNum,
            bitPerExclusiveAttrs,
            getMask(bitPerExclusiveAttrs, 0),
            rand
        );

        // merge origins' binary attrs into derivative's
		// use binAttrsNum * alleleNum = 14 bits
        uint256 binAttrs;
        (binAttrs, rand) = recombineBatch(
            attrs1,
            attrs2,
            binAttrsNum * alleleNum,
            bitPerBinAttrs,
            totalExclusiveAttrsBitNum,
            rand
        );

        // since bin and exclusive attributes are on different bits,
        // we add them up to get the complete attributes
//        require(binAttrs & exclusiveAttrs == 0);
        newAttrs = binAttrs + exclusiveAttrs;

        // up until here, we right shift rand for 20 bits
        // remaining 108 bits for the rest

        // 2. swap alleles
        (newAttrs, rand) = swapDominantRecessive(newAttrs, rand);

        // 3. mutate
        (newNoise, rand) = mutateNoise(newNoise, rand); // ~4000 gas
        (newAttrs, rand) = mutateAttrs(newAttrs, rand);

        return (newNoise, newAttrs);
    }

    function swapDominantRecessive(
        uint256 derivativeAttrs,
        uint256 rand
    ) internal pure returns (uint256, uint256) {
        // analysis tools can evaluate your contract to identify the conditions and function calls which will reach a failing assert
        // https://medium.com/blockchannel/the-use-of-revert-assert-and-require-in-solidity-and-the-new-revert-opcode-in-the-evm-1a3a7990e06e
        assert(rand >> 256 - noiseNum - attrsNum * alleleNum == 0);  // 128 + 20
        uint256 startIndex = 0;
        for (uint256 i = 0; i < exclusiveAttrsNum; i++) {
            if (rand % attrsPerSwap == 0) {  // 25% possibility
                derivativeAttrs = mutate(
                    derivativeAttrs,
                    swapBits(derivativeAttrs, startIndex, bitPerExclusiveAttrs),
                    getMask(bitPerExclusiveAttrs * alleleNum, startIndex)
                );
            }
            rand >>= bitPerAttrsSwap;
            startIndex += bitPerExclusiveAttrs * alleleNum;
        }
        (derivativeAttrs, rand) = swapDominantRecessiveBinAttrs(derivativeAttrs, rand, startIndex);
        return (derivativeAttrs, rand);
    }
    
    // this is a tricky implementation
    // it works ONLY IF bitPerBinAttrs == 1 and alleleNum == 2 and position % 2 == 0 and possibility == 25%
    function swapDominantRecessiveBinAttrs(
        uint256 derivativeAttrs,
        uint256 rand,
        uint256 position
    )  internal pure returns (uint256, uint256) {
        assert(bitPerBinAttrs == 1 && alleleNum == 2 && position % 2 == 0);
        uint256 attrsMask = 0x5555555555555555555555555555555555555555555555555555555555555555;
        uint256 randMask = (((rand >> 1) | rand) & attrsMask) << position;
        uint256 dominantAttrs = (((derivativeAttrs >> 1) & ~randMask) | (derivativeAttrs & randMask)) & attrsMask;
        randMask <<= 1;
        uint256 recessiveAttrs = (((derivativeAttrs << 1) & ~randMask) | (derivativeAttrs & randMask)) & (attrsMask << 1);
        uint256 binAttrsMask = getMask(binAttrsNum * alleleNum, position);
        derivativeAttrs = mutate(derivativeAttrs, (dominantAttrs | recessiveAttrs) & binAttrsMask, binAttrsMask);
        rand >>= 2 * binAttrsNum;
        return (derivativeAttrs, rand);
    }


    function mutateNoise(
        uint256 derivativeNoise,
        uint256 rand
    ) internal pure returns (uint256, uint256) {
        assert(rand >> 256 - noiseNum - attrsNum * (alleleNum + bitPerAttrsSwap) == 0);  // 148 + 20 = 168
        // mutate every 16 noise
        for (uint256 idx = 0; idx < noiseNum; idx += noisePerMutation) { // 8 times

            // the first four bits indicate the position to mutate
            uint256 mutationPos = (rand % noisePerMutation + idx) * bitPerNoise;
            rand >>= bitPerNoiseMutationPos;

            // the next two bits indicate the value to mutate
            uint256 mutation = rand % noiseValueRange << mutationPos;
            rand >>= bitPerNoise;

            // replace the gene at mutationPos with the mutation
            derivativeNoise = mutate(derivativeNoise, mutation, getMask(bitPerNoise, mutationPos));
        }
        return (derivativeNoise, rand);
    }


    function mutateAttrs(
        uint256 derivativeAttrs,
        uint256 rand
    ) internal pure returns (uint256, uint256) {
        assert(
            rand >> noiseNum - attrsNum * (alleleNum + bitPerAttrsSwap) -
            (noiseNum / noisePerMutation) * (bitPerNoiseMutationPos + bitPerNoise) == 0
        ); // 168 + 8 * 6 = 216
        uint256 attrToMutate = rand % attrsPerMutation;

        // a mutation only happens on a dominant attribute.
        // since there are 14 attrs in total, we mutate just one of the attrs
        // the possibility for every attribute to mutate should be 1/16 for dominant and 0 for recessive
        if (attrToMutate >= attrsNum) {
            // no mutation if random num >= 14
            return (derivativeAttrs, rand >> bitPerAttrsMutationPos + bitPerExclusiveAttrs);
        }
        uint256 mutationPos;
        uint256 mutationBitNum;
        if (attrToMutate < exclusiveAttrsNum) {
            // the position of the gene to mutate. it should be the allele on the left
            mutationPos = alleleNum * bitPerExclusiveAttrs * attrToMutate + bitPerExclusiveAttrs;
            mutationBitNum = bitPerExclusiveAttrs;
        } else {
            mutationPos = totalExclusiveAttrsBitNum + alleleNum * (attrToMutate - exclusiveAttrsNum) * bitPerBinAttrs + bitPerBinAttrs;
            mutationBitNum = bitPerBinAttrs;
        }
        rand >>= bitPerAttrsMutationPos;
        uint256 mutationMask = getMask(mutationBitNum, mutationPos);
        uint256 mutation = rand % 2 ** mutationBitNum << mutationPos;
        derivativeAttrs = mutate(derivativeAttrs, mutation, mutationMask);

		// TODO: comment line below. This is not necessary, just for code completeness.
        rand >>= bitPerExclusiveAttrs;

        // we used at most 8 bits (or 5 if we mutate on binary attributes, or 4 if no mutation)
        // remaining 256 - 216 - 8 = 32 free bits!
        return (derivativeAttrs, rand);
    }

    // some helper function of computation to tidy up the codes

    function getMask(uint256 size, uint256 position) internal pure returns (uint256) {
        // binary mask with `size` number of 1 and followed by `position` number of 0
        return 2 ** size - 1 << position;
    }

    function swapBits(uint256 attrs, uint256 startIdx, uint256 bitNum) internal pure returns (uint256) {
        // swap the gene of size `bitNum` at `startIdx` of `attrs`
        attrs >>= startIdx;
        uint256 recessive = attrs % (2 ** bitNum);
        uint256 dominant = (attrs >> bitNum) % (2 ** bitNum);
        return ((recessive << bitNum) + dominant) << startIdx;
    }

    /// recombine code of matron and sire into the derivative according to the choice
    /// @param matron  matron's noise or attributes
    /// @param sire  sire's noise or attributes
    /// @param repetition  repeated times
    /// @param step  step for moving the mask
    /// @param mask  indicating the position of the currently relevant gene
    /// @param rand  a random number reading from right to left.
    /// If a bit is 0, choose matron's gene, and if 1, choose sire's gene
    function recombine(
        uint256 matron,
        uint256 sire,
        uint256 repetition,
        uint256 step,
        uint256 mask,
        uint256 rand
    ) internal pure returns (uint256, uint256) {
        uint256 derivative = 0;
        for (uint256 i = 0; i < repetition; i++) {
            // 50% possibility choosing one of the origins
            derivative += (rand % 2 == 0 ? matron: sire) & mask;
            mask <<= step;
            rand >>= 1;
        }
        return (derivative, rand);
    }
    
    /// recombine code of matron and sire into the derivative according to the choice
    /// @param matron  matron's noise or attributes
    /// @param sire  sire's noise or attributes
    /// @param repetition  repeated times
    /// @param step  step for moving the mask
    /// @param position  indicating the starting position (different from `recombine`!)
    /// @param rand  a random number reading from right to left.
    /// If a bit is 0, choose matron's gene, and if 1, choose sire's gene
    function recombineBatch(
        uint256 matron,
        uint256 sire,
        uint256 repetition,
        uint256 step,
        uint256 position,
        uint256 rand
    ) internal pure returns (uint256, uint256) {
        assert(step == 1 || step == 2);
        uint256 randDup = duplicateBits(rand, step);
        randDup <<= position;
        uint256 mask = getMask(step * repetition, position);
        uint256 derivative = ((~randDup & matron) | (randDup & sire)) & mask;
        rand >>= repetition;
        return (derivative, rand);
    }
    
    /// duplicate every bit for `count` times, ignore the highest bits
    /// only works when count == 1 (do nothing) or count == 2
    /// Sample input: (01101011, 2)
    /// Sample output: 11001111 (`1011` are duplicated twice)
    /// @param input  the input number
    /// @param count  the number duplicate bits for each input bit
    function duplicateBits(
        uint256 input,
        uint256 count
    ) internal pure returns (uint256) {
        if (count == 1) {
            return input;
        } else if (count == 2){
            uint256 mask1 = 0x00000000000000000000000000000000ffffffffffffffff0000000000000000;
            uint256 mask2 = 0x000000000000000000000000000000000000000000000000ffffffffffffffff;
            input = ((input & mask1) << 64) | (input & mask2);
            mask1 = 0x0000000000000000ffffffff000000000000000000000000ffffffff00000000;
            mask2 = 0x000000000000000000000000ffffffff000000000000000000000000ffffffff;
            input = ((input & mask1) << 32) | (input & mask2);
            mask1 = 0x00000000ffff000000000000ffff000000000000ffff000000000000ffff0000;
            mask2 = 0x000000000000ffff000000000000ffff000000000000ffff000000000000ffff;
            input = ((input & mask1) << 16) | (input & mask2);
            mask1 = 0x0000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff00;
            mask2 = 0x000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff;
            input = ((input & mask1) << 8) | (input & mask2);
            mask1 = 0x00f000f000f000f000f000f000f000f000f000f000f000f000f000f000f000f0;
            mask2 = 0x000f000f000f000f000f000f000f000f000f000f000f000f000f000f000f000f;
            input = ((input & mask1) << 4) | (input & mask2);
            mask1 = 0x0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c;
            mask2 = 0x0303030303030303030303030303030303030303030303030303030303030303;
            input = ((input & mask1) << 2) | (input & mask2);
            mask1 = 0x2222222222222222222222222222222222222222222222222222222222222222;
            mask2 = 0x1111111111111111111111111111111111111111111111111111111111111111;
            input = ((input & mask1) << 1) | (input & mask2);
            input = (input << 1) | input;
            return input;
        } else {
            assert(false); // not supported
        }
    }

    function mutate(
        uint256 derivative,
        uint256 mutation,
        uint256 mask
    ) internal pure returns (uint256) {
        // mutate the gene at the `mask` position of the derivative code to `mutation`

		// mutation should be contained in masked area!
		assert(mutation & ~mask == 0);

        return (derivative & ~mask) + mutation;
    }
}

Contract ABI

[{"constant":true,"inputs":[],"name":"isFusionFactory","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"noise1","type":"uint256"},{"name":"attrs1","type":"uint256"},{"name":"noise2","type":"uint256"},{"name":"attrs2","type":"uint256"}],"name":"mixCode","outputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

Contract Creation Code

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

Swarm Source

bzzr://70167989078812fc43514a633631408ad35124adef30ed47722f327a8bb0390f
Block Age Transaction Difficulty GasUsed Reward
Block Age Uncle Number Difficulty GasUsed Reward