# TokenFactory Core (middleware)

![crates.io](https://img.shields.io/crates/v/juno-tokenfactory-core.svg)

This is a contract to which you give the admin of your token denomination(s) from the TokenFactory module. Once this contract has that, it allows other contracts you/your DAO controls to mint tokens for your business logic needs (via a WasmMsg).

This makes it more flexible since multiple contracts can "mint" tokens on behalf of the contract admin :D

## Example Use Case

$RAC has slots & dice contracts. If every game they want to mint 1 RAC for you for playing, both slots and dice would need to be admin of the token-factory token to mint
With this core contract, a single contract is an admin, then the DAO can whitelist both the dice and slots address to mint tokens on its behalf.

This way to mint $RAC natively, the dice contract would WasmMsg a mint to the core contract, to then give the user that token.

---

## Rust Dependency

Add the following to your `Cargo.toml` dependencies for a contract. Then view the Mint section of this document for how to implement it.

```toml
[dependencies]
juno-tokenfactory-types = { git = "https://github.com/CosmosContracts/tokenfactory-contracts" }
```

or from crates.io - <https://crates.io/crates/juno-tokenfactory-core>

You can view an example of how to use this in the [example contract](https://github.com/CosmosContracts/tokenfactory-contracts/tree/main/contracts/tf_example/src) or see the [e2e test](https://github.com/CosmosContracts/tokenfactory-contracts/blob/main/e2e/core/test_e2e.sh) for a full example in bash.

---

## Chain Setup

Mainnet Store Code: TBD

```sh
# for uni-6 TESTNET
# update [key] here to be your local wallet's key or your wallet's address
FLAGS="--gas-prices 0.003ujuno --gas auto --gas-adjustment 1.3 --chain-id uni-6 --node https://juno-testnet-rpc.polkachu.com:443 --output json --from [key]"

# create a tokenfactory denomination via the CLI.
junod tx tokenfactory create-denom abcde $FLAGS
# factory/juno1......./abcde is your new denom


# upload this contract (skip if you use the mainnet code)
# junod tx wasm store artifacts/juno_tokenfactory_core.wasm $FLAGS

# Initialize this contract
# You may want to set this as a normal admin initially before changing its admin to a DAO
junod tx wasm instantiate "###" {"allowed_mint_addresses":[],"denoms":["factory/juno1./abcde"]} --label "tf-middlware" --admin [key] $FLAGS
# Get the middleware contract address here

# Transfer ownership of the token to the contract
junod tx tokenfactory change-admin factory/juno1./abcde juno1middlewarecontract $FLAGS

# Ensure the juno1middlewarecontract now has the admin role
junod q tokenfactory denom-authority-metadata factory/juno1./abcde
```

## How To Contract Mint

You can then mint tokens via another contract using the following example

```rust
// msg.rs - mint on behalf of the core_factory_address
#[cw_serde]
pub enum ExecuteMsg {
    MintTokens {
        // You could save this in state.rs on initialize.
        core_tf_middleware_contract: String,
        denoms: Vec<Coin>,
        to_address: String,
    },
}

// contract.rs - execute

// Ensure you added the tokenfactory-types dependency
use juno::juno_tokenfactory_types::msg::ExecuteMsg::Mint;

ExecuteMsg::MintTokens {
    core_tf_middleware_contract,
    denoms,
    to_address,
} => {
    let payload = Mint {
        address: to_address,
        denom: denoms,
    };
    let wasm_msg = WasmMsg::Execute {
        contract_addr: core_tf_middleware_contract.to_string(),
        msg: to_binary(&payload)?,
        funds: vec![],
    };

    Ok(Response::new()
        .add_attribute("method", "execute_mint_tokens_from_other_contract")
        .add_message(wasm_msg))
}
```