[WIP] ERC20 Token Program

x/programs/rust/wasmlanche-sdk/src/state.rs

@@ -173,6 +173,29 @@ impl BorshSerialize for PrefixedBytes<'_> {
     }
 }
 
+pub struct PrefixedMultiBytes<'a>(u8, &'a [&'a [u8]]);
+
+impl<'a> PrefixedMultiBytes<'a> {
+    #[must_use]
+    pub fn new(prefix: u8, bytes: &'a [&'a [u8]]) -> Self {
+        Self(prefix, bytes)
+    }
+}
+
+impl BorshSerialize for PrefixedMultiBytes<'_> {
+    fn serialize<W: std::io::prelude::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        let Self(prefix, bytes) = self;
+
+        let len = 1 + u32::try_from(bytes.iter().map(|byte| (byte.len())).sum::<usize>())
+            .map_err(|_| ErrorKind::InvalidData)?;
+
+        // TODO: just use bytemuck with the enum
+        writer.write_all(&len.to_le_bytes())?;
+        writer.write_all(&[*prefix])?;
+        bytes.iter().try_for_each(|buf| writer.write_all(buf))
+    }
+}
+
 #[derive(BorshSerialize)]
 struct GetAndDeleteArgs<'a> {
     key: PrefixedBytes<'a>,

x/programs/test/programs/simple_token/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "simple_token"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+wasmlanche-sdk = { workspace = true }
+borsh = { workspace = true }
+
+[build-dependencies]
+wasmlanche-sdk = { workspace = true, features = ["build"] }

x/programs/test/programs/simple_token/src/lib.rs

@@ -0,0 +1,178 @@
+use wasmlanche_sdk::Context;
+use wasmlanche_sdk::{public, state_keys, types::Address, Program};
+
+const INITIAL_SUPPLY: u64 = 123456789;
+
+/// The program state keys.
+#[state_keys]
+pub enum StateKey {
+    /// The total supply of the token. Key prefix 0x0.
+    TotalSupply,
+    /// The name of the token. Key prefix 0x1.
+    Name,
+    /// The symbol of the token. Key prefix 0x2.
+    Symbol,
+    /// The balance of the token by address. Key prefix 0x3 + address.
+    Balance(Address),
+
+    Allowance(Address, Address),
+
+    Owner,
+}
+
+pub fn get_owner(program: &Program<StateKey>) -> Address {
+    program
+        .state()
+        .get(StateKey::Owner)
+        .expect("failed to get total supply")
+}
+
+pub fn owner_check(program: &Program<StateKey>, actor: Address) {
+    assert!(
+        get_owner(program) == actor,
+        "caller is required to be owner"
+    )
+}
+
+/// Initializes the program with a name, symbol, and total supply.
+#[public]
+pub fn init(context: Context<StateKey>, name: String, symbol: String, owner: Address) {
+    let Context { program, actor } = context;
+
+    program
+        .state()
+        .store(StateKey::Owner, &actor)
+        .expect("failed to store total supply");
+
+    // set total supply
+    program
+        .state()
+        .store(StateKey::TotalSupply, &INITIAL_SUPPLY)
+        .expect("failed to store total supply");
+
+    // set token name
+    program
+        .state()
+        .store(StateKey::Name, &name)
+        .expect("failed to store coin name");
+
+    // set token symbol
+    program
+        .state()
+        .store(StateKey::Symbol, &symbol)
+        .expect("failed to store symbol");
+}
+
+/// Returns the total supply of the token.
+#[public]
+pub fn total_supply(context: Context<StateKey>) -> u64 {
+    let Context { program, .. } = context;
+    program
+        .state()
+        .get(StateKey::TotalSupply)
+        .unwrap_or_defaul()
+}
+
+/// Transfers balance from the token owner to the recipient.
+#[public]
+pub fn mint(context: Context<StateKey>, recipient: Address, amount: u64) -> bool {
+    let Context { program, actor } = context;
+    owner_check(&program, actor);
+    let balance = program
+        .state()
+        .get::<u64>(StateKey::Balance(recipient))
+        .unwrap_or_default();
+
+    program
+        .state()
+        .store(StateKey::Balance(recipient), &(balance + amount))
+        .expect("failed to store balance");
+
+    true
+}
+
+/// Burn the token from the recipient.
+#[public]
+pub fn burn(context: Context<StateKey>, recipient: Address) -> u64 {
+    let Context { program, actor } = context;
+    owner_check(&program, actor);
+    program
+        .state()
+        .delete::<u64>(StateKey::Balance(recipient))
+        .expect("failed to burn recipient tokens")
+        .expect("recipient balance not found")
+}
+
+/// Gets the balance of the recipient.
+#[public]
+pub fn balance_of(context: Context<StateKey>, account: Address) -> u64 {
+    let Context { program, .. } = context;
+    program
+        .state()
+        .get(StateKey::Balance(account))
+        .unwrap_or_default()
+}
+
+#[public]
+pub fn allowance(context: Context<StateKey>, owner: Address, spender: Address) -> u64 {
+    let Context { program, .. } = context;
+    program
+        .state()
+        .get::<u64>(StateKey::Allowance([owner, spender]))
+        .unwrap_or_default()
+}
+
+#[public]
+pub fn approve(context: Context<StateKey>, spender: Address, amount: u64) -> bool {
+    let Context { program, actor } = context;
+    assert_ne!(actor, spender, "actor and spender must be different");
+    program
+        .state()
+        .store(StateKey::Allowance([actor,spender]), &amount)
+        .expect("failed to store allowance");
+    true
+}
+
+/// Transfers balance from the sender to the the recipient.
+#[public]
+pub fn transfer(context: Context<StateKey>, recipient: Address, amount: u64) -> bool {
+    let Context { program, actor } = context;
+    let sender = actor;
+    assert_ne!(sender, recipient, "sender and recipient must be different");
+
+    // ensure the sender has adequate balance
+    let sender_balance = program
+        .state()
+        .get::<u64>(StateKey::Balance(sender))
+        .expect("failed to update balance");
+
+    assert!(amount >= 0 && sender_balance >= amount, "invalid input");
+
+    let recipient_balance = program
+        .state()
+        .get::<u64>(StateKey::Balance(recipient))
+        .unwrap_or_default();
+
+    // update balances
+    program
+        .state()
+        .store(StateKey::Balance(sender), &(sender_balance - amount))
+        .expect("failed to store balance");
+
+    program
+        .state()
+        .store(StateKey::Balance(recipient), &(recipient_balance + amount))
+        .expect("failed to store balance");
+
+    true
+}
+
+#[public]
+pub fn transfer_from(
+    context: Context<StateKey>,
+    sender: Address,
+    recipient: Address,
+    amount: u64,
+) -> bool {
+    false
+}