Token Approval

pragma language_version >= 0.23;

import CompactStandardLibrary;

struct UserSecretKey { bytes: Bytes<32>; }
struct UserPublicKey { bytes: Bytes<32>; }
witness getUserSecret(): UserSecretKey;

// Balances
export ledger _balances: Map<UserPublicKey, Uint<128>>;

// Allowances: owner → (spender → amount)
export ledger _allowances: Map<UserPublicKey, Map<UserPublicKey, Uint<128>>>;

export circuit deriveUserPublicKey(sk: UserSecretKey): UserPublicKey {
    return UserPublicKey {
        bytes: persistentHash<Vector<2, Bytes<32>>>([
            pad(32, "myapp:user:v1"),
            sk.bytes
        ])
    };
}

// Approve spender to spend up to `amount` of the caller's tokens
export circuit approve(spender: UserPublicKey, amount: Uint<128>): Boolean {
    const owner = disclose(deriveUserPublicKey(getUserSecret()));
    _approve(owner, spender, amount);
    return true;
}

// Read remaining allowance
export circuit allowance(
    owner: UserPublicKey,
    spender: UserPublicKey
): Uint<128> {
    if (!_allowances.member(disclose(owner))) {
        return 0;
    }
    if (!_allowances.lookup(disclose(owner)).member(disclose(spender))) {
        return 0;
    }
    return _allowances.lookup(disclose(owner)).lookup(disclose(spender));
}

// Internal: write the allowance entry
circuit _approve(
    owner: UserPublicKey,
    spender: UserPublicKey,
    amount: Uint<128>
): [] {
    if (!_allowances.member(disclose(owner))) {
        _allowances.insert(
            disclose(owner),
            default<Map<UserPublicKey, Uint<128>>>
        );
    }
    _allowances.lookup(disclose(owner)).insert(disclose(spender), disclose(amount));
}