impl Contract {
    const CARDS_PER_PACK: U128 = U128(5);
    const TOTAL_SUPPLY: U128 = U128(25000);
    const NEAR_COST_PER_PACK: u128 = 4*ONE_NEAR;
    #[init]
    pub fn new_default_meta(owner_id: AccountId) -> Self {
      //...
    }

    #[init]
    pub fn new(owner_id: AccountId, metadata: FungibleTokenMetadata) -> Self {
      //...
    }

    #[payable]
    pub fn purchase(&mut self) {
        let buyer_id = env::predecessor_account_id();
        let buyer_deposit = env::attached_deposit();
        let num_packs = buyer_deposit / Self::NEAR_COST_PER_PACK;
        assert!(num_packs > 0, "You must purchase at least 1 pack at {} NEAR per pack.", Self::NEAR_COST_PER_PACK / ONE_NEAR);
        let refund_amount = buyer_deposit % Self::NEAR_COST_PER_PACK;
        let sender_id = env::current_account_id();
        log!("Sending {} packs from {} to {}", num_packs, buyer_id, sender_id);
        let amount: Balance = num_packs.into();
        let memo = format!("Purchase of {} MONSTER ALPHA packs for {} NEAR", num_packs, num_packs * Self::NEAR_COST_PER_PACK / ONE_NEAR);
        log!(memo);
        
        self.token.internal_transfer(&sender_id, &buyer_id, amount, Some(memo));
        log!("Sent {} packs with {} refund", num_packs, refund_amount);
        if refund_amount > 0 {
            Promise::new(buyer_id.clone())
                .transfer(refund_amount);
        }
    }

    #[payable]
    pub fn open_pack(&mut self) {
        let num_packs = U128(1);
        let sender_id = &env::predecessor_account_id();
        let receiver_id = AccountId::new_unchecked("system".into());
        let mint_gas = env::prepaid_gas() - Gas(100000000000000); //TODO

        let memo = "Open pack";
        self.token.internal_transfer(&sender_id, &receiver_id, num_packs.into(), Some(memo.into()));
        let mint_promise = env::promise_create(
            AccountId::new_unchecked(MONSTERS_NFT_CONTRACT.into()),
            "mint_random",
            &serde_json::to_vec(&(Self::CARDS_PER_PACK,sender_id)).unwrap(),
            10000000000000000000000,
            mint_gas,
        );
        env::promise_return(mint_promise)
    }
}

impl Contract {
    #[init]
    pub fn new_default_meta(owner_id: AccountId) -> Self {
      //...
    }

    #[init]
    pub fn new(owner_id: AccountId, metadata: NFTContractMetadata) -> Self {
      //...
    }

    #[payable]
    pub fn mint_random(&mut self, amount: U128, token_owner_id: AccountId) -> Vec<Token> {
        assert_eq!(env::predecessor_account_id(), AccountId::new_unchecked(MONSTERS_ALPHA_CONTRACT.into()), "Unauthorized");
        (0..amount.into()).map(|index| {
            let i = index as usize;
            let roll = random_seed()[i*2] as usize;
            let cards = if roll < 8 {
                get_land_nft_cards()
            } else if roll < 35 {
                get_rare_nft_cards()
            } else if roll < 96 {
                get_uncommon_nft_cards()
            } else {
                get_common_nft_cards()
            };
            let card_index = ((random_seed()[i*2+1] as f64 / 256.0) * ((cards.len()-1) as f64)).round() as usize;
            let card = &cards[card_index];
            let card_count: u64 = match &self.copies_by_card_id {
                Some(copies) => {
                    copies.get(&card.id.to_string()).map_or(1, |count| count + 1)
                },
                None => 1,
            };
            let token_id = get_token_id(card.id, card_count);

            let token_metadata = TokenMetadata {
                title: None,
                description: None,
                media: None,
                media_hash: None,
                copies: None,
                issued_at: Some(get_current_datetime()),
                expires_at: None,
                starts_at: None,
                updated_at: None,
                extra: None,
                reference: None,
                reference_hash: None,
            };

            log!("Creating card with token_id {}", token_id);
            if let Some(copies_count) = &mut self.copies_by_card_id {
                copies_count.insert(&card.id.to_string(), &card_count);
            }
            self.tokens.internal_mint(token_id.into(), token_owner_id.clone(), Some(token_metadata))

        }).collect()
    }

    pub fn full_set_listing(&self) -> Vec<NFTCardTemplate> {
      //...
    }

    fn enrich_token_with_card_data(&self, token: &mut Token) {
      //...
    }

}

#[near_bindgen]
impl NonFungibleTokenCore for Contract {
    #[payable]
    fn nft_transfer(&mut self, receiver_id: AccountId, token_id: TokenId, approval_id: Option<u64>, memo: Option<String>) {
        self.tokens.nft_transfer(receiver_id, token_id, approval_id, memo);
    }

    #[payable]
    fn nft_transfer_call(&mut self, receiver_id: AccountId, token_id: TokenId, approval_id: Option<u64>, memo: Option<String>, msg: String) -> PromiseOrValue<bool> {
        self.tokens.nft_transfer_call(receiver_id, token_id, approval_id, memo, msg)
    }

    fn nft_token(&self, token_id: TokenId) -> Option<Token> {
        let original_token = self.tokens.nft_token(token_id);

        original_token.map(|mut token| {
            self.enrich_token_with_card_data(&mut token);
            token
        })
    }
}

assert_eq!(env::predecessor_account_id(), AccountId::new_unchecked(MONSTERS_ALPHA_CONTRACT.into()), "Unauthorized");

const alphaPacksOwned = Near.view(ftContract, "ft_balance_of", {account_id: context.accountId});
const isOpenDisabled = (alphaPacksOwned === 0);
const nftsOwned = Near.view(nftContract, "nft_supply_for_owner", {account_id: context.accountId});
const nfts = Near.view(nftContract, "nft_tokens_for_owner", {account_id: context.accountId, limit:1000});//{from_index: (nftsOwned-5).toString(), limit:5});

...

const openPack = () => {
  try {
    Near.call(ftContract, 'open_pack', {}, 300000000000000, 10000000000000000000000);
  } catch (e) {
    State.update({error:`Error from NEAR: ${e.message}`});
  }
}

...

NEAR_ENV=mainnet near call monsters-alpha.near storage_deposit '{"account_id": "system"}' --accountId monsters-alpha.near --depositYocto 3000000000000000000000

...
const storageBalance = Near.view(ftContract, "storage_balance_of", {account_id: context.accountId});
const isRegistered = (storageBalance !== null);
...
const register = () => {
  try {
    // Perform smart contract call to buy packs
    Near.call(ftContract, 'storage_deposit', {}, Big("300000000000000"), ONE_NEAR/Big(100));
  } catch (e) {
    State.update({error:`Error from NEAR: ${e.message}`});
  }
}
const handleSubmit = () => {
  try {
    // Perform smart contract call to buy packs
    Near.call(ftContract, 'purchase', {}, Big("300000000000000"), state.packsToBuy*4*ONE_NEAR+300000000000000);
    State.update({error:null});
  } catch (e) {
    State.update({error:`Error from NEAR: ${e.message}`});
  }
};
...