tonb/sources/jetton_trait.tact

import "@stdlib/ownable";
import "./wallet";
import "./linker";


@interface("org.ton.jetton.master")
trait TONBTrait with Ownable {

    //
    // Storage
    //

    totalSupply: Int;
    mintable: Bool;
    owner: Address;
    content: Cell?;
    first_linker: Address?;
    last_linker: Address?;
    n_linkers: Int = 0;


    //
    // Receivers
    //

    receive(msg: TokenUpdateContent) {

        // Allow changing content only by owner
        self.requireOwner();
        
        // Update content
        self.content = msg.content;
    }

    receive(msg: TokenBurnNotification) {
        
        // Check wallet
        self.requireWallet(msg.owner);

        // Update supply
        self.totalSupply = self.totalSupply - msg.amount;

        // Cashback
        if (msg.responseAddress != null) {
            send(SendParameters{
                to: msg.responseAddress!!, 
                value: 0,
                bounce: false,
                mode: SendRemainingValue + SendIgnoreErrors,
                body: TokenExcesses{
                    queryId: msg.queryId
                }.toCell()
            });
        }
    }


    //
    // Get Methods
    //

    get fun get_wallet_address(owner: Address): Address {
        let winit: StateInit = self.getJettonWalletInit(owner);
        return contractAddress(winit);
    }

    get fun get_jetton_data(): JettonData {
        let code: Cell = self.getJettonWalletInit(myAddress()).code;
        return JettonData{ 
            totalSupply: self.totalSupply, 
            mintable: self.mintable, 
            owner: self.owner, 
            content: self.content, 
            walletCode: code
        };
    }

    //
    // Private Methods
    //

    fun mint(to: Address, amount: Int, responseAddress: Address?) {

        // Update total supply
        self.totalSupply = self.totalSupply + amount;

        // Create message
        let winit: StateInit = self.getJettonWalletInit(to);
        let walletAddress: Address = contractAddress(winit);
        // let linker_init: StateInit = initOf Linker(self.n_linkers, walletAddress);
        // let linker_address: Address = contractAddress(linker_init);
        // send(SendParameters{
        //     to: linker_address, 
        //     value: 0, 
        //     bounce: false,
        //     body: SetLinkerNeighbor{ 
        //         neighbor: self.last_linker
        //     }.toCell(),
        //     code: linker_init.code,
        //     data: linker_init.data
        // });
        send(SendParameters{
            to: walletAddress, 
            value: ton("0.2"), 
            bounce: false,
            body: TokenTransferInternal{ 
                amount: amount,
                queryId: 0,
                from: myAddress(),
                responseAddress: responseAddress,
                forwardTonAmount: 0,
                forwardPayload: emptySlice()
            }.toCell(),
            code: winit.code,
            data: winit.data
        });
        
    }

    fun burn(from: Address, amount: Int, responseAddress: Address?) {

        // Create message
        let winit: StateInit = self.getJettonWalletInit(from);
        let walletAddress: Address = contractAddress(winit);
        send(SendParameters{
            to: walletAddress, 
            value: 0, 
            bounce: false,
            mode: SendRemainingValue,
            body: TokenBurn{
                amount: amount,
                queryId: 0,
                responseAddress: responseAddress,
                owner: from
            }.toCell(),
            code: winit.code,
            data: winit.data
        });
    }

    fun requireWallet(owner: Address) {
        let ctx: Context = context();
        let winit: StateInit = self.getJettonWalletInit(owner);
        require(contractAddress(winit) == ctx.sender, "Invalid sender");
    }

    virtual fun getJettonWalletInit(address: Address): StateInit {
        return initOf TONBWallet(myAddress(), address);
    }
}