Use Issued Assets in Smart Contracts with the Stellar Asset Contract (SAC)

pub trait StellarAssetInterface {
    // All this is available in any SEP-41-compliant contract
    fn allowance(env: Env, from: Address, spender: Address) -> i128;
    fn approve(env: Env, from: Address, spender: Address, amount: i128, live_until_ledger: u32);
    fn balance(env: Env, id: Address) -> i128;
    fn transfer(env: Env, from: Address, to: MuxedAddress, amount: i128);
    fn transfer_from(env: Env, spender: Address, from: Address, to: Address, amount: i128);
    fn burn(env: Env, from: Address, amount: i128);
    fn burn_from(env: Env, spender: Address, from: Address, amount: i128);
    fn decimals(env: Env) -> u32;
    fn name(env: Env) -> String;
    fn symbol(env: Env) -> String;

    //! Everything below is specifically available to SAC instances

    /// Sets the administrator to the specified address `new_admin`.
    ///
    /// # Arguments
    ///
    /// * `new_admin` - The address which will henceforth be the administrator
    ///   of this token contract.
    ///
    /// # Events
    ///
    /// Emits an event with topics `["set_admin", admin: Address,
    /// sep0011_asset: String], data = new_admin: Address`
    fn set_admin(env: Env, new_admin: Address);

    /// Returns the admin of the contract.
    ///
    /// # Panics
    ///
    /// If the admin is not set.
    fn admin(env: Env) -> Address;

    /// Sets whether the account is authorized to use its balance. If
    /// `authorized` is true, `id` should be able to use its balance.
    ///
    /// # Arguments
    ///
    /// * `id` - The address being (de-)authorized.
    /// * `authorize` - Whether or not `id` can use its balance.
    ///
    /// # Events
    ///
    /// Emits an event with topics `["set_authorized", id: Address,
    /// sep0011_asset: String], data = authorize: bool`
    fn set_authorized(env: Env, id: Address, authorize: bool);

    /// Returns true if `id` is authorized to use its balance.
    ///
    /// # Arguments
    ///
    /// * `id` - The address for which token authorization is being checked.
    fn authorized(env: Env, id: Address) -> bool;

    /// Mints `amount` to `to`.
    ///
    /// # Arguments
    ///
    /// * `to` - The address which will receive the minted tokens.
    /// * `amount` - The amount of tokens to be minted.
    ///
    /// # Events
    ///
    /// Emits an event with topics `["mint", to: Address,
    /// sep0011_asset: String], data = amount: i128`
    fn mint(env: Env, to: Address, amount: i128);

    /// Clawback `amount` from `from` account. `amount` is burned in the
    /// clawback process.
    ///
    /// # Arguments
    ///
    /// * `from` - The address holding the balance from which the clawback will
    ///   take tokens.
    /// * `amount` - The amount of tokens to be clawed back.
    ///
    /// # Events
    ///
    /// Emits an event with topics `["clawback", from: Address,
    /// sep0011_asset: String], data = amount: i128`
    fn clawback(env: Env, from: Address, amount: i128);

    /// Creates this contract asset's unlimited trustline for the provided
    /// address.
    ///
    /// This is a no-op if the input address is a C-address, or if the
    /// provided G-address already has the respective trustline.
    ///
    /// If the trustline is actually created, this will require authorization
    /// from `addr` (i.e. `addr.require_auth()` will be called).
    ///
    /// # Arguments
    ///
    /// * `addr` - The address for which a trustline will be created.
    ///
    /// # Panics
    ///
    /// If the asset issuer does not exist, or if a new trustline cannot be
    /// created.
    fn trust(env: Env, addr: Address);
}

#[derive(Debug, FromPrimitive, PartialEq, Eq)]
pub(crate) enum ContractError {
    // Indicates an internal error in protocol implementation, such as invalid
    // ledger state. This may not happen in the real networks, but might appear
    // when using malformed test data (such as malformed ledger snapshots).
    InternalError = 1,
    // Indicates an impossible function has been invoked, such as clawback for
    // an asset that does not have clawback enabled. Or, an operation has been
    // called affecting the issuer's trustline.
    OperationNotSupportedError = 2,
    // Indicates the SAC has already been initialized. This error may only occur
    // during initialization of an asset's SAC instance.
    AlreadyInitializedError = 3,
    // Unused = 4, - this error code is not used by SAC
    // Unused = 5, - this error code is not used by SAC
    // An account that would be modified by this transaction does not exist on
    // the network.
    AccountMissingError = 6,
    // Unused = 7, - this error code is not used by SAC
    // Indicates an amount less than zero was provided for a transfer amount.
    NegativeAmountError = 8,
    // Indicates an insufficient spender's available allowance amount. Also used
    // to indicate a problem with expiration ledger when creating an allowance.
    AllowanceError = 9,
    // Indicates too low of a balance to spend the requested amount, or a
    // balance as a result of this transaction would be too low or high, or a
    // problem with attempting a clawback on a non-clawback-enabled trustline.
    BalanceError = 10,
    // Indicates an address has had its balance authorization revoked by the
    // asset issuer.
    BalanceDeauthorizedError = 11,
    // Indicates this transaction would result in a spender's allowance
    // overflowing.
    OverflowError = 12,
    // Indicates a trustline entry does not exist for this address to hold this
    // asset.
    TrustlineMissingError = 13,
}