Contract 0x5789e2b5460cae9329d93a78511e2ac49f98a1f6

 

TxHash Block Age From To Value [TxFee]
0xb2f329ba372f4b6cc4c05b8ca4cbef90ad03a1ca5cea9aef8de8d4de35ad18e46038471239 days 3 hrs ago0x95b697e13f227d55ef4336f7aa762fe243eef590 IN  GU_LegendaryPack0 Ether0.00054984
0x01a64550e4cad9f1f48ff8155d98ee59d7a2ac3270cfb8d4b4541140f8e1cec55970271250 days 18 hrs ago0x8bcb229a544e110b279d9158504783f9cfbe456e IN  GU_LegendaryPack0 Ether0.0002266
0x7beeadd3df84a1e72c10779ab9a8cf648dd48488d89e26cabfc84404df2bf42e5955103253 days 7 hrs ago0xaf42b74f2d2c40c5cf99ae1f7357d855b02059a3 IN  GU_LegendaryPack0.36 Ether0.000189704
0x616052666475d9ec6a167bfc4daddf7526663328ea95c7bf35552c76b2dac8b05947764254 days 12 hrs ago0xe310ecb5ad4bdf59d7e2bfa28871a67d260ecef0 IN  GU_LegendaryPack0.3645 Ether0.0003006022
0x70dba9f46171ea5f9e1b04910a456a2696858a7ab46372c643fd82858e778bfd5945659254 days 20 hrs ago0x95b697e13f227d55ef4336f7aa762fe243eef590 IN  GU_LegendaryPack0 Ether0.00085053
0x47ae09735d09f050973d1e8e26c9624bf8f4147caa748f504e7f06b8d8a99f955945647254 days 21 hrs ago0xcb3562dd15807e2bcf35092b1e873971af0a51da IN  GU_LegendaryPack0 Ether0.000329115
0x4fc534ac55955e9c2f137f1f2140832387e98b14ce2443c33611e3e1711188fd5944498255 days 1 hr ago0x1ae5f902319ab59f3c6420fb405f64d4632dc4ec IN  GU_LegendaryPack0 Ether0.001306325
0x1027802d00bc77e6ba1cc2f482abfcd04183082f8876f700e04e9083e4cd38325944496255 days 1 hr ago0x78fea9884fb0a3e03a1b7ab06d88210994daffcf IN  GU_LegendaryPack0.36 Ether0.001021096
0xbe546bee209a2892d810d3694d68e7bd6a959a7e91871ecaf40d73dd0278fc615944443255 days 1 hr ago0x1ae5f902319ab59f3c6420fb405f64d4632dc4ec IN  GU_LegendaryPack0 Ether0.001306325
0x193f1a8952c1d8f8c95caac77744c00a5300599ce9392a4b2a2c0b3402d3aaed5944441255 days 1 hr ago0x7a8660a241bc6640118276a2b0cded05e11a6998 IN  GU_LegendaryPack0.36 Ether0.00127637
0x1f5be6667ca101d70ff805160a40575a6fd629151944b552e56f4af33363a7865944227255 days 2 hrs ago0x1ae5f902319ab59f3c6420fb405f64d4632dc4ec IN  GU_LegendaryPack0 Ether0.001306325
0x990c067e8b3213a67be6e02379a5acd586f736b32840552da0690bdb84bdc28a5944224255 days 2 hrs ago0xf7a23f55b48c027d465032fd9d0691dc469007ee IN  GU_LegendaryPack0.36 Ether0.0011488974
0xad0c500ebc8ecd34559be1dda12b2f71e132d647d96039b124d0ece4d5ea10e55943895255 days 4 hrs ago0x31a59f382c9f93a601a7b409d412a000c56f8afb IN  GU_LegendaryPack0 Ether0.0003399
0xcb8c4d4a51750c776c61b23f9a02ec3d5f21d529018bc4038b5a967926c792555943891255 days 4 hrs ago0x8bcb229a544e110b279d9158504783f9cfbe456e IN  GU_LegendaryPack0 Ether0.0002266
0x037f9dbecb4a8d9e3499eb7cb46130b3fa8b346798ea43a4548481b9e40c77115943891255 days 4 hrs ago0x31a59f382c9f93a601a7b409d412a000c56f8afb IN  GU_LegendaryPack0 Ether0.00052253
0xa2bb53944c73e2b6083a8c812a9a146906ab14883322501e3b75f99647ce616d5943884255 days 4 hrs ago0x1ae5f902319ab59f3c6420fb405f64d4632dc4ec IN  GU_LegendaryPack0 Ether0.001306325
0xc37f75f13e5d4e11f9eee666a912879cc7891dd579bf8b99fff5b61973dcc01a5943883255 days 4 hrs ago0x76b370bc59f32c0b58bdc4a95bcaf763d871a62e IN  GU_LegendaryPack0.36 Ether0.00112637
0xb188cfa3894a7b9d1f83d366b6a134eb49e3992cbc09895b28494a875931024e5943881255 days 4 hrs ago0x0cdd0ff2ea99e5a2476c709eeb705a70934a5c6f IN  GU_LegendaryPack0.36 Ether0.000563185
0x214685dddeed92b02f35ee3c475b242122148b8403533e10c083abf30aeb57d35943881255 days 4 hrs ago0xaf42b74f2d2c40c5cf99ae1f7357d855b02059a3 IN  GU_LegendaryPack0.36 Ether0.000190328
0xc05594a3cd53969327dbc56d217a23b275c063ea91ad9c1ea71062c426dca0705943822255 days 4 hrs ago0x1ae5f902319ab59f3c6420fb405f64d4632dc4ec IN  GU_LegendaryPack0 Ether0.001306325
0xe5e092fbb767ca8da6861483adf40a1be900259b75c0a2774782b083ab30116a5943820255 days 4 hrs ago0x4361e1981b9272b173f72198e447c30ba921333a IN  GU_LegendaryPack0.36 Ether0.001021096
0x9a419400ffd9772bdab709f58409d82874e7fe0e61820a86fa842ec7dbd081675943792255 days 4 hrs ago0x1ae5f902319ab59f3c6420fb405f64d4632dc4ec IN  GU_LegendaryPack0 Ether0.001306325
0x30ffc134b87d1a36a0505b74c6e82a7635cff5b346631341f5ddb502f4d6536c5943790255 days 4 hrs ago0xf7a23f55b48c027d465032fd9d0691dc469007ee IN  GU_LegendaryPack0.36 Ether0.00127637
0x4b82a2921eb64f7ef6af3a624258155c2fe7bf1f8ded34b28936ca00a9919f7f5943709255 days 4 hrs ago0x1ae5f902319ab59f3c6420fb405f64d4632dc4ec IN  GU_LegendaryPack0 Ether0.001306325
0xf2640e720e3e76e14fdb138222f66ce324aabbd3be781025917351670b55aee15943707255 days 4 hrs ago0x76b370bc59f32c0b58bdc4a95bcaf763d871a62e IN  GU_LegendaryPack0.36 Ether0.00127637
[ Download CSV Export 

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

Parent TxHash Block Age From To Value
0x1027802d00bc77e6ba1cc2f482abfcd04183082f8876f700e04e9083e4cd38325944496255 days 1 hr ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0x193f1a8952c1d8f8c95caac77744c00a5300599ce9392a4b2a2c0b3402d3aaed5944441255 days 1 hr ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0x990c067e8b3213a67be6e02379a5acd586f736b32840552da0690bdb84bdc28a5944224255 days 2 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0xc37f75f13e5d4e11f9eee666a912879cc7891dd579bf8b99fff5b61973dcc01a5943883255 days 4 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0xb188cfa3894a7b9d1f83d366b6a134eb49e3992cbc09895b28494a875931024e5943881255 days 4 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0xe5e092fbb767ca8da6861483adf40a1be900259b75c0a2774782b083ab30116a5943820255 days 4 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0x30ffc134b87d1a36a0505b74c6e82a7635cff5b346631341f5ddb502f4d6536c5943790255 days 4 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0xf2640e720e3e76e14fdb138222f66ce324aabbd3be781025917351670b55aee15943707255 days 4 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0xc0be5dff7e4719496f781de0735cab34c76c9b4d241f40f9fd4aa9e7c90870465943670255 days 5 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6891.8 Ether
0xe4b98fa8f7fa4eace92950ef367e41e17a822a5dc4d8125b5834a10a50992c0c5943639255 days 5 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0x2e3cd1ec51aa5a9da75a1a3ea17e3f9fbbeb32c509a2b38d98fdde74cd964fb35943604255 days 5 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0xe63f3683c5b5c498bfde7b93f51439caa93b078856e854404833c336f55ec0175943571255 days 5 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0x05b62108504c4095f1250e1196d8e06ed0e820ec81e47bb0e9f57200a49ff03e5943556255 days 5 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0x62af4e0893f1b9a0ac8834f78181229897354afb3771573567c46a596a6b22b45943395255 days 6 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0xf9f2b1687d83b27846c1f153f269b60a4617a04aef168fbf1146eb658706b1f35943284255 days 6 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0x506400fd7ece2a10559fd920860645244bb27c8ebabca1cef8924057b12dc1685943277255 days 6 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0xf93272ceee1035f6275afed46dbda6aa94c259d0805eed355fd30153bdc9b4135942986255 days 7 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.324 Ether
0xf93272ceee1035f6275afed46dbda6aa94c259d0805eed355fd30153bdc9b4135942986255 days 7 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60xc7ded8d808fc92e2f1696bf8b130e3f9984c75290.036 Ether
0xb92b5e82bc5341953046d01f9f1a52030adcffcfc0bef1e717b76e26d29c8e7e5942893255 days 8 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.324 Ether
0xb92b5e82bc5341953046d01f9f1a52030adcffcfc0bef1e717b76e26d29c8e7e5942893255 days 8 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60xc7ded8d808fc92e2f1696bf8b130e3f9984c75290.036 Ether
0x10aef48a5a44deb5ed4e61bc96e07dd203e8f1e034b111c50c3c774f81af52775942823255 days 8 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0xd143f34b28d449e37d8d0e561e3f1195d40de1bd7c1aae9cccc0dc9e85e14b8d5942815255 days 8 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.36 Ether
0x9866519efe4f5af926df8ede5de8c72a090220941e94739695e37ae8eaa54a995942797255 days 8 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6891.8 Ether
0x6987668c4aaedf55ec98e5301fcc2a4f6eb3f33a63a7d9af7b52b3a546b8f8955942709255 days 9 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60x91b9d2835ad914bc1dcfe09bd1816febd04fd6890.324 Ether
0x6987668c4aaedf55ec98e5301fcc2a4f6eb3f33a63a7d9af7b52b3a546b8f8955942709255 days 9 hrs ago0x5789e2b5460cae9329d93a78511e2ac49f98a1f60xc7ded8d808fc92e2f1696bf8b130e3f9984c75290.036 Ether
[ Download CSV Export 
Warning: The compiled contract might be susceptible to ExpExponentCleanup (medium/high-severity), EventStructWrongData (very low-severity) Solidity Compiler Bugs.

Contract Source Code Verified (Exact Match)

Contract Name:
LegendaryPack

Compiler Version
v0.4.24+commit.e67f0147

Optimization Enabled:
No

Runs (Optimizer):
200

Contract Source Code

pragma solidity 0.4.24;

contract Governable {

    event Pause();
    event Unpause();

    address public governor;
    bool public paused = false;

    constructor() public {
        governor = msg.sender;
    }

    function setGovernor(address _gov) public onlyGovernor {
        governor = _gov;
    }

    modifier onlyGovernor {
        require(msg.sender == governor);
        _;
    }

    /**
    * @dev Modifier to make a function callable only when the contract is not paused.
    */
    modifier whenNotPaused() {
        require(!paused);
        _;
    }

    /**
    * @dev Modifier to make a function callable only when the contract is paused.
    */
    modifier whenPaused() {
        require(paused);
        _;
    }

    /**
    * @dev called by the owner to pause, triggers stopped state
    */
    function pause() onlyGovernor whenNotPaused public {
        paused = true;
        emit Pause();
    }

    /**
    * @dev called by the owner to unpause, returns to normal state
    */
    function unpause() onlyGovernor whenPaused public {
        paused = false;
        emit Unpause();
    }

}

contract CardBase is Governable {


    struct Card {
        uint16 proto;
        uint16 purity;
    }

    function getCard(uint id) public view returns (uint16 proto, uint16 purity) {
        Card memory card = cards[id];
        return (card.proto, card.purity);
    }

    function getShine(uint16 purity) public pure returns (uint8) {
        return uint8(purity / 1000);
    }

    Card[] public cards;
    
}

contract CardProto is CardBase {

    event NewProtoCard(
        uint16 id, uint8 season, uint8 god, 
        Rarity rarity, uint8 mana, uint8 attack, 
        uint8 health, uint8 cardType, uint8 tribe, bool packable
    );

    struct Limit {
        uint64 limit;
        bool exists;
    }

    // limits for mythic cards
    mapping(uint16 => Limit) public limits;

    // can only set limits once
    function setLimit(uint16 id, uint64 limit) public onlyGovernor {
        Limit memory l = limits[id];
        require(!l.exists);
        limits[id] = Limit({
            limit: limit,
            exists: true
        });
    }

    function getLimit(uint16 id) public view returns (uint64 limit, bool set) {
        Limit memory l = limits[id];
        return (l.limit, l.exists);
    }

    // could make these arrays to save gas
    // not really necessary - will be update a very limited no of times
    mapping(uint8 => bool) public seasonTradable;
    mapping(uint8 => bool) public seasonTradabilityLocked;
    uint8 public currentSeason;

    function makeTradeable(uint8 season) public onlyGovernor {
        seasonTradable[season] = true;
    }

    function makeUntradable(uint8 season) public onlyGovernor {
        require(!seasonTradabilityLocked[season]);
        seasonTradable[season] = false;
    }

    function makePermanantlyTradable(uint8 season) public onlyGovernor {
        require(seasonTradable[season]);
        seasonTradabilityLocked[season] = true;
    }

    function isTradable(uint16 proto) public view returns (bool) {
        return seasonTradable[protos[proto].season];
    }

    function nextSeason() public onlyGovernor {
        //Seasons shouldn't go to 0 if there is more than the uint8 should hold, the governor should know this ¯\_(ツ)_/¯ -M
        require(currentSeason <= 255); 

        currentSeason++;
        mythic.length = 0;
        legendary.length = 0;
        epic.length = 0;
        rare.length = 0;
        common.length = 0;
    }

    enum Rarity {
        Common,
        Rare,
        Epic,
        Legendary, 
        Mythic
    }

    uint8 constant SPELL = 1;
    uint8 constant MINION = 2;
    uint8 constant WEAPON = 3;
    uint8 constant HERO = 4;

    struct ProtoCard {
        bool exists;
        uint8 god;
        uint8 season;
        uint8 cardType;
        Rarity rarity;
        uint8 mana;
        uint8 attack;
        uint8 health;
        uint8 tribe;
    }

    // there is a particular design decision driving this:
    // need to be able to iterate over mythics only for card generation
    // don't store 5 different arrays: have to use 2 ids
    // better to bear this cost (2 bytes per proto card)
    // rather than 1 byte per instance

    uint16 public protoCount;
    
    mapping(uint16 => ProtoCard) protos;

    uint16[] public mythic;
    uint16[] public legendary;
    uint16[] public epic;
    uint16[] public rare;
    uint16[] public common;

    function addProtos(
        uint16[] externalIDs, uint8[] gods, Rarity[] rarities, uint8[] manas, uint8[] attacks, uint8[] healths, uint8[] cardTypes, uint8[] tribes, bool[] packable
    ) public onlyGovernor returns(uint16) {

        for (uint i = 0; i < externalIDs.length; i++) {

            ProtoCard memory card = ProtoCard({
                exists: true,
                god: gods[i],
                season: currentSeason,
                cardType: cardTypes[i],
                rarity: rarities[i],
                mana: manas[i],
                attack: attacks[i],
                health: healths[i],
                tribe: tribes[i]
            });

            _addProto(externalIDs[i], card, packable[i]);
        }
        
    }

    function addProto(
        uint16 externalID, uint8 god, Rarity rarity, uint8 mana, uint8 attack, uint8 health, uint8 cardType, uint8 tribe, bool packable
    ) public onlyGovernor returns(uint16) {
        ProtoCard memory card = ProtoCard({
            exists: true,
            god: god,
            season: currentSeason,
            cardType: cardType,
            rarity: rarity,
            mana: mana,
            attack: attack,
            health: health,
            tribe: tribe
        });

        _addProto(externalID, card, packable);
    }

    function addWeapon(
        uint16 externalID, uint8 god, Rarity rarity, uint8 mana, uint8 attack, uint8 durability, bool packable
    ) public onlyGovernor returns(uint16) {

        ProtoCard memory card = ProtoCard({
            exists: true,
            god: god,
            season: currentSeason,
            cardType: WEAPON,
            rarity: rarity,
            mana: mana,
            attack: attack,
            health: durability,
            tribe: 0
        });

        _addProto(externalID, card, packable);
    }

    function addSpell(uint16 externalID, uint8 god, Rarity rarity, uint8 mana, bool packable) public onlyGovernor returns(uint16) {

        ProtoCard memory card = ProtoCard({
            exists: true,
            god: god,
            season: currentSeason,
            cardType: SPELL,
            rarity: rarity,
            mana: mana,
            attack: 0,
            health: 0,
            tribe: 0
        });

        _addProto(externalID, card, packable);
    }

    function addMinion(
        uint16 externalID, uint8 god, Rarity rarity, uint8 mana, uint8 attack, uint8 health, uint8 tribe, bool packable
    ) public onlyGovernor returns(uint16) {

        ProtoCard memory card = ProtoCard({
            exists: true,
            god: god,
            season: currentSeason,
            cardType: MINION,
            rarity: rarity,
            mana: mana,
            attack: attack,
            health: health,
            tribe: tribe
        });

        _addProto(externalID, card, packable);
    }

    function _addProto(uint16 externalID, ProtoCard memory card, bool packable) internal {

        require(!protos[externalID].exists);

        card.exists = true;

        protos[externalID] = card;

        protoCount++;

        emit NewProtoCard(
            externalID, currentSeason, card.god, 
            card.rarity, card.mana, card.attack, 
            card.health, card.cardType, card.tribe, packable
        );

        if (packable) {
            Rarity rarity = card.rarity;
            if (rarity == Rarity.Common) {
                common.push(externalID);
            } else if (rarity == Rarity.Rare) {
                rare.push(externalID);
            } else if (rarity == Rarity.Epic) {
                epic.push(externalID);
            } else if (rarity == Rarity.Legendary) {
                legendary.push(externalID);
            } else if (rarity == Rarity.Mythic) {
                mythic.push(externalID);
            } else {
                require(false);
            }
        }
    }

    function getProto(uint16 id) public view returns(
        bool exists, uint8 god, uint8 season, uint8 cardType, Rarity rarity, uint8 mana, uint8 attack, uint8 health, uint8 tribe
    ) {
        ProtoCard memory proto = protos[id];
        return (
            proto.exists,
            proto.god,
            proto.season,
            proto.cardType,
            proto.rarity,
            proto.mana,
            proto.attack,
            proto.health,
            proto.tribe
        );
    }

    function getRandomCard(Rarity rarity, uint16 random) public view returns (uint16) {
        // modulo bias is fine - creates rarity tiers etc
        // will obviously revert is there are no cards of that type: this is expected - should never happen
        if (rarity == Rarity.Common) {
            return common[random % common.length];
        } else if (rarity == Rarity.Rare) {
            return rare[random % rare.length];
        } else if (rarity == Rarity.Epic) {
            return epic[random % epic.length];
        } else if (rarity == Rarity.Legendary) {
            return legendary[random % legendary.length];
        } else if (rarity == Rarity.Mythic) {
            // make sure a mythic is available
            uint16 id;
            uint64 limit;
            bool set;
            for (uint i = 0; i < mythic.length; i++) {
                id = mythic[(random + i) % mythic.length];
                (limit, set) = getLimit(id);
                if (set && limit > 0){
                    return id;
                }
            }
            // if not, they get a legendary :(
            return legendary[random % legendary.length];
        }
        require(false);
        return 0;
    }

    // can never adjust tradable cards
    // each season gets a 'balancing beta'
    // totally immutable: season, rarity
    function replaceProto(
        uint16 index, uint8 god, uint8 cardType, uint8 mana, uint8 attack, uint8 health, uint8 tribe
    ) public onlyGovernor {
        ProtoCard memory pc = protos[index];
        require(!seasonTradable[pc.season]);
        protos[index] = ProtoCard({
            exists: true,
            god: god,
            season: pc.season,
            cardType: cardType,
            rarity: pc.rarity,
            mana: mana,
            attack: attack,
            health: health,
            tribe: tribe
        });
    }

}

interface ERC721Metadata /* is ERC721 */ {
    /// @notice A descriptive name for a collection of NFTs in this contract
    function name() external pure returns (string _name);

    /// @notice An abbreviated name for NFTs in this contract
    function symbol() external pure returns (string _symbol);

    /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
    /// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
    ///  3986. The URI may point to a JSON file that conforms to the "ERC721
    ///  Metadata JSON Schema".
    function tokenURI(uint256 _tokenId) external view returns (string);
}

interface ERC721Enumerable /* is ERC721 */ {
    /// @notice Count NFTs tracked by this contract
    /// @return A count of valid NFTs tracked by this contract, where each one of
    ///  them has an assigned and queryable owner not equal to the zero address
    function totalSupply() public view returns (uint256);

    /// @notice Enumerate valid NFTs
    /// @dev Throws if `_index` >= `totalSupply()`.
    /// @param _index A counter less than `totalSupply()`
    /// @return The token identifier for the `_index`th NFT,
    ///  (sort order not specified)
    function tokenByIndex(uint256 _index) external view returns (uint256);

    /// @notice Enumerate NFTs assigned to an owner
    /// @dev Throws if `_index` >= `balanceOf(_owner)` or if
    ///  `_owner` is the zero address, representing invalid NFTs.
    /// @param _owner An address where we are interested in NFTs    owned by them
    /// @param _index A counter less than `balanceOf(_owner)`
    /// @return The token identifier for the `_index`th NFT assigned to `_owner`,
    ///   (sort order not specified)
    function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256 _tokenId);
}

interface ERC165 {
    /// @notice Query if a contract implements an interface
    /// @param interfaceID The interface identifier, as specified in ERC-165
    /// @dev Interface identification is specified in ERC-165. This function
    ///  uses less than 30,000 gas.
    /// @return `true` if the contract implements `interfaceID` and
    ///  `interfaceID` is not 0xffffffff, `false` otherwise
    function supportsInterface(bytes4 interfaceID) external view returns (bool);
}

contract ERC721 {
    event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
    event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

    function balanceOf(address _owner) public view returns (uint256 _balance);
    function ownerOf(uint256 _tokenId) public view returns (address _owner);
    function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) public payable;
    function safeTransferFrom(address _from, address _to, uint256 _tokenId) public payable;
    function transfer(address _to, uint256 _tokenId) public payable;
    function transferFrom(address _from, address _to, uint256 _tokenId) public payable;
    function approve(address _to, uint256 _tokenId) public payable;
    function setApprovalForAll(address _to, bool _approved) public;
    function getApproved(uint256 _tokenId) public view returns (address);
    function isApprovedForAll(address _owner, address _operator) public view returns (bool);
}

contract NFT is ERC721, ERC165, ERC721Metadata, ERC721Enumerable {}

contract CardOwnership is NFT, CardProto {

    // doing this strategy doesn't save gas
    // even setting the length to the max and filling in
    // unfortunately - maybe if we stop it boundschecking
    // address[] owners;
    mapping(uint => address) owners;
    mapping(uint => address) approved;
    // support multiple operators
    mapping(address => mapping(address => bool)) operators;

    // save space, limits us to 2^40 tokens (>1t)
    mapping(address => uint40[]) public ownedTokens;

    mapping(uint => string) uris;

    // save space, limits us to 2^24 tokens per user (~17m)
    uint24[] indices;

    uint public burnCount;

    /**
    * @return the name of this token
    */
    function name() public view returns (string) {
        return "Gods Unchained";
    }

    /**
    * @return the symbol of this token
    */  
    function symbol() public view returns (string) {
        return "GODS";
    }

    /**
    * @return the total number of cards in circulation
    */
    function totalSupply() public view returns (uint) {
        return cards.length - burnCount;
    }

    /**
    * @param to : the address to which the card will be transferred
    * @param id : the id of the card to be transferred
    */
    function transfer(address to, uint id) public payable {
        require(owns(msg.sender, id));
        require(isTradable(cards[id].proto));
        require(to != address(0));
        _transfer(msg.sender, to, id);
    }

    /**
    * internal transfer function which skips checks - use carefully
    * @param from : the address from which the card will be transferred
    * @param to : the address to which the card will be transferred
    * @param id : the id of the card to be transferred
    */
    function _transfer(address from, address to, uint id) internal {
        approved[id] = address(0);
        owners[id] = to;
        _addToken(to, id);
        _removeToken(from, id);
        emit Transfer(from, to, id);
    }

    /**
    * initial internal transfer function which skips checks and saves gas - use carefully
    * @param to : the address to which the card will be transferred
    * @param id : the id of the card to be transferred
    */
    function _create(address to, uint id) internal {
        owners[id] = to;
        _addToken(to, id);
        emit Transfer(address(0), to, id);
    }

    /**
    * @param to : the address to which the cards will be transferred
    * @param ids : the ids of the cards to be transferred
    */
    function transferAll(address to, uint[] ids) public payable {
        for (uint i = 0; i < ids.length; i++) {
            transfer(to, ids[i]);
        }
    }

    /**
    * @param proposed : the claimed owner of the cards
    * @param ids : the ids of the cards to check
    * @return whether proposed owns all of the cards 
    */
    function ownsAll(address proposed, uint[] ids) public view returns (bool) {
        for (uint i = 0; i < ids.length; i++) {
            if (!owns(proposed, ids[i])) {
                return false;
            }
        }
        return true;
    }

    /**
    * @param proposed : the claimed owner of the card
    * @param id : the id of the card to check
    * @return whether proposed owns the card
    */
    function owns(address proposed, uint id) public view returns (bool) {
        return ownerOf(id) == proposed;
    }

    /**
    * @param id : the id of the card
    * @return the address of the owner of the card
    */
    function ownerOf(uint id) public view returns (address) {
        return owners[id];
    }

    /**
    * @param id : the index of the token to burn
    */
    function burn(uint id) public {
        // require(isTradable(cards[id].proto));
        require(owns(msg.sender, id));
        burnCount++;
        // use the internal transfer function as the external
        // has a guard to prevent transfers to 0x0
        _transfer(msg.sender, address(0), id);
    }

    /**
    * @param ids : the indices of the tokens to burn
    */
    function burnAll(uint[] ids) public {
        for (uint i = 0; i < ids.length; i++){
            burn(ids[i]);
        }
    }

    /**
    * @param to : the address to approve for transfer
    * @param id : the index of the card to be approved
    */
    function approve(address to, uint id) public payable {
        require(owns(msg.sender, id));
        require(isTradable(cards[id].proto));
        approved[id] = to;
        emit Approval(msg.sender, to, id);
    }

    /**
    * @param to : the address to approve for transfer
    * @param ids : the indices of the cards to be approved
    */
    function approveAll(address to, uint[] ids) public payable {
        for (uint i = 0; i < ids.length; i++) {
            approve(to, ids[i]);
        }
    }

    /**
    * @param id : the index of the token to check
    * @return the address approved to transfer this token
    */
    function getApproved(uint id) public view returns(address) {
        return approved[id];
    }

    /**
    * @param owner : the address to check
    * @return the number of tokens controlled by owner
    */
    function balanceOf(address owner) public view returns (uint) {
        return ownedTokens[owner].length;
    }

    /**
    * @param id : the index of the proposed token
    * @return whether the token is owned by a non-zero address
    */
    function exists(uint id) public view returns (bool) {
        return owners[id] != address(0);
    }

    /**
    * @param to : the address to which the token should be transferred
    * @param id : the index of the token to transfer
    */
    function transferFrom(address from, address to, uint id) public payable {
        
        require(to != address(0));
        require(to != address(this));

        // TODO: why is this necessary
        // if you're approved, why does it matter where it comes from?
        require(ownerOf(id) == from);

        require(isSenderApprovedFor(id));

        require(isTradable(cards[id].proto));

        _transfer(ownerOf(id), to, id);
    }

    /**
    * @param to : the address to which the tokens should be transferred
    * @param ids : the indices of the tokens to transfer
    */
    function transferAllFrom(address to, uint[] ids) public payable {
        for (uint i = 0; i < ids.length; i++) {
            transferFrom(address(0), to, ids[i]);
        }
    }

    /**
     * @return the number of cards which have been burned
     */
    function getBurnCount() public view returns (uint) {
        return burnCount;
    }

    function isApprovedForAll(address owner, address operator) public view returns (bool) {
        return operators[owner][operator];
    }

    function setApprovalForAll(address to, bool toApprove) public {
        require(to != msg.sender);
        operators[msg.sender][to] = toApprove;
        emit ApprovalForAll(msg.sender, to, toApprove);
    }

    bytes4 constant magic = bytes4(keccak256("onERC721Received(address,uint256,bytes)"));

    function safeTransferFrom(address from, address to, uint id, bytes data) public payable {
        require(to != address(0));
        transferFrom(from, to, id);
        if (_isContract(to)) {
            bytes4 response = ERC721TokenReceiver(to).onERC721Received.gas(50000)(from, id, data);
            require(response == magic);
        }
    }

    function safeTransferFrom(address from, address to, uint id) public payable {
        safeTransferFrom(from, to, id, "");
    }

    function _addToken(address to, uint id) private {
        uint pos = ownedTokens[to].push(uint40(id)) - 1;
        indices.push(uint24(pos));
    }

    function _removeToken(address from, uint id) public payable {
        uint24 index = indices[id];
        uint lastIndex = ownedTokens[from].length - 1;
        uint40 lastId = ownedTokens[from][lastIndex];

        ownedTokens[from][index] = lastId;
        ownedTokens[from][lastIndex] = 0;
        ownedTokens[from].length--;
    }

    function isSenderApprovedFor(uint256 id) internal view returns (bool) {
        return owns(msg.sender, id) || getApproved(id) == msg.sender || isApprovedForAll(ownerOf(id), msg.sender);
    }

    function _isContract(address test) internal view returns (bool) {
        uint size; 
        assembly {
            size := extcodesize(test)
        }
        return (size > 0);
    }

    function tokenURI(uint id) public view returns (string) {
        return uris[id];
    }
    
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 _tokenId){
        return ownedTokens[owner][index];
    }

    function tokenByIndex(uint256 index) external view returns (uint256){
        return index;
    }

    function supportsInterface(bytes4 interfaceID) public view returns (bool) {
        return (
            interfaceID == this.supportsInterface.selector || // ERC165
            interfaceID == 0x5b5e139f || // ERC721Metadata
            interfaceID == 0x6466353c || // ERC-721 on 3/7/2018
            interfaceID == 0x780e9d63
        ); // ERC721Enumerable
    }

    function implementsERC721() external pure returns (bool) {
        return true;
    }

    function getOwnedTokens(address user) public view returns (uint40[]) {
        return ownedTokens[user];
    }
    

}

/// @dev Note: the ERC-165 identifier for this interface is 0xf0b9e5ba
interface ERC721TokenReceiver {
    /// @notice Handle the receipt of an NFT
    /// @dev The ERC721 smart contract calls this function on the recipient
    ///  after a `transfer`. This function MAY throw to revert and reject the
    ///  transfer. This function MUST use 50,000 gas or less. Return of other
    ///  than the magic value MUST result in the transaction being reverted.
    ///  Note: the contract address is always the message sender.
    /// @param _from The sending address
    /// @param _tokenId The NFT identifier which is being transfered
    /// @param _data Additional data with no specified format
    /// @return `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
    ///  unless throwing
	function onERC721Received(address _from, uint256 _tokenId, bytes _data) external returns(bytes4);
}



contract CardIntegration is CardOwnership {
    
    CardPack[] packs;

    event CardCreated(uint indexed id, uint16 proto, uint16 purity, address owner);

    function addPack(CardPack approved) public onlyGovernor {
        packs.push(approved);
    }

    modifier onlyApprovedPacks {
        require(_isApprovedPack());
        _;
    }

    function _isApprovedPack() private view returns (bool) {
        for (uint i = 0; i < packs.length; i++) {
            if (msg.sender == address(packs[i])) {
                return true;
            }
        }
        return false;
    }

    function createCard(address owner, uint16 proto, uint16 purity) public whenNotPaused onlyApprovedPacks returns (uint) {
        ProtoCard memory card = protos[proto];
        require(card.season == currentSeason);
        if (card.rarity == Rarity.Mythic) {
            uint64 limit;
            bool exists;
            (limit, exists) = getLimit(proto);
            require(!exists || limit > 0);
            limits[proto].limit--;
        }
        return _createCard(owner, proto, purity);
    }

    function _createCard(address owner, uint16 proto, uint16 purity) internal returns (uint) {
        Card memory card = Card({
            proto: proto,
            purity: purity
        });

        uint id = cards.push(card) - 1;

        _create(owner, id);
        
        emit CardCreated(id, proto, purity, owner);

        return id;
    }

    /*function combineCards(uint[] ids) public whenNotPaused {
        require(ids.length == 5);
        require(ownsAll(msg.sender, ids));
        Card memory first = cards[ids[0]];
        uint16 proto = first.proto;
        uint8 shine = _getShine(first.purity);
        require(shine < shineLimit);
        uint16 puritySum = first.purity - (shine * 1000);
        burn(ids[0]);
        for (uint i = 1; i < ids.length; i++) {
            Card memory next = cards[ids[i]];
            require(next.proto == proto);
            require(_getShine(next.purity) == shine);
            puritySum += (next.purity - (shine * 1000));
            burn(ids[i]);
        }
        uint16 newPurity = uint16(((shine + 1) * 1000) + (puritySum / ids.length));
        _createCard(msg.sender, proto, newPurity);
    }*/


    // PURITY NOTES
    // currently, we only
    // however, to protect rarity, you'll never be abl
    // this is enforced by the restriction in the create-card function
    // no cards above this point can be found in packs

    

}

contract CardPack {

    CardIntegration public integration;
    uint public creationBlock;

    constructor(CardIntegration _integration) public payable {
        integration = _integration;
        creationBlock = block.number;
    }

    event Referral(address indexed referrer, uint value, address purchaser);

    /**
    * purchase 'count' of this type of pack
    */
    function purchase(uint16 packCount, address referrer) public payable;

    // store purity and shine as one number to save users gas
    function _getPurity(uint16 randOne, uint16 randTwo) internal pure returns (uint16) {
        if (randOne >= 998) {
            return 3000 + randTwo;
        } else if (randOne >= 988) {
            return 2000 + randTwo;
        } else if (randOne >= 938) {
            return 1000 + randTwo;
        } else {
            return randTwo;
        }
    }

}

contract Ownable {

   address public owner;

   constructor() public {
       owner = msg.sender;
   }

   function setOwner(address _owner) public onlyOwner {
       owner = _owner;
   }

   modifier onlyOwner {
       require(msg.sender == owner);
       _;
   }

}

contract Vault is Ownable {

   function () public payable {

   }

   function getBalance() public view returns (uint) {
       return address(this).balance;
   }

   function withdraw(uint amount) public onlyOwner {
       require(address(this).balance >= amount);
       owner.transfer(amount);
   }

   function withdrawAll() public onlyOwner {
       withdraw(address(this).balance);
   }
}

contract CappedVault is Vault { 

    uint public limit;
    uint withdrawn = 0;

    constructor() public {
        limit = 33333 ether;
    }

    function () public payable {
        require(total() + msg.value <= limit);
    }

    function total() public view returns(uint) {
        return getBalance() + withdrawn;
    }

    function withdraw(uint amount) public onlyOwner {
        require(address(this).balance >= amount);
        owner.transfer(amount);
        withdrawn += amount;
    }

}


contract Pausable is Ownable {
    
    event Pause();
    event Unpause();

    bool public paused = false;


    /**
    * @dev Modifier to make a function callable only when the contract is not paused.
    */
    modifier whenNotPaused() {
        require(!paused);
        _;
    }

    /**
    * @dev Modifier to make a function callable only when the contract is paused.
    */
    modifier whenPaused() {
        require(paused);
        _;
    }

    /**
    * @dev called by the owner to pause, triggers stopped state
    */
    function pause() onlyOwner whenNotPaused public {
        paused = true;
        emit Pause();
    }

    /**
    * @dev called by the owner to unpause, returns to normal state
    */
    function unpause() onlyOwner whenPaused public {
        paused = false;
        emit Unpause();
    }
}

contract PresalePack is CardPack, Pausable {

    CappedVault public vault;

    Purchase[] purchases;

    struct Purchase {
        uint16 current;
        uint16 count;
        address user;
        uint randomness;
        uint64 commit;
    }

    event PacksPurchased(uint indexed id, address indexed user, uint16 count);
    event PackOpened(uint indexed id, uint16 startIndex, address indexed user, uint[] cardIDs);
    event RandomnessReceived(uint indexed id, address indexed user, uint16 count, uint randomness);

    constructor(CardIntegration integration, CappedVault _vault) public payable CardPack(integration) {
        vault = _vault;
    }

    function basePrice() public returns (uint);
    function getCardDetails(uint16 packIndex, uint8 cardIndex, uint result) public view returns (uint16 proto, uint16 purity);
    
    function packSize() public view returns (uint8) {
        return 5;
    }

    function packsPerClaim() public view returns (uint16) {
        return 15;
    }

    // start in bytes, length in bytes
    function extract(uint num, uint length, uint start) internal pure returns (uint) {
        return (((1 << (length * 8)) - 1) & (num >> ((start * 8) - 1)));
    }

    uint public purchaseCount;
    uint public totalCount;

    function purchase(uint16 packCount, address referrer) whenNotPaused public payable {

        require(packCount > 0);
        require(referrer != msg.sender);

        uint price = calculatePrice(basePrice(), packCount);

        require(msg.value >= price);

        Purchase memory p = Purchase({
            user: msg.sender,
            count: packCount,
            commit: uint64(block.number),
            randomness: 0,
            current: 0
        });

        uint id = purchases.push(p) - 1;

        emit PacksPurchased(id, msg.sender, packCount);

        if (referrer != address(0)) {
            uint commission = price / 10;
            referrer.transfer(commission);
            price -= commission;
            emit Referral(referrer, commission, msg.sender);
        }
        
        address(vault).transfer(price); 
    }

    // can be called by anybody
    function callback(uint id) public {

        Purchase storage p = purchases[id];

        require(p.randomness == 0);

        bytes32 bhash = blockhash(p.commit);

        uint random = uint(keccak256(abi.encodePacked(totalCount, bhash)));

        totalCount += p.count;

        if (uint(bhash) == 0) {
            // should never happen (must call within next 256 blocks)
            // if it does, just give them 1: will become common and therefore less valuable
            // set to 1 rather than 0 to avoid calling claim before randomness
            p.randomness = 1;
        } else {
            p.randomness = random;
        }

        emit RandomnessReceived(id, p.user, p.count, p.randomness);
    }

    

    function claim(uint id) public {
        
        Purchase storage p = purchases[id];

        require(canClaim);

        uint16 proto;
        uint16 purity;
        uint16 count = p.count;
        uint result = p.randomness;
        uint8 size = packSize();

        address user = p.user;
        uint16 current = p.current;

        require(result != 0); // have to wait for the callback
        // require(user == msg.sender); // not needed
        require(count > 0);

        uint[] memory ids = new uint[](size);

        uint16 end = current + packsPerClaim() > count ? count : current + packsPerClaim();

        require(end > current);

        for (uint16 i = current; i < end; i++) {
            for (uint8 j = 0; j < size; j++) {
                (proto, purity) = getCardDetails(i, j, result);
                ids[j] = integration.createCard(user, proto, purity);
            }
            emit PackOpened(id, (i * size), user, ids);
        }
        p.current += (end - current);
    }

    function predictPacks(uint id) external view returns (uint16[] protos, uint16[] purities) {

        Purchase memory p = purchases[id];

        uint16 proto;
        uint16 purity;
        uint16 count = p.count;
        uint result = p.randomness;
        uint8 size = packSize();

        purities = new uint16[](size * count);
        protos = new uint16[](size * count);

        for (uint16 i = 0; i < count; i++) {
            for (uint8 j = 0; j < size; j++) {
                (proto, purity) = getCardDetails(i, j, result);
                purities[(i * size) + j] = purity;
                protos[(i * size) + j] = proto;
            }
        }
        return (protos, purities);
    }

    function calculatePrice(uint base, uint16 packCount) public view returns (uint) {
        // roughly 6k blocks per day
        uint difference = block.number - creationBlock;
        uint numDays = difference / 6000;
        if (20 > numDays) {
            return (base - (((20 - numDays) * base) / 100)) * packCount;
        }
        return base * packCount;
    }

    function _getCommonPlusRarity(uint32 rand) internal pure returns (CardProto.Rarity) {
        if (rand == 999999) {
            return CardProto.Rarity.Mythic;
        } else if (rand >= 998345) {
            return CardProto.Rarity.Legendary;
        } else if (rand >= 986765) {
            return CardProto.Rarity.Epic;
        } else if (rand >= 924890) {
            return CardProto.Rarity.Rare;
        } else {
            return CardProto.Rarity.Common;
        }
    }

    function _getRarePlusRarity(uint32 rand) internal pure returns (CardProto.Rarity) {
        if (rand == 999999) {
            return CardProto.Rarity.Mythic;
        } else if (rand >= 981615) {
            return CardProto.Rarity.Legendary;
        } else if (rand >= 852940) {
            return CardProto.Rarity.Epic;
        } else {
            return CardProto.Rarity.Rare;
        } 
    }

    function _getEpicPlusRarity(uint32 rand) internal pure returns (CardProto.Rarity) {
        if (rand == 999999) {
            return CardProto.Rarity.Mythic;
        } else if (rand >= 981615) {
            return CardProto.Rarity.Legendary;
        } else {
            return CardProto.Rarity.Epic;
        }
    }

    function _getLegendaryPlusRarity(uint32 rand) internal pure returns (CardProto.Rarity) {
        if (rand == 999999) {
            return CardProto.Rarity.Mythic;
        } else {
            return CardProto.Rarity.Legendary;
        } 
    }

    bool public canClaim = true;

    function setCanClaim(bool claim) public onlyOwner {
        canClaim = claim;
    }

    function getComponents(
        uint16 i, uint8 j, uint rand
    ) internal returns (
        uint random, uint32 rarityRandom, uint16 purityOne, uint16 purityTwo, uint16 protoRandom
    ) {
        random = uint(keccak256(abi.encodePacked(i, rand, j)));
        rarityRandom = uint32(extract(random, 4, 10) % 1000000);
        purityOne = uint16(extract(random, 2, 4) % 1000);
        purityTwo = uint16(extract(random, 2, 6) % 1000);
        protoRandom = uint16(extract(random, 2, 8) % (2**16-1));
        return (random, rarityRandom, purityOne, purityTwo, protoRandom);
    }

    function withdraw() public onlyOwner {
        owner.transfer(address(this).balance);
    }

}

contract ERC20 {

    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);
    
    function allowance(address owner, address spender) public view returns (uint256);
    
    function transferFrom(address from, address to, uint256 value) public returns (bool);

    function approve(address spender, uint256 value) public returns (bool);

    function totalSupply() public view returns (uint256);

    function balanceOf(address who) public view returns (uint256);
    
    function transfer(address to, uint256 value) public returns (bool);
    
  
}

pragma solidity 0.4.24;

// from OZ

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
    // Gas optimization: this is cheaper than asserting 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    // uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return a / b;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
    c = a + b;
    assert(c >= a);
    return c;
  }
}

contract TournamentPass is ERC20, Ownable {

    using SafeMath for uint256;

    Vault vault;

    constructor(Vault _vault) public {
        vault = _vault;
    }

    mapping(address => uint256) balances;
    mapping (address => mapping (address => uint256)) internal allowed;
    address[] public minters;
    uint256 supply;
    uint mintLimit = 20000;
    
    function name() public view returns (string){
        return "GU Tournament Passes";
    }

    function symbol() public view returns (string) {
        return "PASS";
    }

    function addMinter(address minter) public onlyOwner {
        minters.push(minter);
    }

    function totalSupply() public view returns (uint256) {
        return supply;
    }

    function transfer(address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);

        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    function balanceOf(address _owner) public view returns (uint256) {
        return balances[_owner];
    }

    function isMinter(address test) internal view returns (bool) {
        for (uint i = 0; i < minters.length; i++) {
            if (minters[i] == test) {
                return true;
            }
        }
        return false;
    }

    function mint(address to, uint amount) public returns (bool) {
        require(isMinter(msg.sender));
        if (amount.add(supply) > mintLimit) {
            return false;
        } 
        supply = supply.add(amount);
        balances[to] = balances[to].add(amount);
        emit Transfer(address(0), to, amount);
        return true;
    }

    function approve(address _spender, uint256 _value) public returns (bool) {
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[_from]);
        require(_value <= allowed[_from][msg.sender]);

        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(_value);
        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
        emit Transfer(_from, _to, _value);
        return true;
    }

    function increaseApproval(address spender, uint256 addedValue) public returns (bool) {
        allowed[msg.sender][spender] = allowed[msg.sender][spender].add(addedValue);
        emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
        return true;
    }

    function decreaseApproval(address spender, uint256 subtractedValue) public returns (bool) {
        uint256 oldValue = allowed[msg.sender][spender];
        if (subtractedValue > oldValue) {
            allowed[msg.sender][spender] = 0;
        } else {
            allowed[msg.sender][spender] = oldValue.sub(subtractedValue);
        }
        emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
        return true;
    }

    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }

    uint public price = 250 finney;

    function purchase(uint amount) public payable {
        
        require(msg.value >= price.mul(amount));
        require(supply.add(amount) <= mintLimit);

        supply = supply.add(amount);
        balances[msg.sender] = balances[msg.sender].add(amount);
        emit Transfer(address(0), msg.sender, amount);

        address(vault).transfer(msg.value);
    }

}

contract LegendaryPack is PresalePack {

    TournamentPass pass;

    constructor(CardIntegration integration, CappedVault _vault, TournamentPass _pass) public payable PresalePack(integration, _vault) {
        pass = _pass;
    }

    function purchase(uint16 packCount, address referrer) public payable {
        super.purchase(packCount, referrer);
        pass.mint(msg.sender, packCount);
    }

    function basePrice() public returns (uint) {
        return 450 finney;
    }

    function getCardDetails(uint16 packIndex, uint8 cardIndex, uint result) public view returns (uint16 proto, uint16 purity) {
        uint random;
        uint32 rarityRandom;
        uint16 protoRandom;
        uint16 purityOne;
        uint16 purityTwo;

        CardProto.Rarity rarity;

        (random, rarityRandom, purityOne, purityTwo, protoRandom) = getComponents(packIndex, cardIndex, result);

        if (cardIndex == 4) {
            rarity = _getLegendaryPlusRarity(rarityRandom);
        } else if (cardIndex == 3) {
            rarity = _getRarePlusRarity(rarityRandom);
        } else {
            rarity = _getCommonPlusRarity(rarityRandom);
        }

        purity = _getPurity(purityOne, purityTwo);
    
        proto = integration.getRandomCard(rarity, protoRandom);

        return (proto, purity);
    } 
    
}

Contract ABI

[{"constant":true,"inputs":[],"name":"packSize","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"creationBlock","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"purchaseCount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalCount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"id","type":"uint256"}],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"packCount","type":"uint16"},{"name":"referrer","type":"address"}],"name":"purchase","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"integration","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"canClaim","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"packsPerClaim","outputs":[{"name":"","type":"uint16"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"packIndex","type":"uint16"},{"name":"cardIndex","type":"uint8"},{"name":"result","type":"uint256"}],"name":"getCardDetails","outputs":[{"name":"proto","type":"uint16"},{"name":"purity","type":"uint16"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"claim","type":"bool"}],"name":"setCanClaim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"basePrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"id","type":"uint256"}],"name":"predictPacks","outputs":[{"name":"protos","type":"uint16[]"},{"name":"purities","type":"uint16[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"base","type":"uint256"},{"name":"packCount","type":"uint16"}],"name":"calculatePrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"vault","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"id","type":"uint256"}],"name":"callback","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"integration","type":"address"},{"name":"_vault","type":"address"},{"name":"_pass","type":"address"}],"payable":true,"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"id","type":"uint256"},{"indexed":true,"name":"user","type":"address"},{"indexed":false,"name":"count","type":"uint16"}],"name":"PacksPurchased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"id","type":"uint256"},{"indexed":false,"name":"startIndex","type":"uint16"},{"indexed":true,"name":"user","type":"address"},{"indexed":false,"name":"cardIDs","type":"uint256[]"}],"name":"PackOpened","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"id","type":"uint256"},{"indexed":true,"name":"user","type":"address"},{"indexed":false,"name":"count","type":"uint16"},{"indexed":false,"name":"randomness","type":"uint256"}],"name":"RandomnessReceived","type":"event"},{"anonymous":false,"inputs":[],"name":"Pause","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpause","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"referrer","type":"address"},{"indexed":false,"name":"value","type":"uint256"},{"indexed":false,"name":"purchaser","type":"address"}],"name":"Referral","type":"event"}]

Contract Creation Code

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000512fbd15bde6570ff09e4438af27ede60402451500000000000000000000000091b9d2835ad914bc1dcfe09bd1816febd04fd68900000000000000000000000022365168c8705e95b2d08876c23a8c13e3ad72e2

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000512fbd15bde6570ff09e4438af27ede604024515
Arg [1] : 00000000000000000000000091b9d2835ad914bc1dcfe09bd1816febd04fd689
Arg [2] : 00000000000000000000000022365168c8705e95b2d08876c23a8c13e3ad72e2

Swarm Source

bzzr://0b7f7fba114e576fd1b98fb2b3504b141d633be2347d85daa7a8483440e93051
Block Age Transaction Difficulty GasUsed Reward
Block Age Uncle Number Difficulty GasUsed Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.