ERC-20 Tokens (Go)

This guide shows the core steps to use ULedger’s native ERC-20-style token transactions with the ULedger Go SDK.

ERC-20 tokens are fungible tokens: every unit is interchangeable, like normally understood currency. They’re commonly used for payments, in-app balances, governance/staking tokens, and tokenized assets where “1 unit” is the same as any other unit.

In ULedger, ERC-20-style tokens are supported as native protocol transactions. That means you can manage a token’s lifecycle using standard transaction types such as:

CREATE_TOKEN — define token metadata (name, symbol, decimals) and optionally mint an initial supply
TRANSFER_TOKEN — send tokens between wallets
APPROVE_TOKEN — grant a spender an allowance
TRANSFER_TOKEN (with payload From) — transfer on behalf of an owner using an allowance/approval
BURN_TOKEN — destroy tokens to reduce supply (if burnable)

Because these actions are normal ULedger transactions, token operations inherit ULedger’s core capabilities: wallet-based identity, cryptographic signatures, tamper-evident history, and an auditable trail of token events across the chain.

In the next guides, we’ll cover ULedger’s other native token standards:

ERC-721 (NFTs) — non-fungible tokens where each token has a unique tokenId (collectibles, certificates, unique assets).
ERC-1155 (multi-tokens) — a single contract/address can manage both fungible and non-fungible token IDs, including batch mint/transfer (game items, inventory systems, mixed asset catalogs).

info

Your wallet must be registered on-chain (CREATE_WALLET) before it can submit token transactions. Make sure your wallet is registered.

1) Prerequisites

You need:

A node endpoint (you can use a testnet endpont: https://tn-w-1.uledger.net/)
A blockchainId (Ttestnet: 08c28f29a62819120958984b761ddf8ccb45951612731409873994958fd150a2)
A wallet you can sign with (recommended: load from .ukey)
A basic understanding that:
- Token Address = the TransactionId returned by CREATE_TOKEN

2) Load a wallet

Load from a .ukey file instead of hardcoding keys:

w, err := wallet.LoadFromFile("./wallets/my_wallet.ukey", "")
if err != nil {
  return fmt.Errorf("load wallet: %w", err)
}

3) Create a transaction session

Create a session bound to a node and wallet:

session, err := transaction.NewUL_TransactionSession(nodeEndpoint, w)
if err != nil {
  return fmt.Errorf("create session: %w", err)
}

4) Create an ERC-20 token (CREATE_TOKEN)

4.1 Build the payload

func buildCreateERC20Payload() ([]byte, error) {
  return json.Marshal(transaction.CreateTokenPayload{
    TokenType:     transaction.ERC20_TOKEN_TYPE,
    Name:          "Sotoken",
    Symbol:        "SOTOK",
    Decimals:      18,
    InitialSupply: 1000000000000000000, // 1 token if decimals=18 (in wei-like units)
    Mintable:      true,
    Burnable:      true,
  })
}

4.2 Submit the transaction

payloadBytes, err := buildCreateERC20Payload()
if err != nil {
  return err
}

input := transaction.ULTransactionInput{
  BlockchainId: blockchainId,
  From:         w.Address,
  PayloadType:  transaction.CREATE_TOKEN.String(),
  Payload:      string(payloadBytes),
}

tx, err := session.GenerateTransaction(input)
if err != nil {
  return fmt.Errorf("create token tx: %w", err)
}

tokenAddress := tx.TransactionId // ✅ Save this
fmt.Println("Token address:", tokenAddress)
fmt.Println("Status:", tx.Status, "Output:", tx.Output)

✅ The returned tx.TransactionId is used as the token’s “address” in future calls.

5) Transfer tokens (TRANSFER_TOKEN)

5.1 Build the payload

func buildTransferERC20Payload(tokenAddress, to string, amount uint64) ([]byte, error) {
  return json.Marshal(transaction.TransferTokenPayload{
    TokenAddress: tokenAddress,
    To:           to,
    Amount:       amount,
  })
}

5.2 Submit the transaction

payloadBytes, err := buildTransferERC20Payload(tokenAddress, toAddress, 5000)
if err != nil {
  return err
}

input := transaction.ULTransactionInput{
  BlockchainId: blockchainId,
  From:         w.Address,
  PayloadType:  transaction.TRANSFER_TOKEN.String(),
  Payload:      string(payloadBytes),
}

tx, err := session.GenerateTransaction(input)
if err != nil {
  return fmt.Errorf("transfer tx: %w", err)
}

fmt.Println("Transfer tx:", tx.TransactionId)
fmt.Println("Status:", tx.Status, "Output:", tx.Output)

6) Approve a spender (APPROVE_TOKEN)

Approvals allow a spender to transfer tokens on behalf of the token owner (allowance-style).

6.1 Build the payload

func buildApproveERC20Payload(tokenAddress, spender string, amount uint64) ([]byte, error) {
  return json.Marshal(transaction.ApproveTokenPayload{
    TokenAddress: tokenAddress,
    Spender:      spender,
    Amount:       amount,
  })
}

6.2 Submit the transaction

payloadBytes, err := buildApproveERC20Payload(tokenAddress, spenderAddress, 5000)
if err != nil {
  return err
}

input := transaction.ULTransactionInput{
  BlockchainId: blockchainId,
  From:         w.Address, // token owner
  PayloadType:  transaction.APPROVE_TOKEN.String(),
  Payload:      string(payloadBytes),
}

tx, err := session.GenerateTransaction(input)
if err != nil {
  return fmt.Errorf("approve tx: %w", err)
}

fmt.Println("Approve tx:", tx.TransactionId)
fmt.Println("Status:", tx.Status, "Output:", tx.Output)

7) Transfer using approval (TRANSFER_TOKEN with payload `From`)

This pattern submits a transfer where:

the transaction signer (input.From) is the spender
the payload From is the token owner whose balance is being moved

7.1 Build the payload

func buildTransferApprovalERC20Payload(tokenAddress, to, owner string, amount uint64) ([]byte, error) {
  return json.Marshal(transaction.TransferTokenPayload{
    TokenAddress: tokenAddress,
    To:           to,
    From:         owner,  // owner whose funds will be moved
    Amount:       amount, // amount to spend from allowance
  })
}

7.2 Submit the transaction

payloadBytes, err := buildTransferApprovalERC20Payload(tokenAddress, finalRecipient, ownerAddress, 3000)
if err != nil {
  return err
}

input := transaction.ULTransactionInput{
  BlockchainId: blockchainId,
  From:         spenderWallet.Address, // signer is spender
  PayloadType:  transaction.TRANSFER_TOKEN.String(),
  Payload:      string(payloadBytes),
}

spenderSession, err := transaction.NewUL_TransactionSession(nodeEndpoint, spenderWallet)
if err != nil {
  return err
}

tx, err := spenderSession.GenerateTransaction(input)
if err != nil {
  return fmt.Errorf("transfer_approval tx: %w", err)
}

fmt.Println("Transfer (approval) tx:", tx.TransactionId)
fmt.Println("Status:", tx.Status, "Output:", tx.Output)

8) Burn tokens (BURN_TOKEN)

8.1 Build the payload

func buildBurnERC20Payload(tokenAddress string, amount uint64) ([]byte, error) {
  return json.Marshal(transaction.BurnTokenPayload{
    TokenAddress: tokenAddress,
    Amount:       amount,
  })
}

8.2 Submit the transaction

payloadBytes, err := buildBurnERC20Payload(tokenAddress, 5000)
if err != nil {
  return err
}

input := transaction.ULTransactionInput{
  BlockchainId: blockchainId,
  From:         w.Address,
  PayloadType:  transaction.BURN_TOKEN.String(),
  Payload:      string(payloadBytes),
}

tx, err := session.GenerateTransaction(input)
if err != nil {
  return fmt.Errorf("burn tx: %w", err)
}

fmt.Println("Burn tx:", tx.TransactionId)
fmt.Println("Status:", tx.Status, "Output:", tx.Output)

9) Full example

This single example shows:

Create token
Transfer
Approve
Transfer using approval
Burn

package main

import (
  "encoding/json"
  "fmt"

  "github.com/ULedgerInc/go-sdk/pkg/crypto"
  "github.com/ULedgerInc/go-sdk/pkg/transaction"
  "github.com/ULedgerInc/go-sdk/pkg/wallet"
)

func main() {
  nodeEndpoint := "https://tn-w-1.uledger.net/"
  blockchainId := "08c28f29a62819120958984b761ddf8ccb45951612731409873994958fd150a2"

  // Load two wallets (owner + spender) for demonstration
  ownerWallet, err := wallet.LoadFromFile("./wallets/owner.ukey", "")
  if err != nil { panic(err) }

  spenderWallet, err := wallet.LoadFromFile("./wallets/spender.ukey", "")
  if err != nil { panic(err) }

  ownerSession, err := transaction.NewUL_TransactionSession(nodeEndpoint, ownerWallet)
  if err != nil { panic(err) }

  // 1) CREATE_TOKEN
  createPayload, err := json.Marshal(transaction.CreateTokenPayload{
    TokenType:     transaction.ERC20_TOKEN_TYPE,
    Name:          "Sotoken",
    Symbol:        "SOTOK",
    Decimals:      18,
    InitialSupply: 1000000000000000000,
    Mintable:      true,
    Burnable:      true,
  })
  if err != nil { panic(err) }

  createTx, err := ownerSession.GenerateTransaction(transaction.ULTransactionInput{
    BlockchainId: blockchainId,
    From:         ownerWallet.Address,
    PayloadType:  transaction.CREATE_TOKEN.String(),
    Payload:      string(createPayload),
    KeyType:      crypto.KeyTypeSecp256k1,
  })
  if err != nil { panic(err) }

  tokenAddress := createTx.TransactionId
  fmt.Println("Token address:", tokenAddress)

  // 2) TRANSFER_TOKEN (owner -> someone)
  transferPayload, _ := json.Marshal(transaction.TransferTokenPayload{
    TokenAddress: tokenAddress,
    To:           spenderWallet.Address,
    Amount:       5000,
  })
  transferTx, err := ownerSession.GenerateTransaction(transaction.ULTransactionInput{
    BlockchainId: blockchainId,
    From:         ownerWallet.Address,
    PayloadType:  transaction.TRANSFER_TOKEN.String(),
    Payload:      string(transferPayload),
  })
  if err != nil { panic(err) }
  fmt.Println("Transfer tx:", transferTx.TransactionId)

  // 3) APPROVE_TOKEN (owner approves spender)
  approvePayload, _ := json.Marshal(transaction.ApproveTokenPayload{
    TokenAddress: tokenAddress,
    Spender:      spenderWallet.Address,
    Amount:       5000,
  })
  approveTx, err := ownerSession.GenerateTransaction(transaction.ULTransactionInput{
    BlockchainId: blockchainId,
    From:         ownerWallet.Address,
    PayloadType:  transaction.APPROVE_TOKEN.String(),
    Payload:      string(approvePayload),
  })
  if err != nil { panic(err) }
  fmt.Println("Approve tx:", approveTx.TransactionId)

  // 4) TRANSFER_TOKEN using approval (spender spends owner's allowance)
  spenderSession, err := transaction.NewUL_TransactionSession(nodeEndpoint, spenderWallet)
  if err != nil { panic(err) }

  transferApprovalPayload, _ := json.Marshal(transaction.TransferTokenPayload{
    TokenAddress: tokenAddress,
    From:         ownerWallet.Address,     // owner
    To:           "DESTINATION_ADDRESS",   // replace
    Amount:       3000,
  })

  transferApprovalTx, err := spenderSession.GenerateTransaction(transaction.ULTransactionInput{
    BlockchainId: blockchainId,
    From:         spenderWallet.Address, // signer = spender
    PayloadType:  transaction.TRANSFER_TOKEN.String(),
    Payload:      string(transferApprovalPayload),
  })
  if err != nil { panic(err) }
  fmt.Println("Transfer (approval) tx:", transferApprovalTx.TransactionId)

  // 5) BURN_TOKEN
  burnPayload, _ := json.Marshal(transaction.BurnTokenPayload{
    TokenAddress: tokenAddress,
    Amount:       1000,
  })

  burnTx, err := ownerSession.GenerateTransaction(transaction.ULTransactionInput{
    BlockchainId: blockchainId,
    From:         ownerWallet.Address,
    PayloadType:  transaction.BURN_TOKEN.String(),
    Payload:      string(burnPayload),
  })
  if err != nil { panic(err) }
  fmt.Println("Burn tx:", burnTx.TransactionId)
}

Next steps

Create an ERC-721 guide (NFT mint/transfer/approve patterns)
Create an ERC-1155 guide (multi-token + batch transfer patterns)

1) Prerequisites​

2) Load a wallet​

3) Create a transaction session​

4) Create an ERC-20 token (CREATE_TOKEN)​

4.1 Build the payload​

4.2 Submit the transaction​

5) Transfer tokens (TRANSFER_TOKEN)​

5.1 Build the payload​

5.2 Submit the transaction​

6) Approve a spender (APPROVE_TOKEN)​

6.1 Build the payload​

6.2 Submit the transaction​

7) Transfer using approval (TRANSFER_TOKEN with payload From)​

7.1 Build the payload​

7.2 Submit the transaction​

8) Burn tokens (BURN_TOKEN)​

8.1 Build the payload​

8.2 Submit the transaction​

9) Full example​

Next steps​