diff --git a/src/pages/guide/machine-payments/index.mdx b/src/pages/guide/machine-payments/index.mdx index f97842c8..e9b89a10 100644 --- a/src/pages/guide/machine-payments/index.mdx +++ b/src/pages/guide/machine-payments/index.mdx @@ -13,7 +13,7 @@ The [Machine Payments Protocol](https://mpp.dev) (MPP) adds inline payments to a ## Try it out -See the full payment flow in action. The terminal creates an ephemeral wallet, funds it with testnet USDC, and makes a paid request to fetch a photo. +See the full payment flow in action. The terminal creates an ephemeral wallet, funds it with testnet USDG, and makes a paid request to fetch a photo.
diff --git a/src/pages/guide/payments/accept-a-payment.mdx b/src/pages/guide/payments/accept-a-payment.mdx index eb5e974b..edea9b71 100644 --- a/src/pages/guide/payments/accept-a-payment.mdx +++ b/src/pages/guide/payments/accept-a-payment.mdx @@ -601,10 +601,10 @@ contract PaymentReceiver { If you need to accept payments in a specific stablecoin but receive a different one, use the exchange to swap: ```ts -// User sends USDC, but you need USDT -// Swap USDC to USDT using the exchange +// User sends USDG, but you need USDT +// Swap USDG to USDT using the exchange const { receipt } = await client.dex.sellSync({ - tokenIn: usdcAddress, + tokenIn: usdgAddress, tokenOut: usdtAddress, amountIn: receivedAmount, minAmountOut: receivedAmount * 99n / 100n, // 1% slippage diff --git a/src/pages/protocol/exchange/exchange-balance.mdx b/src/pages/protocol/exchange/exchange-balance.mdx index 9faeee67..10118b51 100644 --- a/src/pages/protocol/exchange/exchange-balance.mdx +++ b/src/pages/protocol/exchange/exchange-balance.mdx @@ -27,7 +27,7 @@ function balanceOf( **Example:** ```solidity -uint128 balance = exchange.balanceOf(msg.sender, USDC_ADDRESS); +uint128 balance = exchange.balanceOf(msg.sender, USDG_ADDRESS); ``` ## Using Your DEX Balance @@ -58,8 +58,8 @@ function withdraw( **Example:** ```solidity -// Withdraw 1000 USDC from exchange to your wallet -exchange.withdraw(USDC_ADDRESS, 1000e6); +// Withdraw 1000 USDG from exchange to your wallet +exchange.withdraw(USDG_ADDRESS, 1000e6); ``` :::warning diff --git a/src/pages/protocol/exchange/executing-swaps.mdx b/src/pages/protocol/exchange/executing-swaps.mdx index f9ded508..2d48fa54 100644 --- a/src/pages/protocol/exchange/executing-swaps.mdx +++ b/src/pages/protocol/exchange/executing-swaps.mdx @@ -30,12 +30,12 @@ function swapExactAmountIn( **Returns:** - `amountOut` - The actual amount of `tokenOut` received -**Example:** Swap exactly 1000 USDC for at least 998 USDT: +**Example:** Swap exactly 1000 USDG for at least 998 USDT: ```solidity uint128 amountOut = exchange.swapExactAmountIn( - USDC_ADDRESS, + USDG_ADDRESS, USDT_ADDRESS, - 1000e6, // Sell exactly 1000 USDC + 1000e6, // Sell exactly 1000 USDG 998e6 // Receive at least 998 USDT ); ``` @@ -62,13 +62,13 @@ function swapExactAmountOut( **Returns:** - `amountIn` - The actual amount of `tokenIn` spent -**Example:** Receive exactly 1000 USDT by spending at most 1002 USDC: +**Example:** Receive exactly 1000 USDT by spending at most 1002 USDG: ```solidity uint128 amountIn = exchange.swapExactAmountOut( - USDC_ADDRESS, + USDG_ADDRESS, USDT_ADDRESS, 1000e6, // Receive exactly 1000 USDT - 1002e6 // Pay at most 1002 USDC + 1002e6 // Pay at most 1002 USDG ); ``` @@ -102,16 +102,16 @@ Returns how much `tokenIn` you would need to spend to receive a given `amountOut **Example: Getting a price quote** ```solidity -// Check how much USDT you'd get for 1000 USDC +// Check how much USDT you'd get for 1000 USDG uint128 expectedOut = exchange.quoteSwapExactAmountIn( - USDC_ADDRESS, + USDG_ADDRESS, USDT_ADDRESS, 1000e6 ); // Only execute if the price is acceptable if (expectedOut >= 998e6) { - exchange.swapExactAmountIn(USDC_ADDRESS, USDT_ADDRESS, 1000e6, 998e6); + exchange.swapExactAmountIn(USDG_ADDRESS, USDT_ADDRESS, 1000e6, 998e6); } ``` diff --git a/src/pages/protocol/exchange/index.mdx b/src/pages/protocol/exchange/index.mdx index aa48036a..b817eb76 100644 --- a/src/pages/protocol/exchange/index.mdx +++ b/src/pages/protocol/exchange/index.mdx @@ -6,7 +6,7 @@ import { Cards, Card } from 'vocs' # Exchanging Stablecoins -Tempo features an enshrined decentralized exchange (DEX) designed specifically for trading between stablecoins of the same underlying asset (e.g., USDC to USDT). The exchange provides optimal pricing for cross-stablecoin payments while minimizing chain load from excessive market activity. +Tempo features an enshrined decentralized exchange (DEX) designed specifically for trading between stablecoins of the same underlying asset (e.g., USDG to USDT). The exchange provides optimal pricing for cross-stablecoin payments while minimizing chain load from excessive market activity. The exchange operates as a singleton precompiled contract at address `0xdec0000000000000000000000000000000000000`. It maintains an orderbook with separate queues for each price tick, using price-time priority for order matching. diff --git a/src/pages/protocol/exchange/providing-liquidity.mdx b/src/pages/protocol/exchange/providing-liquidity.mdx index 27b44f6a..6b95db1a 100644 --- a/src/pages/protocol/exchange/providing-liquidity.mdx +++ b/src/pages/protocol/exchange/providing-liquidity.mdx @@ -40,24 +40,24 @@ function place( **Returns:** - `orderId` - Unique identifier for this order -**Example: Place a bid to buy 1000 USDC at $0.9990** +**Example: Place a bid to buy 1000 USDG at $0.9990** ```solidity // tick = (0.9990 - 1) * 100_000 = -10 uint128 orderId = exchange.place( - USDC_ADDRESS, - 1000e6, // Amount: 1000 USDC - true, // isBid: buying USDC + USDG_ADDRESS, + 1000e6, // Amount: 1000 USDG + true, // isBid: buying USDG -10 // tick: price = $0.9990 ); ``` -**Example: Place an ask to sell 1000 USDC at $1.0010** +**Example: Place an ask to sell 1000 USDG at $1.0010** ```solidity // tick = (1.0010 - 1) * 100_000 = 10 uint128 orderId = exchange.place( - USDC_ADDRESS, - 1000e6, // Amount: 1000 USDC - false, // isBid: selling USDC + USDG_ADDRESS, + 1000e6, // Amount: 1000 USDG + false, // isBid: selling USDG 10 // tick: price = $1.0010 ); ``` @@ -89,8 +89,8 @@ function placeFlip( ```solidity // Place a bid at $0.9990 that flips to an ask at $1.0010 uint128 orderId = exchange.placeFlip( - USDC_ADDRESS, - 1000e6, // Amount: 1000 USDC + USDG_ADDRESS, + 1000e6, // Amount: 1000 USDG true, // isBid: start as a buy order -10, // tick: buy at $0.9990 10 // flipTick: sell at $1.0010 after filled @@ -98,8 +98,8 @@ uint128 orderId = exchange.placeFlip( ``` When this order is completely filled: -1. You buy 1000 USDC at $0.9990 -2. A new order automatically sells 1000 USDC at $1.0010 +1. You buy 1000 USDG at $0.9990 +2. A new order automatically sells 1000 USDG at $1.0010 3. When that fills, it flips back to a bid at $0.9990 4. This continues indefinitely, earning the spread each time @@ -136,9 +136,9 @@ Price ticks are limited to ±2% from peg (±2000 ticks). Orders outside this ran - **Bid (isBid = true)**: An order to *buy* the token using its quote token - **Ask (isBid = false)**: An order to *sell* the token for its quote token -For a USDC/USD pair where USD is the quote: -- A bid buys USDC with USD at your specified price -- An ask sells USDC for USD at your specified price +For a USDG/USD pair where USD is the quote: +- A bid buys USDG with USD at your specified price +- An ask sells USDG for USD at your specified price ## Order Execution Timeline diff --git a/src/pages/protocol/fees/spec-fee.mdx b/src/pages/protocol/fees/spec-fee.mdx index a3f09dd9..4456c014 100644 --- a/src/pages/protocol/fees/spec-fee.mdx +++ b/src/pages/protocol/fees/spec-fee.mdx @@ -243,7 +243,7 @@ validatorTokenOut = userTokenIn × 0.9970 ``` This means: -- User pays 1.0 USDC for fees +- User pays 1.0 USDG for fees - Validator receives 0.9970 USDT (if that's their preferred token) - The 0.003 (0.3%) difference goes to liquidity providers as a fee @@ -251,13 +251,13 @@ This means: Here's a complete example of the fee lifecycle: -1. **Alice** wants to send a transaction and pays fees in **USDC** (her preferred token) +1. **Alice** wants to send a transaction and pays fees in **USDG** (her preferred token) 2. **Validator** prefers to receive fees in **USDT** -3. Alice's transaction has a max fee of 1.0 USDC -4. The FeeManager collects 1.0 USDC from Alice before execution -5. Transaction executes and uses 0.8 USDC worth of gas -6. The FeeManager refunds 0.2 USDC to Alice -7. The Fee AMM immediately swaps 0.8 USDC → 0.7976 USDT (0.8 × 0.9970) +3. Alice's transaction has a max fee of 1.0 USDG +4. The FeeManager collects 1.0 USDG from Alice before execution +5. Transaction executes and uses 0.8 USDG worth of gas +6. The FeeManager refunds 0.2 USDG to Alice +7. The Fee AMM immediately swaps 0.8 USDG → 0.7976 USDT (0.8 × 0.9970) 8. The 0.7976 USDT is added to the validator's accumulated fees 9. Validator calls `distributeFees()` to claim their accumulated fees 10. Liquidity providers earn 0.0024 USDT from the 0.3% fee diff --git a/src/pages/protocol/tip20/overview.mdx b/src/pages/protocol/tip20/overview.mdx index 247bd663..ddea9646 100644 --- a/src/pages/protocol/tip20/overview.mdx +++ b/src/pages/protocol/tip20/overview.mdx @@ -161,7 +161,7 @@ The currency code is **immutable** — it cannot be changed after token creation TIP-20 tokens can serve as quote tokens in Tempo's decentralized exchange (DEX). When creating trading pairs on the [Stablecoin DEX](/protocol/exchange), TIP-20 tokens function as the quote currency against which other tokens are priced and traded. -This enables efficient stablecoin-to-stablecoin trading and provides optimized routing for liquidity. For example, a USDC TIP-20 token can be paired with other stablecoins, allowing traders to swap between different USD-denominated tokens with minimal slippage through concentrated liquidity pools. +This enables efficient stablecoin-to-stablecoin trading and provides optimized routing for liquidity. For example, a USDG TIP-20 token can be paired with other stablecoins, allowing traders to swap between different USD-denominated tokens with minimal slippage through concentrated liquidity pools. By using TIP-20 tokens as quote tokens, the DEX benefits from the same payment-optimized features like deterministic addresses, currency identifiers, and compliance policies, ensuring secure and efficient exchange operations. diff --git a/src/pages/protocol/transactions/spec-tempo-transaction.mdx b/src/pages/protocol/transactions/spec-tempo-transaction.mdx index 4b1fc960..1645e480 100644 --- a/src/pages/protocol/transactions/spec-tempo-transaction.mdx +++ b/src/pages/protocol/transactions/spec-tempo-transaction.mdx @@ -692,7 +692,7 @@ The protocol tracks and enforces spending limits for TIP20 token transfers: key_id: keyId, // address derived from public key expiry: timestamp + 86400, // 24 hours from now (or 0 for never) limits: [ - { token: USDC_ADDRESS, amount: 1000000000 }, // 1000 USDC (6 decimals) + { token: USDG_ADDRESS, amount: 1000000000 }, // 1000 USDG (6 decimals) { token: DAI_ADDRESS, amount: 500000000000000000000 } // 500 DAI (18 decimals) ] }; @@ -804,8 +804,8 @@ const tx = { value: 0, input: encodeCall("updateSpendingLimit", [ keyId, - USDC_ADDRESS, - 2000000000 // New limit: 2000 USDC + USDG_ADDRESS, + 2000000000 // New limit: 2000 USDG ]) }], // ... sign with Root Key @@ -824,7 +824,7 @@ const keyInfo = await precompile.getKey(account, keyId); // Returns: { signatureType, keyId, expiry } // Check remaining spending limit for a token -const remaining = await precompile.getRemainingLimit(account, keyId, USDC_ADDRESS); +const remaining = await precompile.getRemainingLimit(account, keyId, USDG_ADDRESS); // Returns: uint256 amount remaining // Get which key signed current transaction (callable from contracts) diff --git a/src/pages/quickstart/evm-compatibility.mdx b/src/pages/quickstart/evm-compatibility.mdx index bb2cd808..84c2dee6 100644 --- a/src/pages/quickstart/evm-compatibility.mdx +++ b/src/pages/quickstart/evm-compatibility.mdx @@ -79,9 +79,9 @@ As specified in the preference system above, the simplest way to specify the fee #### Consideration 2: Paying fees in the TIP-20 contract being interacted with -If the user is calling a method on a TIP-20 token (e.g., `transfer`), the default fee token is that token itself. For example, if the user is calling the `transfer` method on a TIP-20 token with a symbol of "USDC", the default fee token would be "USDC". +If the user is calling a method on a TIP-20 token (e.g., `transfer`), the default fee token is that token itself. For example, if the user is calling the `transfer` method on a TIP-20 token with a symbol of "USDG", the default fee token would be "USDG". -Importantly, note that the `amount` field in this case is sent in full. So, if the user is calling the `transfer` method on a TIP-20 token with a symbol of "USDC" with the `amount` field set to 1000, the full amount of the token will be transferred **and** the sender's balance will be reduced by the amount spent in fees. So, the recipient will receive 1000 USDC. +Importantly, note that the `amount` field in this case is sent in full. So, if the user is calling the `transfer` method on a TIP-20 token with a symbol of "USDG" with the `amount` field set to 1000, the full amount of the token will be transferred **and** the sender's balance will be reduced by the amount spent in fees. So, the recipient will receive 1000 USDG. #### Consideration 3: The fallback in the case of a non-TIP-20 contract