TIP-20 Token Standard

event TransferWithMemo(
    address indexed from,
    address indexed to,
    uint256 amount,
    bytes32 indexed memo
);

// Create a policy once
ITIP403Registry registry = ITIP403Registry(POLICY_REGISTRY_ADDRESS);
uint256 policyId = registry.createPolicy(transferHooksAddress);

// Apply to multiple tokens
token1.setPolicyId(policyId);
token2.setPolicyId(policyId);
token3.setPolicyId(policyId);

// Update policy once, enforced everywhere
registry.updatePolicy(policyId, newTransferHooksAddress);

import { ITIP20Factory } from '@tempo/contracts';

const factory = ITIP20Factory.connect(TIP20_FACTORY_ADDRESS, signer);

const tx = await factory.createToken(
  'AlphaUSD',           // name
  'AUSD',               // symbol
  6,                    // decimals
  ownerAddress,         // owner
  parseUnits('1000000', 6), // initial supply
  0,                    // policy ID (0 = no policy)
  ethers.ZeroAddress    // quote token (for DEX)
);

const receipt = await tx.wait();
const tokenAddress = receipt.logs[0].address; // TIP-20 address

// Grant roles
token.grantRole(MINTER_ROLE, minterAddress);
token.grantRole(BURNER_ROLE, burnerAddress);

// Revoke roles
token.revokeRole(MINTER_ROLE, minterAddress);

import { signTypedData } from 'viem';

const domain = {
  name: await token.name(),
  version: '1',
  chainId: TEMPO_CHAIN_ID,
  verifyingContract: tokenAddress,
};

const types = {
  Permit: [
    { name: 'owner', type: 'address' },
    { name: 'spender', type: 'address' },
    { name: 'value', type: 'uint256' },
    { name: 'nonce', type: 'uint256' },
    { name: 'deadline', type: 'uint256' },
  ],
};

const value = {
  owner: ownerAddress,
  spender: spenderAddress,
  value: parseUnits('1000', 6),
  nonce: await token.nonces(ownerAddress),
  deadline: Math.floor(Date.now() / 1000) + 3600, // 1 hour
};

const signature = await signTypedData({ domain, types, value });
const { v, r, s } = signature;

// Spender can now execute permit + transfer atomically
await token.permit(owner, spender, value.value, value.deadline, v, r, s);
await token.transferFrom(owner, recipient, value.value);

// Validators earn rewards from TIP-20 activity
function setRewardRecipient(address recipient) external {
    // Direct rewards to another address (e.g., staking pool)
}

function claimRewards() external {
    // Claim accumulated rewards from TIP-20 transfers
}

// Set quote token to create DEX pair
await token.setQuoteToken(usdcAddress);

// Initiates quote token update (48-hour delay)
await token.setNextQuoteToken(usdtAddress);

// Complete update after delay
await token.completeQuoteTokenUpdate();

interface ITransferPolicy {
    function beforeTransfer(
        address token,
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
    
    function afterTransfer(
        address token,
        address from,
        address to,
        uint256 amount
    ) external;
}

// Pause all transfers
await token.pause();

// Approvals still work (non-value-moving)
await token.approve(spender, amount); // ✅ Allowed

// Transfers revert
await token.transfer(recipient, amount); // ❌ Reverts

// Resume transfers
await token.unpause();

import { ITIP20 } from '@tempo/contracts';

const token = ITIP20.connect(tokenAddress, provider);

const name = await token.name();
const symbol = await token.symbol();
const decimals = await token.decimals();
const totalSupply = await token.totalSupply();
const balance = await token.balanceOf(userAddress);

// Standard ERC-20 Transfer event
token.on('Transfer', (from, to, amount, event) => {
  console.log(`${formatUnits(amount, 6)} transferred from ${from} to ${to}`);
});

// TIP-20 TransferWithMemo event
token.on('TransferWithMemo', (from, to, amount, memo, event) => {
  const memoString = ethers.toUtf8String(memo).replace(/\0/g, '');
  console.log(`Transfer memo: ${memoString}`);
});

// Standard ERC-20 approve/transferFrom flow
await token.connect(owner).approve(spender, parseUnits('1000', 6));

// Spender executes transfer
await token.connect(spender).transferFrom(
  owner,
  recipient,
  parseUnits('500', 6)
);

// Check remaining allowance
const remaining = await token.allowance(owner, spender);