diff --git a/package.json b/package.json
index ed1804861..6c4608fba 100644
--- a/package.json
+++ b/package.json
@@ -28,6 +28,7 @@
     "@nimiq/core": "^2.21.0",
     "@nimiq/electrum-client": "https://github.com/nimiq/electrum-client#build",
     "@nimiq/fastspot-api": "^1.10.3",
+    "@nimiq/gasless-sdk": "file:../gas-abstraction/sdk",
     "@nimiq/hub-api": "^1.15.0",
     "@nimiq/iqons": "^1.5.2",
     "@nimiq/libswap": "^1.5.2",
diff --git a/src/components/layouts/Network.vue b/src/components/layouts/Network.vue
index 5e22132c1..1f5c1808a 100644
--- a/src/components/layouts/Network.vue
+++ b/src/components/layouts/Network.vue
@@ -88,7 +88,7 @@
 <script lang="ts">
 import { defineComponent, onMounted, onUnmounted, ref, computed } from '@vue/composition-api';
 import { InfoCircleIcon, CircleSpinner } from '@nimiq/vue-components';
-import { calculateFee as calculatePolygonFee } from '@/ethers';
+import { isGaslessTransferConfigured, quoteGaslessFee } from '@/lib/usdc/Gasless';
 import { estimateFees } from '@/lib/BitcoinTransactionUtils';
 import { getElectrumClient } from '@/electrum';
 import { useI18n } from '@/lib/useI18n';
@@ -165,20 +165,14 @@ export default defineComponent({
                 btcFee.value = estimateFees(2, 2, fees[12]);
             }
 
-            if (config.polygon.enabled && stablecoin.value) {
-                switch (stablecoin.value) { // eslint-disable-line default-case
-                    case CryptoCurrency.USDC:
-                        polygonFee.value = (await calculatePolygonFee(
-                            config.polygon.usdc.tokenContract,
-                            'transferWithPermit',
-                        )).fee.toNumber();
-                        break;
-                    case CryptoCurrency.USDT:
-                        polygonFee.value = (await calculatePolygonFee(
-                            config.polygon.usdt_bridged.tokenContract,
-                            'transferWithApproval',
-                        )).fee.toNumber();
-                        break;
+            if (config.polygon.enabled && stablecoin.value && isGaslessTransferConfigured()) {
+                try {
+                    const quote = await quoteGaslessFee(stablecoin.value === CryptoCurrency.USDC
+                        ? config.polygon.usdc.tokenContract
+                        : config.polygon.usdt_bridged.tokenContract);
+                    polygonFee.value = Number(quote.fee);
+                } catch (error) {
+                    console.warn('Failed to fetch the gasless transfer fee', error); // eslint-disable-line no-console
                 }
             }
         }
diff --git a/src/components/modals/MoonpayModal.vue b/src/components/modals/MoonpayModal.vue
index b8c508b57..4b3a89e94 100644
--- a/src/components/modals/MoonpayModal.vue
+++ b/src/components/modals/MoonpayModal.vue
@@ -281,14 +281,14 @@ export default defineComponent({
                     throw new Error('Invalid network ID given by Moonpay');
                 }
 
-                const { tokenContract } = config.polygon.usdt_bridged;
+                const { tokenContract } = config.polygon.usdc;
 
                 if (properties.cryptoCurrency.contractAddress !== tokenContract.toLowerCase()) {
                     throw new Error('Invalid USDC contract address given by Moonpay');
                 }
 
                 const { accountUsdcBalance } = usePolygonAddressStore();
-                // TODO: Preselect a relay to be able to check balance against the fee as well
+                // The relay fee is checked against the balance when sending
                 if (accountUsdcBalance.value < value) {
                     throw new Error('Insufficient USDC balance');
                 }
@@ -298,7 +298,6 @@ export default defineComponent({
                     normalizedDepositAddress,
                     value,
                     'Moonpay',
-                    // relay,
                 );
 
                 if (!tx) {
@@ -336,7 +335,7 @@ export default defineComponent({
                 }
 
                 const { accountUsdtBridgedBalance } = usePolygonAddressStore();
-                // TODO: Preselect a relay to be able to check balance against the fee as well
+                // The relay fee is checked against the balance when sending
                 if (accountUsdtBridgedBalance.value < value) {
                     throw new Error('Insufficient USDT balance');
                 }
@@ -346,7 +345,6 @@ export default defineComponent({
                     normalizedDepositAddress,
                     value,
                     'Moonpay',
-                    // relay,
                 );
 
                 if (!tx) {
diff --git a/src/components/modals/StablecoinSendModal.vue b/src/components/modals/StablecoinSendModal.vue
index 374930f87..9a4db99fd 100644
--- a/src/components/modals/StablecoinSendModal.vue
+++ b/src/components/modals/StablecoinSendModal.vue
@@ -266,13 +266,14 @@ import { computed, defineComponent, onBeforeUnmount, ref, Ref, watch } from '@vu
 import { useRouter, RouteName } from '@/router';
 import { useI18n } from '@/lib/useI18n';
 import { nextTick } from '@/lib/nextTick';
+import type { TransferRequest } from '@nimiq/gasless-sdk/core';
 import { useConfig } from '../../composables/useConfig';
 import { useWindowSize } from '../../composables/useWindowSize';
 import { useFlaggedAddressCheck, FlaggedAddressInfo } from '../../composables/useFlaggedAddressCheck';
 import { sendPolygonTransaction } from '../../hub';
-import { loadEthersLibrary, calculateFee } from '../../ethers';
+import { loadEthersLibrary } from '../../ethers';
 import { CryptoCurrency, FiatCurrency, FIAT_CURRENCIES_OFFERED, ENV_MAIN } from '../../lib/Constants';
-import type { RelayServerInfo } from '../../lib/usdc/OpenGSN';
+import { quoteGaslessFee, GaslessFeeQuote, GaslessTransferError } from '../../lib/usdc/Gasless';
 import {
     isValidDomain as isValidUnstoppableDomain,
     resolve as resolveUnstoppableDomain,
@@ -513,7 +514,11 @@ export default defineComponent({
         const feeLoading = ref(true); // Only true for first fee loading, not for updates.
         const feeError = ref<string>(null);
 
-        const relay = ref<RelayServerInfo | null>(null);
+        const feeQuote = ref<GaslessFeeQuote | null>(null);
+        /**
+         * A payment that failed. Retrying it must keep its nonce (a correction), so that at most one version executes.
+         */
+        const failedPayment = ref<TransferRequest | null>(null);
 
         // Use 2.00 USDC/T as safe fallback fee
         const maxSendableAmount = computed(() => {
@@ -708,15 +713,25 @@ export default defineComponent({
             statusTitle.value = $t('Sending Transaction') as string;
             statusMessage.value = '';
 
+            const token = stablecoin.value === CryptoCurrency.USDC
+                ? config.polygon.usdc.tokenContract
+                : config.polygon.usdt_bridged.tokenContract;
+            const recipient = recipientInfo.value!.address;
+            // A correction must pay the same token to the same recipient. Otherwise, it is a new payment.
+            const corrects = failedPayment.value
+                && failedPayment.value.token.toLowerCase() === token.toLowerCase()
+                && failedPayment.value.to.toLowerCase() === recipient.toLowerCase()
+                ? failedPayment.value
+                : undefined;
+
             try {
                 const tx = await sendPolygonTransaction(
-                    stablecoin.value === CryptoCurrency.USDC
-                        ? config.polygon.usdc.tokenContract
-                        : config.polygon.usdt_bridged.tokenContract,
-                    recipientInfo.value!.address,
+                    token,
+                    recipient,
                     amount.value,
                     recipientInfo.value!.label,
-                    relay.value || undefined,
+                    feeQuote.value || undefined,
+                    corrects,
                 );
 
                 if (!tx) {
@@ -724,6 +739,7 @@ export default defineComponent({
                     return;
                 }
 
+                failedPayment.value = null;
                 saveRecipientLabel();
 
                 if (stablecoin.value === CryptoCurrency.USDC) {
@@ -752,6 +768,10 @@ export default defineComponent({
                 }, SUCCESS_REDIRECT_DELAY);
             } catch (error: any) {
                 reportToSentry(error);
+                if (error instanceof GaslessTransferError) {
+                    // Null if the payment's outcome is final
+                    failedPayment.value = error.payment;
+                }
 
                 // Show error screen
                 statusState.value = State.WARNING;
@@ -820,20 +840,18 @@ export default defineComponent({
             window.clearTimeout(feeUpdateTimeout); // Reset potentially existing update timeout.
             feeUpdateTimeout = 0; // 0: timer is to be started after the initial update
             try {
-                const method = stablecoin.value === CryptoCurrency.USDC ? 'transferWithPermit' : 'transferWithApproval';
-                const feeInformation = await calculateFee(
+                const quote = await quoteGaslessFee(
                     stablecoin.value === CryptoCurrency.USDC
                         ? config.polygon.usdc.tokenContract
                         : config.polygon.usdt_bridged.tokenContract,
-                    method,
-                    relay.value || undefined,
                 );
-                fee.value = Math.max(feeInformation.fee.toNumber(), 0.01);
-                relay.value = feeInformation.relay;
+                fee.value = Number(quote.fee);
+                feeQuote.value = quote;
                 feeLoading.value = false;
                 feeError.value = null;
                 if (feeUpdateTimeout === 0) {
-                    // Schedule next update in 20s if timer is still to be started and has not been started yet.
+                    // Schedule next update in 20s if timer is still to be started and has not been started yet. The
+                    // relay's quotes are valid for 120s.
                     feeUpdateTimeout = window.setTimeout(startFeeUpdates, 20e3);
                 }
             } catch (e: unknown) {
diff --git a/src/config/config.local.ts b/src/config/config.local.ts
index 574f19e0e..72e1e72c7 100644
--- a/src/config/config.local.ts
+++ b/src/config/config.local.ts
@@ -43,10 +43,13 @@ export default {
 
     polygon: {
         enabled: false,
-        // Set to true to keep sending visible, but show a maintenance warning instead of the send modal.
+        // Set to true to keep stablecoin swaps visible, but show a maintenance warning. Swaps are still relayed via
+        // OpenGSN.
         isGasAbstractionUnderMaintenance: false,
-        networkId: 80002,
-        rpcEndpoint: 'wss://polygon-amoy.g.alchemy.com/v2/#ALCHEMY_API_KEY#',
+        // Set to true to keep sending visible, but show a maintenance warning instead of the send modal.
+        isGaslessTransferUnderMaintenance: false,
+        networkId: 31337, // The local Anvil stack of the gas abstraction, see `gasless` below
+        rpcEndpoint: 'http://localhost:8545',
         rpcMaxBlockRange: 648_000, // 15 days - Maximum supported range by Alchemy?
         // eslint-disable-next-line max-len
         // rpcEndpoint: 'wss://shy-sparkling-wind.matic-testnet.discover.quiknode.pro/4461ca78cea96dd6a168a58d8fc30a021cabf01d/',
@@ -75,16 +78,27 @@ export default {
             earliestHistoryScanHeight: 13320830, // Block when Wallet was switched to Amoy testnet
         },
         usdc: {
-            tokenContract: '0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582',
+            tokenContract: '0x5FbDB2315678afecb367f032d93F642f64180aa3', // MockUSDC
             transferContract: '', // v1
             htlcContract: '',
-            earliestHistoryScanHeight: 13320830, // Block when Wallet was switched to Amoy testnet
+            earliestHistoryScanHeight: 0,
         },
         usdt_bridged: {
-            tokenContract: '0x1616d425Cd540B256475cBfb604586C8598eC0FB',
+            tokenContract: '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512', // MockUSDT0
             transferContract: '',
             htlcContract: '',
-            earliestHistoryScanHeight: 13320830, // Block when USDT was added to the Wallet
+            earliestHistoryScanHeight: 0,
+        },
+        // Gasless USDC/USDT0 transfers on the local Anvil stack of https://github.com/NimiqToolbox/gas-abstraction
+        // (`make stack-up`, with the Anvil and relay ports made reachable from the host), see networkId, rpcEndpoint
+        // and the token addresses above. The deployment addresses are deterministic on a fresh chain.
+        gasless: {
+            relayUrl: 'http://localhost:8080',
+            transferContract: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0',
+            relays: ['0xBcd4042DE499D14e55001CcbB24a551F3b954096'] as string[], // Anvil account 10
+            deployBlock: 0,
+            maxFee: 5e6,
+            maxAcceptableFee: 0.5e6,
         },
         usdcConversion: {
             swapContract: '',
diff --git a/src/config/config.mainnet.ts b/src/config/config.mainnet.ts
index 1bbdd2cd3..907a7e39c 100644
--- a/src/config/config.mainnet.ts
+++ b/src/config/config.mainnet.ts
@@ -53,8 +53,12 @@ export default {
 
     polygon: {
         enabled: true,
-        // Set to true to keep sending visible, but show a maintenance warning instead of the send modal.
+        // Set to true to keep stablecoin swaps visible, but show a maintenance warning. Swaps are still relayed via
+        // OpenGSN.
         isGasAbstractionUnderMaintenance: true,
+        // Set to true to keep sending visible, but show a maintenance warning instead of the send modal.
+        // TODO: Set to false once the gasless relay address and URL are configured below.
+        isGaslessTransferUnderMaintenance: true,
         networkId: 137,
         rpcEndpoint: 'wss://polygon-mainnet.g.alchemy.com/v2/#ALCHEMY_API_KEY#',
         rpcMaxBlockRange: 648_000, // 15 days - Maximum supported range by Alchemy?
@@ -76,6 +80,16 @@ export default {
             htlcContract: '0xF615bD7EA00C4Cc7F39Faad0895dB5f40891359f',
             earliestHistoryScanHeight: 63189500, // Block when USDT was added to the Wallet
         },
+        // Gasless USDC/USDT0 transfers, see https://github.com/NimiqToolbox/gas-abstraction
+        gasless: {
+            relayUrl: '', // TODO: Add the production relay URL
+            transferContract: '0xA0df3CdF124d7101a67ebE5b1b97D222505De9D6',
+            // Relay addresses the user may sign for. More than one allows a relay key rotation.
+            relays: [] as string[], // TODO: Add the production relay address
+            deployBlock: 94577424,
+            maxFee: 5e6, // The contract's MAX_FEE: 5.00 USDC/USDT
+            maxAcceptableFee: 0.5e6, // The highest relay fee the user is asked to sign, same as in the Keyguard
+        },
         usdcConversion: {
             swapContract: '0xfAbBed813017bF535b40013c13b8702638aC25CD',
             swapPoolContract: '0xD36ec33c8bed5a9F7B6630855f1533455b98a418',
diff --git a/src/config/config.testnet.ts b/src/config/config.testnet.ts
index cd8e460ac..e3a15b133 100644
--- a/src/config/config.testnet.ts
+++ b/src/config/config.testnet.ts
@@ -41,8 +41,11 @@ export default {
 
     polygon: {
         enabled: false,
-        // Set to true to keep sending visible, but show a maintenance warning instead of the send modal.
+        // Set to true to keep stablecoin swaps visible, but show a maintenance warning. Swaps are still relayed via
+        // OpenGSN.
         isGasAbstractionUnderMaintenance: false,
+        // Set to true to keep sending visible, but show a maintenance warning instead of the send modal.
+        isGaslessTransferUnderMaintenance: false,
         networkId: 80002,
         rpcEndpoint: 'wss://polygon-amoy.g.alchemy.com/v2/#ALCHEMY_API_KEY#',
         rpcMaxBlockRange: 648_000, // 15 days - Maximum supported range by Alchemy?
@@ -64,6 +67,15 @@ export default {
             htlcContract: '',
             earliestHistoryScanHeight: 13320830, // Block when USDT was added to the Wallet
         },
+        // Gasless transfers are not deployed on Amoy
+        gasless: {
+            relayUrl: '',
+            transferContract: '',
+            relays: [] as string[],
+            deployBlock: 0,
+            maxFee: 5e6,
+            maxAcceptableFee: 0.5e6,
+        },
         usdcConversion: {
             swapContract: '', // v2
             swapPoolContract: '',
diff --git a/src/ethers.ts b/src/ethers.ts
index ee598ac8c..3448dda69 100644
--- a/src/ethers.ts
+++ b/src/ethers.ts
@@ -32,7 +32,6 @@ import {
     getBestRelay,
     getRelayAddr,
     getRelayHub,
-    POLYGON_BLOCKS_PER_MINUTE,
     RelayServerInfo,
 } from './lib/usdc/OpenGSN';
 import { getPoolAddress, getUsdPrice } from './lib/usdc/Uniswap';
@@ -598,7 +597,10 @@ export async function launchPolygon() {
         if ((trigger as number) > 0) updateUsdcBridgedBalances([address]);
 
         const client = await getPolygonClient();
-        const poolAddress = await getPoolAddress(client.usdcBridgedTransfer, config.polygon.usdc_bridged.tokenContract);
+        const poolAddress = await getLegacyFeePoolAddress(
+            client.usdcBridgedTransfer,
+            config.polygon.usdc_bridged.tokenContract,
+        );
 
         console.debug('Fetching bridged USDC transaction history for', address, knownTxs);
 
@@ -610,27 +612,16 @@ export async function launchPolygon() {
 
         const STEP_BLOCKS = config.polygon.rpcMaxBlockRange;
 
-        const MAX_ALLOWANCE = client.ethers
-            .BigNumber.from('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
-
-        // The minimum allowance that should remain so we can be certain the max allowance was ever given.
-        // If the current allowance is below this number, we ignore allowance counting for the history sync.
-        const MIN_ALLOWANCE = client.ethers
-            .BigNumber.from('0x1000000000000000000000000000000000000000000000000000000000000000');
-
         Promise.all([
             client.usdcBridgedToken.balanceOf(address) as Promise<BigNumber>,
             client.usdcBridgedToken.nonces(address).then((nonce: BigNumber) => nonce.toNumber()) as Promise<number>,
-            client.usdcBridgedToken.allowance(address, config.polygon.usdc_bridged.transferContract)
-                .then((allowance: BigNumber) => {
-                    if (allowance.lt(MIN_ALLOWANCE)) return client.ethers.BigNumber.from(0);
-                    return MAX_ALLOWANCE.sub(allowance);
-                }) as Promise<BigNumber>,
-            client.usdcBridgedToken.allowance(address, config.polygon.usdc_bridged.htlcContract)
-                .then((allowance: BigNumber) => {
-                    if (allowance.lt(MIN_ALLOWANCE)) return client.ethers.BigNumber.from(0);
-                    return MAX_ALLOWANCE.sub(allowance);
-                }) as Promise<BigNumber>,
+            getLegacyAllowanceUsed(
+                client,
+                client.usdcBridgedToken,
+                address,
+                config.polygon.usdc_bridged.transferContract,
+            ),
+            getLegacyAllowanceUsed(client, client.usdcBridgedToken, address, config.polygon.usdc_bridged.htlcContract),
         ]).then(async ([balance, nonce, transferAllowanceUsed, htlcAllowanceUsed]) => {
             let blockHeight = await getPolygonBlockNumber();
 
@@ -905,7 +896,7 @@ export async function launchPolygon() {
         if ((trigger as number) > 0) updateUsdcBalances([address]);
 
         const client = await getPolygonClient();
-        const poolAddress = await getPoolAddress(client.usdcTransfer, config.polygon.usdc.tokenContract);
+        const poolAddress = await getLegacyFeePoolAddress(client.usdcTransfer, config.polygon.usdc.tokenContract);
 
         console.debug('Fetching native USDC transaction history for', address, knownTxs);
 
@@ -918,27 +909,11 @@ export async function launchPolygon() {
 
         const STEP_BLOCKS = config.polygon.rpcMaxBlockRange;
 
-        const MAX_ALLOWANCE = client.ethers
-            .BigNumber.from('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
-
-        // The minimum allowance that should remain so we can be certain the max allowance was ever given.
-        // If the current allowance is below this number, we ignore allowance counting for the history sync.
-        const MIN_ALLOWANCE = client.ethers
-            .BigNumber.from('0x1000000000000000000000000000000000000000000000000000000000000000');
-
         Promise.all([
             client.usdcToken.balanceOf(address) as Promise<BigNumber>,
             client.usdcToken.nonces(address).then((nonce: BigNumber) => nonce.toNumber()) as Promise<number>,
-            client.usdcToken.allowance(address, config.polygon.usdc.transferContract)
-                .then((allowance: BigNumber) => {
-                    if (allowance.lt(MIN_ALLOWANCE)) return client.ethers.BigNumber.from(0);
-                    return MAX_ALLOWANCE.sub(allowance);
-                }) as Promise<BigNumber>,
-            client.usdcToken.allowance(address, config.polygon.usdc.htlcContract)
-                .then((allowance: BigNumber) => {
-                    if (allowance.lt(MIN_ALLOWANCE)) return client.ethers.BigNumber.from(0);
-                    return MAX_ALLOWANCE.sub(allowance);
-                }) as Promise<BigNumber>,
+            getLegacyAllowanceUsed(client, client.usdcToken, address, config.polygon.usdc.transferContract),
+            getLegacyAllowanceUsed(client, client.usdcToken, address, config.polygon.usdc.htlcContract),
         ]).then(async ([balance, nonce, transferAllowanceUsed, htlcAllowanceUsed]) => {
             let blockHeight = await getPolygonBlockNumber();
 
@@ -1011,6 +986,19 @@ export async function launchPolygon() {
 
                     if (knownHashes.includes(log.transactionHash)) return false;
 
+                    // Transfers to a gasless relay, in a transaction with another transfer from this address, are
+                    // the fees paid to the relay
+                    if (log.args.from === address && isGaslessRelay(log.args.to)) {
+                        const mainTransferLog = allTransferLogs.find((otherLog) =>
+                            otherLog.transactionHash === log.transactionHash
+                            && otherLog.logIndex !== log.logIndex
+                            && otherLog.args?.from === address);
+                        if (mainTransferLog && mainTransferLog.args) {
+                            mainTransferLog.args = addFeeToArgs(mainTransferLog.args, log.args.value);
+                            return false;
+                        }
+                    }
+
                     // Transfers to the Uniswap pool are the fees paid to OpenGSN
                     if (log.args.to === poolAddress) {
                         // Find the main transfer log
@@ -1166,7 +1154,10 @@ export async function launchPolygon() {
         if ((trigger as number) > 0) updateUsdtBridgedBalances([address]);
 
         const client = await getPolygonClient();
-        const poolAddress = await getPoolAddress(client.usdtBridgedTransfer, config.polygon.usdt_bridged.tokenContract);
+        const poolAddress = await getLegacyFeePoolAddress(
+            client.usdtBridgedTransfer,
+            config.polygon.usdt_bridged.tokenContract,
+        );
 
         console.debug('Fetching bridged USDT transaction history for', address, knownTxs);
 
@@ -1178,27 +1169,16 @@ export async function launchPolygon() {
 
         const STEP_BLOCKS = config.polygon.rpcMaxBlockRange;
 
-        const MAX_ALLOWANCE = client.ethers
-            .BigNumber.from('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
-
-        // The minimum allowance that should remain so we can be certain the max allowance was ever given.
-        // If the current allowance is below this number, we ignore allowance counting for the history sync.
-        const MIN_ALLOWANCE = client.ethers
-            .BigNumber.from('0x1000000000000000000000000000000000000000000000000000000000000000');
-
         Promise.all([
             client.usdtBridgedToken.balanceOf(address) as Promise<BigNumber>,
             client.usdtBridgedToken.getNonce(address).then((nonce: BigNumber) => nonce.toNumber()) as Promise<number>,
-            client.usdtBridgedToken.allowance(address, config.polygon.usdt_bridged.transferContract)
-                .then((allowance: BigNumber) => {
-                    if (allowance.lt(MIN_ALLOWANCE)) return client.ethers.BigNumber.from(0);
-                    return MAX_ALLOWANCE.sub(allowance);
-                }) as Promise<BigNumber>,
-            client.usdtBridgedToken.allowance(address, config.polygon.usdt_bridged.htlcContract)
-                .then((allowance: BigNumber) => {
-                    if (allowance.lt(MIN_ALLOWANCE)) return client.ethers.BigNumber.from(0);
-                    return MAX_ALLOWANCE.sub(allowance);
-                }) as Promise<BigNumber>,
+            getLegacyAllowanceUsed(
+                client,
+                client.usdtBridgedToken,
+                address,
+                config.polygon.usdt_bridged.transferContract,
+            ),
+            getLegacyAllowanceUsed(client, client.usdtBridgedToken, address, config.polygon.usdt_bridged.htlcContract),
         ]).then(async ([balance, nonce, transferAllowanceUsed, htlcAllowanceUsed]) => {
             let blockHeight = await getPolygonBlockNumber();
 
@@ -1272,6 +1252,19 @@ export async function launchPolygon() {
 
                     if (knownHashes.includes(log.transactionHash)) return false;
 
+                    // Transfers to a gasless relay, in a transaction with another transfer from this address, are
+                    // the fees paid to the relay
+                    if (log.args.from === address && isGaslessRelay(log.args.to)) {
+                        const mainTransferLog = allTransferLogs.find((otherLog) =>
+                            otherLog.transactionHash === log.transactionHash
+                            && otherLog.logIndex !== log.logIndex
+                            && otherLog.args?.from === address);
+                        if (mainTransferLog && mainTransferLog.args) {
+                            mainTransferLog.args = addFeeToArgs(mainTransferLog.args, log.args.value);
+                            return false;
+                        }
+                    }
+
                     // Transfers to the Uniswap pool are the fees paid to OpenGSN
                     if (log.args.to === poolAddress) {
                         // Find the main transfer log
@@ -1524,123 +1517,6 @@ export async function calculateFee(
     };
 }
 
-export async function createTransactionRequest(
-    tokenAddress: string,
-    recipient: string,
-    amount: number,
-    forceRelay?: RelayServerInfo,
-) {
-    const addressInfo = usePolygonAddressStore().addressInfo.value;
-    if (!addressInfo) throw new Error('No active Polygon address');
-    const fromAddress = addressInfo.address;
-
-    const { config } = useConfig();
-
-    const client = await getPolygonClient();
-
-    const tokenContract = tokenAddress === config.polygon.usdc.tokenContract
-        ? client.usdcToken
-        : client.usdtBridgedToken;
-    const transferAddress = tokenAddress === config.polygon.usdc.tokenContract
-        ? config.polygon.usdc.transferContract
-        : config.polygon.usdt_bridged.transferContract;
-    const transferContract = tokenAddress === config.polygon.usdc.tokenContract
-        ? client.usdcTransfer
-        : client.usdtBridgedTransfer;
-
-    const [
-        nonce,
-        // usdcAllowance,
-        forwarderNonce,
-    ] = await Promise.all([
-        ('nonces' in tokenContract
-            ? tokenContract.nonces(fromAddress)
-            : tokenContract.getNonce(fromAddress)
-        ) as Promise<BigNumber>,
-        // tokenContract.allowance(fromAddress, transferAddress) as Promise<BigNumber>,
-        transferContract.getNonce(fromAddress) as Promise<BigNumber>,
-    ]);
-
-    type Methods = 'transfer' | 'transferWithPermit' | 'transferWithApproval';
-    const method: Methods = tokenAddress === config.polygon.usdc.tokenContract
-        ? 'transferWithPermit'
-        : 'transferWithApproval';
-
-    // // This sets the fee buffer to 10 USDC, which should be enough.
-    // method = usdcAllowance.gte(amount + 10e6) ? 'transfer' : method;
-
-    const { fee, gasPrice, gasLimit, relay } = await calculateFee(tokenAddress, method, forceRelay);
-
-    // Ensure we send only what's possible with the updated fee
-    const accountBalance = tokenAddress === config.polygon.usdc.tokenContract
-        ? addressInfo.balanceUsdc
-        : addressInfo.balanceUsdtBridged;
-    amount = Math.min(amount, (accountBalance || 0) - fee.toNumber());
-
-    // // To be safe, we still check that amount + fee fits into the current allowance
-    // if (method === 'transfer' && usdcAllowance.lt(fee.add(amount))) {
-    //     throw new Error('Unexpectedly high fee, not enough allowance on the USDC contract');
-    // }
-
-    const data = transferContract.interface.encodeFunctionData(method, [
-        /* address token */ tokenAddress,
-        /* uint256 amount */ amount,
-        /* address target */ recipient,
-        /* uint256 fee */ fee,
-        ...(method === 'transferWithPermit' || method === 'transferWithApproval' ? [
-            // // Approve the maximum possible amount so afterwards we can use the `transfer` method for lower fees
-            // /* uint256 value/approval */ client.ethers
-            //     .BigNumber.from('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'),
-            /* uint256 value/approval */ fee.add(amount),
-
-            // Dummy values, replaced by real signature bytes in Keyguard
-            /* bytes32 sigR */ '0x0000000000000000000000000000000000000000000000000000000000000000',
-            /* bytes32 sigS */ '0x0000000000000000000000000000000000000000000000000000000000000000',
-            /* uint8 sigV */ 0,
-        ] : []),
-    ]);
-
-    const relayRequest: RelayRequest = {
-        request: {
-            from: fromAddress,
-            to: transferAddress,
-            data,
-            value: '0',
-            nonce: forwarderNonce.toString(),
-            gas: gasLimit.toString(),
-            validUntil: (await getPolygonBlockNumber() + 2 * 60 * POLYGON_BLOCKS_PER_MINUTE) // 2 hours
-                .toString(10),
-        },
-        relayData: {
-            gasPrice: gasPrice.toString(),
-            pctRelayFee: relay.pctRelayFee.toString(),
-            baseRelayFee: relay.baseRelayFee.toString(),
-            relayWorker: relay.relayWorkerAddress,
-            paymaster: transferAddress,
-            paymasterData: '0x',
-            clientId: Math.floor(Math.random() * 1e6).toString(10),
-            forwarder: transferAddress,
-        },
-    };
-
-    return {
-        relayRequest,
-        relay: {
-            url: relay.url,
-        },
-        ...(method === 'transferWithPermit' ? {
-            permit: {
-                tokenNonce: nonce.toNumber(),
-            },
-        } : null),
-        ...(method === 'transferWithApproval' ? {
-            approval: {
-                tokenNonce: nonce.toNumber(),
-            },
-        } : null),
-    };
-}
-
 export async function sendTransaction(
     token: string,
     relayRequest: RelayRequest,
@@ -1744,7 +1620,7 @@ export async function receiptToTransaction(
             : token === config.polygon.usdc_bridged.tokenContract
                 ? getUsdcBridgedHtlcContract()
                 : getUsdtBridgedHtlcContract(),
-        getPoolAddress(transferContract, token),
+        getLegacyFeePoolAddress(transferContract, token),
     ]);
 
     const logs = receipt.logs.map((log) => {
@@ -1952,6 +1828,98 @@ export async function getConversionSwapContract() {
     return swapContract;
 }
 
+/**
+ * How much of the max allowance that was given to an OpenGSN-based contract was used, for the history sync. Zero if
+ * the contract is not configured or no max allowance was given.
+ */
+async function getLegacyAllowanceUsed(
+    client: PolygonClient,
+    tokenContract: Contract,
+    owner: string,
+    spender: string,
+): Promise<BigNumber> {
+    if (!spender) return client.ethers.BigNumber.from(0);
+    const MAX_ALLOWANCE = client.ethers
+        .BigNumber.from('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
+    // The minimum allowance that should remain so we can be certain the max allowance was ever given.
+    // If the current allowance is below this number, we ignore allowance counting for the history sync.
+    const MIN_ALLOWANCE = client.ethers
+        .BigNumber.from('0x1000000000000000000000000000000000000000000000000000000000000000');
+    const allowance = await tokenContract.allowance(owner, spender) as BigNumber;
+    if (allowance.lt(MIN_ALLOWANCE)) return client.ethers.BigNumber.from(0);
+    return MAX_ALLOWANCE.sub(allowance);
+}
+
+/** The Uniswap pool that received the OpenGSN relay fees of a transfer contract, if that contract is configured. */
+async function getLegacyFeePoolAddress(transferContract: Contract, token: string): Promise<string | undefined> {
+    if (!transferContract.address) return undefined;
+    return getPoolAddress(transferContract, token);
+}
+
+function isGaslessRelay(address: string) {
+    const { config } = useConfig();
+    return config.polygon.gasless.relays.some((relay) => relay.toLowerCase() === address.toLowerCase());
+}
+
+/** Triggers a balance update, e.g. after an outgoing transaction. */
+export function updatePolygonBalances(token: string, addresses: string[]) {
+    const { config } = useConfig();
+    if (token === config.polygon.usdc.tokenContract) {
+        updateUsdcBalances(addresses);
+    } else if (token === config.polygon.usdc_bridged.tokenContract) {
+        updateUsdcBridgedBalances(addresses);
+    } else {
+        updateUsdtBridgedBalances(addresses);
+    }
+}
+
+/**
+ * Converts the receipt of a gasless transfer (GaslessTransfer.relayTransfer) of the given sender into a transaction,
+ * with the relay fee taken from the TransferRelayed event.
+ */
+export async function gaslessReceiptToTransaction(receipt: TransactionReceipt, from: string): Promise<Transaction> {
+    const { config } = useConfig();
+    const [client, { gaslessTransferAbi }] = await Promise.all([
+        getPolygonClient(),
+        // The package's subpath exports are not supported by the eslint import resolver
+        // eslint-disable-next-line import/no-unresolved, import/extensions
+        import(/* webpackChunkName: "gasless-sdk" */ '@nimiq/gasless-sdk/core'),
+    ]);
+    const gaslessInterface = new client.ethers.utils.Interface(gaslessTransferAbi as unknown as string[]);
+
+    let relayed: Result | undefined;
+    for (const log of receipt.logs) {
+        if (log.address.toLowerCase() !== config.polygon.gasless.transferContract.toLowerCase()) continue;
+        try {
+            const { args, name } = gaslessInterface.parseLog(log);
+            if (name === 'TransferRelayed' && (args.from as string).toLowerCase() === from.toLowerCase()) {
+                relayed = args;
+            }
+        } catch (error) { /* ignore */ }
+    }
+    if (!relayed) throw new Error('Could not find the TransferRelayed event');
+
+    // The principal transfer is the token's Transfer event from the sender to the recipient
+    const tokenContract = relayed.token === config.polygon.usdc.tokenContract
+        ? client.usdcToken
+        : client.usdtBridgedToken;
+    let transferLog: TransferLog | undefined;
+    for (const log of receipt.logs) {
+        if (log.address !== relayed.token) continue;
+        try {
+            const { args, name } = tokenContract.interface.parseLog(log);
+            if (name === 'Transfer' && args.from === relayed.from && args.to === relayed.to
+                && (args.value as BigNumber).eq(relayed.amount)) {
+                transferLog = { ...log, args: args as unknown as TransferResult, name };
+            }
+        } catch (error) { /* ignore */ }
+    }
+    if (!transferLog) throw new Error('Could not find the transfer log');
+
+    transferLog.args = addFeeToArgs(transferLog.args, relayed.fee) as TransferResult;
+    return logAndBlockToPlain(transferLog, await client.provider.getBlock(receipt.blockHash));
+}
+
 function addFeeToArgs(readonlyArgs: Result, fee: BigNumber): Result {
     // Clone args as writeable
     type Writeable<T> = { -readonly [P in keyof T]: T[P] };
diff --git a/src/hub.ts b/src/hub.ts
index 476b01d04..b79d1f5ab 100644
--- a/src/hub.ts
+++ b/src/hub.ts
@@ -16,8 +16,8 @@ import HubApi, {
 } from '@nimiq/hub-api';
 import type { PlainTransactionDetails } from '@nimiq/core';
 import type { RequestBehavior, BehaviorType } from '@nimiq/hub-api/dist/src/RequestBehavior.d';
-import type { ForwardRequest } from '@opengsn/common/dist/EIP712/ForwardRequest';
 import Config from 'config';
+import type { TransferRequest } from '@nimiq/gasless-sdk/core';
 import { useAccountStore, AccountInfo, AccountType } from './stores/Account';
 import { useAddressStore, AddressInfo, AddressType } from './stores/Address';
 import { useBtcAddressStore, BtcAddressInfo } from './stores/BtcAddress';
@@ -28,7 +28,7 @@ import { useProxyStore, Cashlink } from './stores/Proxy';
 import { useConfig } from './composables/useConfig';
 import { sendTransaction as sendTx } from './network';
 import { sendTransaction as sendBtcTx } from './electrum';
-import { createTransactionRequest, sendTransaction as sendPolygonTx } from './ethers';
+import { sendGaslessTransfer, GaslessFeeQuote } from './lib/usdc/Gasless';
 import { isProxyData, ProxyTransactionDirection } from './lib/ProxyDetection';
 import router, { RouteName } from './router';
 import { useSettingsStore } from './stores/Settings';
@@ -40,7 +40,6 @@ import {
 } from './lib/Constants';
 import { usePwaInstallPrompt } from './composables/usePwaInstallPrompt';
 import type { SetupSwapWithKycResult, SWAP_KYC_HANDLER_STORAGE_KEY } from './swap-kyc-handler'; // avoid bundling
-import type { RelayServerInfo } from './lib/usdc/OpenGSN';
 
 export function shouldUseRedirects(ignoreSettings = false): boolean {
     if (!ignoreSettings) {
@@ -852,58 +851,32 @@ export async function activatePolygon(accountId: string) {
     return true;
 }
 
+/**
+ * Sends a gasless USDC or USDT0 transfer from the active Polygon address. Resolves to the mined transaction, or to
+ * false if the user cancelled. Throws a GaslessTransferError on failure; to retry that payment, pass its `payment` as
+ * `corrects`, so that the retry keeps the payment's nonce and at most one version of it can execute.
+ */
 export async function sendPolygonTransaction(
     tokenAddress: string,
     recipient: string,
     amount: number,
     recipientLabel?: string,
-    forceRelay?: RelayServerInfo,
+    quote?: GaslessFeeQuote,
+    corrects?: TransferRequest,
 ) {
-    // eslint-disable-next-line no-async-promise-executor
-
-    let relayUrl: string;
-
-    // eslint-disable-next-line no-async-promise-executor
-    const request = new Promise<SignPolygonTransactionRequest>(async (resolve, reject) => {
-        try {
-            const {
-                relayRequest,
-                permit,
-                approval,
-                relay,
-            } = await createTransactionRequest(tokenAddress, recipient, amount, forceRelay);
-            relayUrl = relay.url;
-            resolve({
-                ...relayRequest,
-                appName: APP_NAME,
-                recipientLabel,
-
-                ...(permit ? {
-                    permit: {
-                        tokenNonce: permit.tokenNonce,
-                    },
-                } : null),
-
-                ...(approval ? {
-                    approval: {
-                        tokenNonce: approval.tokenNonce,
-                    },
-                } : null),
-            });
-        } catch (e) {
-            reject(e);
-        }
+    const tx = await sendGaslessTransfer({
+        token: tokenAddress,
+        to: recipient,
+        amount,
+        recipientLabel,
+        quote,
+        corrects,
+        sign: (request) => hubApi.signPolygonTransaction({
+            ...request,
+            appName: APP_NAME,
+        }, getBehavior()).catch(onError),
     });
-    const signedTransaction = await hubApi.signPolygonTransaction(request, getBehavior()).catch(onError);
-    if (!signedTransaction) return false;
-
-    const { relayData, ...relayRequest } = signedTransaction.message;
-    return sendPolygonTx(
-        tokenAddress,
-        { request: relayRequest as ForwardRequest, relayData },
-        signedTransaction.signature,
-        relayUrl!,
-    );
+    return tx || false;
 }
 
 export async function addBtcAddresses(accountId: string, chain: 'internal' | 'external', count?: number) {
diff --git a/src/i18n/en.po b/src/i18n/en.po
index 35c269c5a..73d0de77b 100644
--- a/src/i18n/en.po
+++ b/src/i18n/en.po
@@ -1021,7 +1021,7 @@ msgstr ""
 
 #: src/components/BtcAddressInput.vue:99
 #: src/components/modals/SendModal.vue:400
-#: src/components/modals/StablecoinSendModal.vue:422
+#: src/components/modals/StablecoinSendModal.vue:423
 msgid "Domain does not resolve to a valid address"
 msgstr ""
 
@@ -1193,7 +1193,7 @@ msgstr ""
 msgid "Failed"
 msgstr ""
 
-#: src/components/modals/StablecoinSendModal.vue:840
+#: src/components/modals/StablecoinSendModal.vue:858
 msgid "Failed to fetch {ticker} fees. Retrying... (Error: {message})"
 msgstr ""
 
@@ -2430,7 +2430,7 @@ msgstr ""
 
 #: src/components/modals/BtcSendModal.vue:520
 #: src/components/modals/SendModal.vue:683
-#: src/components/modals/StablecoinSendModal.vue:708
+#: src/components/modals/StablecoinSendModal.vue:713
 msgid "Sending Transaction"
 msgstr ""
 
@@ -2454,11 +2454,11 @@ msgstr ""
 msgid "Sent {btc} BTC to {name}"
 msgstr ""
 
-#: src/components/modals/StablecoinSendModal.vue:743
+#: src/components/modals/StablecoinSendModal.vue:759
 msgid "Sent {coin} {ticker}"
 msgstr ""
 
-#: src/components/modals/StablecoinSendModal.vue:738
+#: src/components/modals/StablecoinSendModal.vue:754
 msgid "Sent {coin} {ticker} to {name}"
 msgstr ""
 
@@ -2584,7 +2584,7 @@ msgstr ""
 
 #: src/components/modals/BtcSendModal.vue:584
 #: src/components/modals/SendModal.vue:731
-#: src/components/modals/StablecoinSendModal.vue:758
+#: src/components/modals/StablecoinSendModal.vue:778
 #: src/components/staking/StakingGraphPage.vue:273
 #: src/components/staking/StakingInfoPage.vue:476
 #: src/components/staking/StakingInfoPage.vue:557
diff --git a/src/lib/usdc/Gasless.ts b/src/lib/usdc/Gasless.ts
new file mode 100644
index 000000000..038fffcc9
--- /dev/null
+++ b/src/lib/usdc/Gasless.ts
@@ -0,0 +1,423 @@
+/* eslint-disable no-console */
+import type { Contract } from 'ethers';
+import type { ChainPins, TransferRequest } from '@nimiq/gasless-sdk/core';
+import type { FeeResponse, RelayClient, SubmitTransferBody } from '@nimiq/gasless-sdk/relay';
+import type { SignedPolygonGaslessTransfer, SignPolygonGaslessTransferRequest } from '@nimiq/hub-api';
+import { useConfig } from '../../composables/useConfig';
+import { ENV_MAIN } from '../Constants';
+import { getPolygonClient, gaslessReceiptToTransaction, updatePolygonBalances } from '../../ethers';
+import { useGaslessPaymentsStore, GaslessPaymentStatus, gaslessPaymentKey } from '../../stores/GaslessPayments';
+import { usePolygonAddressStore } from '../../stores/PolygonAddress';
+import { Transaction, useUsdcTransactionsStore } from '../../stores/UsdcTransactions';
+import { useUsdtTransactionsStore } from '../../stores/UsdtTransactions';
+import { waitForTransferOutcome, TransferOutcome } from './GaslessOutcome';
+
+/**
+ * Gasless USDC and USDT0 transfers through the GaslessTransfer contract and the Nimiq relay, see
+ * https://github.com/NimiqToolbox/gas-abstraction. The user signs a transfer intent and a token permit in the Keyguard
+ * (via the Hub), the relay submits it and pays the gas in POL, and receives its fee in the transferred token.
+ *
+ * Rules followed here to never let the user pay twice (sdk/README.md, "Failures, retries and replacements"):
+ * - One payment, one intent nonce. A retry of a payment is a correction that keeps the nonce (`corrects`), so that at
+ *   most one version executes. A new nonce is only signed for a new payment.
+ * - The latest signed version of a payment is recorded before it is submitted, and kept until its outcome is final.
+ * - Before a correction is signed, the chain is checked for whether a version of the payment already executed.
+ */
+
+export type GaslessFeeQuote = Pick<FeeResponse, 'token' | 'fee' | 'relay' | 'quoteId' | 'expiresAt'>;
+
+export class GaslessTransferError extends Error {
+    /**
+     * The payment's latest signed version. A retry of this payment must pass it as `corrects`, to keep the payment's
+     * nonce, instead of starting a new payment.
+     */
+    public readonly payment: TransferRequest | null;
+
+    constructor(message: string, payment: TransferRequest | null) {
+        super(message);
+        this.name = 'GaslessTransferError';
+        this.payment = payment;
+    }
+}
+
+const TOKEN_ABI = [
+    'function nonces(address owner) view returns (uint256)',
+    'function DOMAIN_SEPARATOR() view returns (bytes32)',
+];
+
+async function loadSdk() {
+    const [core, relay] = await Promise.all([
+        // The package's subpath exports are not supported by the eslint import resolver
+        // eslint-disable-next-line import/no-unresolved, import/extensions
+        import(/* webpackChunkName: "gasless-sdk" */ '@nimiq/gasless-sdk/core'),
+        // eslint-disable-next-line import/no-unresolved, import/extensions
+        import(/* webpackChunkName: "gasless-sdk" */ '@nimiq/gasless-sdk/relay'),
+    ]);
+    return { core, relay };
+}
+
+export function isGaslessTransferConfigured() {
+    const { config } = useConfig();
+    const { gasless } = config.polygon;
+    return !!gasless.relayUrl && !!gasless.transferContract && gasless.relays.length > 0;
+}
+
+let pinsPromise: Promise<ChainPins> | null = null;
+/**
+ * The deployment the Wallet trusts: contract, relay addresses, token domains and MAX_FEE. The relay's /v1/info must
+ * match them. The Keyguard pins the same deployment independently.
+ */
+export async function getGaslessPins(): Promise<ChainPins> {
+    if (pinsPromise) return pinsPromise;
+    pinsPromise = (async () => {
+        if (!isGaslessTransferConfigured()) throw new Error('Gasless Polygon transfers are not configured');
+        const { core } = await loadSdk();
+        const { config } = useConfig();
+        const chainId = config.polygon.networkId;
+        return core.definePins({
+            chainId,
+            transfer: config.polygon.gasless.transferContract,
+            relays: config.polygon.gasless.relays,
+            tokens: config.environment === ENV_MAIN
+                // On Polygon mainnet, definePins also checks the tokens against these frozen, verified constants.
+                ? core.POLYGON_TOKENS
+                : [{
+                    symbol: 'USDC',
+                    address: config.polygon.usdc.tokenContract,
+                    decimals: 6,
+                    authModes: ['permit', 'none'],
+                    domain: {
+                        name: 'USD Coin',
+                        version: '2',
+                        chainId,
+                        verifyingContract: config.polygon.usdc.tokenContract as `0x${string}`,
+                    },
+                }, {
+                    symbol: 'USDT0',
+                    address: config.polygon.usdt_bridged.tokenContract,
+                    decimals: 6,
+                    authModes: ['permit', 'metaTxApprove', 'none'],
+                    domain: {
+                        name: 'USDT0',
+                        version: '1',
+                        verifyingContract: config.polygon.usdt_bridged.tokenContract as `0x${string}`,
+                        salt: core.chainIdSalt(chainId),
+                    },
+                }],
+            maxFee: config.polygon.gasless.maxFee,
+            deployBlock: config.polygon.gasless.deployBlock,
+        });
+    })();
+    pinsPromise.catch(() => { pinsPromise = null; });
+    return pinsPromise;
+}
+
+let relayClientPromise: Promise<RelayClient> | null = null;
+async function getRelayClient(): Promise<RelayClient> {
+    if (relayClientPromise) return relayClientPromise;
+    relayClientPromise = (async () => {
+        const [{ relay }, pins] = await Promise.all([loadSdk(), getGaslessPins()]);
+        const { config } = useConfig();
+        return new relay.RelayClient(config.polygon.gasless.relayUrl, { pins });
+    })();
+    relayClientPromise.catch(() => { relayClientPromise = null; });
+    return relayClientPromise;
+}
+
+let transferContract: Contract | null = null;
+async function getTransferContract(): Promise<Contract> {
+    if (transferContract) return transferContract;
+    const [{ core }, pins, client] = await Promise.all([loadSdk(), getGaslessPins(), getPolygonClient()]);
+    transferContract = new client.ethers.Contract(
+        pins.transfer.address,
+        core.gaslessTransferAbi as unknown as string[],
+        client.provider,
+    );
+    return transferContract;
+}
+
+/**
+ * The relay's fee for a permit transfer of the given token, in token units. Refuses quotes above the Wallet's
+ * `maxAcceptableFee`; the Keyguard applies the same limit when signing.
+ */
+export async function quoteGaslessFee(token: string): Promise<GaslessFeeQuote> {
+    const relay = await getRelayClient();
+    const { config } = useConfig();
+    const quote = await relay.fee({
+        token: token as `0x${string}`,
+        authMode: 'permit',
+        maxAcceptableFee: BigInt(config.polygon.gasless.maxAcceptableFee),
+    });
+    return {
+        token: quote.token,
+        fee: quote.fee,
+        relay: quote.relay,
+        quoteId: quote.quoteId,
+        expiresAt: quote.expiresAt,
+    };
+}
+
+async function readPermitNonceAndCheckDomain(token: string, owner: string): Promise<number> {
+    const [{ core }, pins, client] = await Promise.all([loadSdk(), getGaslessPins(), getPolygonClient()]);
+    const pinned = core.findPinnedToken(pins, token);
+    if (!pinned) throw new Error(`Token ${token} is not supported for gasless transfers`);
+    const tokenContract = new client.ethers.Contract(pinned.address, TOKEN_ABI, client.provider);
+    const [nonce, domainSeparator] = await Promise.all([
+        tokenContract.nonces(owner),
+        tokenContract.DOMAIN_SEPARATOR() as Promise<string>,
+    ]);
+    // USDT0's admin can rename the token, which changes its domain. A permit signed with the pinned domain would then
+    // be invalid.
+    if (domainSeparator.toLowerCase() !== pinned.domainSeparator.toLowerCase()) {
+        throw new Error(`The ${pinned.symbol} token domain changed, gasless transfers are unavailable`);
+    }
+    return nonce.toNumber();
+}
+
+function tokenTransactionsStore(token: string) {
+    const { config } = useConfig();
+    return token.toLowerCase() === config.polygon.usdc.tokenContract.toLowerCase()
+        ? useUsdcTransactionsStore()
+        : useUsdtTransactionsStore();
+}
+
+async function transactionFromOutcome(outcome: TransferOutcome): Promise<Transaction | null> {
+    if (!outcome.txHash || !outcome.executedTransfer) return null;
+    const client = await getPolygonClient();
+    const receipt = await client.provider.getTransactionReceipt(outcome.txHash);
+    if (!receipt) return null;
+    return gaslessReceiptToTransaction(receipt, outcome.executedTransfer.from);
+}
+
+/**
+ * Waits in the background until the payment's outcome is final at the finalized block, then forgets the payment. An
+ * execution that the Wallet did not see yet (e.g. after a reload) gets added to the transaction history.
+ */
+async function settleInBackground(latest: TransferRequest, id: string) {
+    const store = useGaslessPaymentsStore();
+    try {
+        const [pins, contract, client, relay] = await Promise.all([
+            getGaslessPins(),
+            getTransferContract(),
+            getPolygonClient(),
+            getRelayClient(),
+        ]);
+        const outcome = await waitForTransferOutcome(client.provider, contract, pins, latest, id, { relay });
+        if (outcome.status === 'executed' || outcome.status === 'other_version_executed') {
+            const tx = await transactionFromOutcome(outcome);
+            if (tx) tokenTransactionsStore(tx.token!).addTransactions([tx]);
+        } else if (outcome.status === 'expired') {
+            // Only this version expired. If a later version of the payment was signed meanwhile, its own check decides.
+            const stored = store.state.payments[gaslessPaymentKey(latest)];
+            if (stored && stored.id !== id) return;
+        }
+        store.settle(latest);
+    } catch (error) {
+        // Not final yet, or the chain could not be read. Keep the payment and check again on the next launch.
+        console.warn('Gasless payment outcome not final yet', id, error);
+    }
+}
+
+let resumed = false;
+/** Resumes the outcome checks of payments that were pending when the Wallet was closed. */
+export function resumePendingGaslessPayments() {
+    if (resumed || !isGaslessTransferConfigured()) return;
+    resumed = true;
+    for (const payment of Object.values(useGaslessPaymentsStore().state.payments)) {
+        settleInBackground(payment.latest, payment.id);
+    }
+}
+
+/**
+ * Relay error codes after which the relay did not store the version (sdk/README.md "What to do"). `conflict` and
+ * `nonce_used` are not among them: another version of the payment may execute.
+ */
+const RETRYABLE_RELAY_ERRORS = ['rate_limited', 'unavailable', 'internal_error'];
+const MAX_SUBMIT_ATTEMPTS = 4;
+
+/**
+ * Sends a gasless transfer from the active Polygon address.
+ *
+ * @param sign - Asks the user to sign the transfer, via the Hub and Keyguard. Resolves to null if the user cancels.
+ * @param corrects - When retrying a payment that failed (`GaslessTransferError.payment`), its latest signed version.
+ * @returns The mined transaction, or null if the user cancelled.
+ */
+export async function sendGaslessTransfer({ token, to, amount, recipientLabel, quote, corrects, sign }: {
+    token: string,
+    to: string,
+    amount: number,
+    recipientLabel?: string,
+    quote?: GaslessFeeQuote,
+    corrects?: TransferRequest,
+    sign: (request: Omit<SignPolygonGaslessTransferRequest, 'appName'>)
+        => Promise<SignedPolygonGaslessTransfer | null | void>,
+}): Promise<Transaction | null> {
+    const addressInfo = usePolygonAddressStore().addressInfo.value;
+    if (!addressInfo) throw new Error('No active Polygon address');
+    const from = addressInfo.address;
+
+    const [{ core, relay: relayModule }, pins, relay, contract] = await Promise.all([
+        loadSdk(),
+        getGaslessPins(),
+        getRelayClient(),
+        getTransferContract(),
+    ]);
+    const client = await getPolygonClient();
+    const store = useGaslessPaymentsStore();
+
+    if (!corrects) {
+        // A payment of the same token to the same recipient that failed as far as the user was told might still
+        // execute. Sending again is therefore a correction of it, which keeps its nonce, not a new payment.
+        corrects = Object.values(store.state.payments)
+            .filter(({ latest, status }) => status !== GaslessPaymentStatus.SUBMITTED
+                && core.sameAddress(latest.from, from)
+                && core.sameAddress(latest.token, token)
+                && core.sameAddress(latest.to, to))
+            .sort((a, b) => b.signedAt - a.signedAt)[0]?.latest;
+    }
+
+    if (corrects) {
+        // Before signing a new version of the payment, make sure that no version executed yet.
+        const used = await contract.nonceUsed(corrects.from, corrects.nonce) as boolean;
+        if (used) {
+            const id = core.transferDigest(pins.chainId, pins.transfer.address, corrects);
+            const outcome = await waitForTransferOutcome(client.provider, contract, pins, corrects, id, { relay });
+            store.settle(corrects);
+            if (outcome.status === 'executed' || outcome.status === 'other_version_executed') {
+                // The payment went through after all. Never sign again for it.
+                const tx = await transactionFromOutcome(outcome);
+                if (tx) tokenTransactionsStore(tx.token!).addTransactions([tx]);
+                throw new GaslessTransferError(
+                    'Your earlier payment to this recipient went through after all. No new payment was made.',
+                    null,
+                );
+            }
+            // The sender invalidated the nonce: no version can execute, and a new payment is safe.
+            corrects = undefined;
+        }
+    }
+
+    if (!quote || quote.token.toLowerCase() !== token.toLowerCase() || quote.expiresAt < Date.now() / 1000 + 10) {
+        quote = await quoteGaslessFee(token);
+    }
+    const fee = Number(quote.fee);
+
+    // Ensure to send only what is possible with the current fee
+    const balance = (token.toLowerCase() === useConfig().config.polygon.usdc.tokenContract.toLowerCase()
+        ? addressInfo.balanceUsdc
+        : addressInfo.balanceUsdtBridged) || 0;
+    amount = Math.min(amount, Math.max(balance - fee, 0));
+    if (amount <= 0) throw new GaslessTransferError('Insufficient balance to pay the fee', corrects || null);
+
+    const tokenNonce = await readPermitNonceAndCheckDomain(token, from);
+
+    const signed = await sign({
+        request: {
+            token,
+            from,
+            to,
+            amount: amount.toString(),
+            fee: quote.fee,
+            relay: quote.relay,
+        },
+        tokenNonce,
+        corrects,
+        recipientLabel,
+    });
+    if (!signed) return null;
+
+    // Make sure the signed transfer is the one we asked for, and valid for our pins
+    const request = core.normalizeTransferRequest(signed.request);
+    if (!core.sameAddress(request.token, token) || !core.sameAddress(request.from, from)
+        || !core.sameAddress(request.to, to) || request.amount !== amount.toString() || request.fee !== quote.fee
+        || !core.sameAddress(request.relay, quote.relay) || (corrects && request.nonce !== corrects.nonce)) {
+        throw new Error('The signed transfer does not match the requested transfer');
+    }
+    const body: SubmitTransferBody = core.buildSubmitTransferBody({
+        request,
+        signature: signed.signature,
+        authorization: signed.authorization as SubmitTransferBody['authorization'],
+        quoteId: quote.quoteId,
+    });
+    const id = core.transferDigest(pins.chainId, pins.transfer.address, request);
+
+    // Record the version as the payment's latest before submitting it
+    store.recordSigned(request, id);
+
+    try {
+        // Submit. After an unclear answer, post the identical body again: the relay answers a body it stored with 200.
+        let unclear = false;
+        for (let attempt = 1; ; attempt++) {
+            try {
+                await relay.submitTransfer(body, { repost: unclear }); // eslint-disable-line no-await-in-loop
+                store.setStatus(request, GaslessPaymentStatus.SUBMITTED);
+                break;
+            } catch (error) {
+                if (error instanceof relayModule.RelayApiError) {
+                    if (error.code === 'conflict' || error.code === 'nonce_used') {
+                        // Another version of this payment is stored or executed. Its outcome decides.
+                        settleInBackground(request, id);
+                        throw new GaslessTransferError(
+                            'Another version of this payment is pending. Please wait a few minutes before retrying.',
+                            request,
+                        );
+                    }
+                    if (!RETRYABLE_RELAY_ERRORS.includes(error.code)) {
+                        // The relay refused this version and did not store it
+                        settleInBackground(request, id);
+                        throw new GaslessTransferError(`The relay refused the transfer: ${error.message}`, request);
+                    }
+                    if (error.code === 'internal_error') unclear = true;
+                } else if (error instanceof relayModule.RelayClientError) {
+                    if (error.code === 'pin_mismatch') {
+                        settleInBackground(request, id);
+                        throw new GaslessTransferError('The relay does not match the Wallet\'s configuration', request);
+                    }
+                    unclear = true;
+                } else {
+                    // Validation errors before sending: nothing was sent in this attempt
+                    settleInBackground(request, id);
+                    throw new GaslessTransferError(error instanceof Error ? error.message : String(error), request);
+                }
+                if (attempt >= MAX_SUBMIT_ATTEMPTS) {
+                    settleInBackground(request, id);
+                    throw new GaslessTransferError(`Could not reach the relay: ${(error as Error).message}`, request);
+                }
+                await new Promise((resolve) => { window.setTimeout(resolve, 2000 * attempt); }); // eslint-disable-line
+            }
+        }
+
+        let txHash: string | null;
+        try {
+            const state = await relay.waitForRequest(id as `0x${string}`, { until: 'mined', timeoutMs: 3 * 60e3 });
+            txHash = state.txHash;
+        } catch (error) {
+            settleInBackground(request, id);
+            if (error instanceof relayModule.RelayRequestFailedError) {
+                throw new GaslessTransferError(
+                    `The transfer failed: ${error.state.error?.message || error.relayCode || error.message}`,
+                    request,
+                );
+            }
+            throw new GaslessTransferError(
+                'The transfer is still pending. It shows up in your history once it is included.',
+                request,
+            );
+        }
+
+        // Settle the payment once its block is final
+        settleInBackground(request, id);
+
+        const receipt = txHash ? await client.provider.getTransactionReceipt(txHash) : null;
+        if (!receipt) {
+            throw new GaslessTransferError('The transfer was sent, but its receipt is not available yet', request);
+        }
+        updatePolygonBalances(token, [from]);
+        return gaslessReceiptToTransaction(receipt, from);
+    } catch (error) {
+        if (error instanceof GaslessTransferError && error.payment) {
+            store.setStatus(error.payment, GaslessPaymentStatus.FAILED);
+        }
+        throw error;
+    }
+}
diff --git a/src/lib/usdc/GaslessOutcome.ts b/src/lib/usdc/GaslessOutcome.ts
new file mode 100644
index 000000000..53466aba8
--- /dev/null
+++ b/src/lib/usdc/GaslessOutcome.ts
@@ -0,0 +1,349 @@
+/* eslint-disable no-await-in-loop */
+import type { BigNumber, Contract, providers } from 'ethers';
+import type { ChainPins, TransferRequest } from '@nimiq/gasless-sdk/core';
+import type { RelayClient, RequestState, RequestStatus } from '@nimiq/gasless-sdk/relay';
+
+/**
+ * Port of the gasless SDK's `confirmOnChain` and `waitForTransferOutcome` (sdk/src/viem/confirm.ts and outcome.ts in
+ * https://github.com/NimiqToolbox/gas-abstraction) to ethers v5, which the Wallet uses instead of viem.
+ *
+ * Every version of a payment is signed with one intent nonce, and the contract executes at most one intent per
+ * (from, nonce). These checks therefore answer for the payment, not only for the given version, and read the chain
+ * directly without trusting the relay. Only an answer read at the finalized block allows signing a new payment.
+ */
+
+/** See OnChainStatus in the SDK. `pending` and `unresolved` are not final. */
+export type OnChainStatus = 'executed' | 'other_version_executed' | 'pending' | 'expired' | 'nonce_consumed'
+    | 'unresolved';
+
+export type ExecutedTransfer = Readonly<Omit<TransferRequest, 'deadline'>>;
+
+export interface OnChainConfirmation {
+    readonly status: OnChainStatus;
+    readonly txHash: string | null;
+    readonly blockNumber: number | null;
+    readonly executedTransfer: ExecutedTransfer | null;
+}
+
+export type TransferOutcome = OnChainConfirmation & {
+    readonly status: Exclude<OnChainStatus, 'pending' | 'unresolved'>,
+    readonly relayState: RequestState | null,
+};
+
+export type ConfirmBlockTag = 'latest' | 'safe' | 'finalized';
+
+/** The longest lifetime the SDK and relay accept (7200 s), plus 600 s for clocks and lagging nodes. */
+const SEARCH_BEFORE_DEADLINE_SECONDS = 7200 + 600;
+/** Blocks per eth_getLogs query at first; halved each time the RPC refuses a range. */
+const LOG_RANGE_BLOCKS = 1000;
+const MAX_DEADLINE_SECONDS = 7200;
+const FINALITY_SLACK_SECONDS = 1800;
+const MIN_DEFAULT_WAIT_SECONDS = 60;
+const DEFAULT_POLL_INTERVAL_MS = 4000;
+const DECIDED: readonly RequestStatus[] = ['mined', 'confirmed', 'failed', 'expired'];
+const FINAL: readonly OnChainStatus[] = ['executed', 'other_version_executed', 'expired', 'nonce_consumed'];
+
+interface Block {
+    readonly number: number;
+    readonly timestamp: number;
+    readonly hash: string;
+}
+
+interface Context {
+    readonly provider: providers.Provider;
+    readonly contract: Contract; // The pinned GaslessTransfer contract
+    readonly request: TransferRequest;
+}
+
+type NonceUse = { readonly kind: 'transfer', readonly transfer: ExecutedTransfer } | { readonly kind: 'invalidation' };
+
+function sameAddress(a: string, b: string) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+
+function nonceUseOf({ contract, request }: Context, log: providers.Log): NonceUse | undefined {
+    if (log.removed || !sameAddress(log.address, contract.address) || !log.topics.length) return undefined;
+    let event;
+    try {
+        event = contract.interface.parseLog(log);
+    } catch (error) {
+        return undefined;
+    }
+    if (event.name === 'TransferRelayed') {
+        const { args } = event;
+        if (!sameAddress(args.from, request.from) || (args.nonce as string).toLowerCase() !== request.nonce) {
+            return undefined;
+        }
+        return {
+            kind: 'transfer',
+            transfer: Object.freeze({
+                token: args.token,
+                from: args.from,
+                to: args.to,
+                amount: (args.amount as BigNumber).toString(),
+                fee: (args.fee as BigNumber).toString(),
+                relay: args.relay,
+                nonce: (args.nonce as string).toLowerCase() as TransferRequest['nonce'],
+            }),
+        };
+    }
+    if (event.name === 'NonceInvalidated') {
+        const { args } = event;
+        if (!sameAddress(args.signer, request.from) || (args.nonce as string).toLowerCase() !== request.nonce) {
+            return undefined;
+        }
+        return { kind: 'invalidation' };
+    }
+    return undefined;
+}
+
+function answerOf(use: NonceUse, request: TransferRequest, txHash: string, blockNumber: number): OnChainConfirmation {
+    if (use.kind === 'invalidation') {
+        return { status: 'nonce_consumed', txHash, blockNumber, executedTransfer: null };
+    }
+    const t = use.transfer;
+    const exact = sameAddress(t.token, request.token)
+        && sameAddress(t.to, request.to)
+        && t.amount === request.amount
+        && t.fee === request.fee
+        && sameAddress(t.relay, request.relay);
+    return { status: exact ? 'executed' : 'other_version_executed', txHash, blockNumber, executedTransfer: t };
+}
+
+function notUsed(status: 'pending' | 'expired' | 'unresolved'): OnChainConfirmation {
+    return { status, txHash: null, blockNumber: null, executedTransfer: null };
+}
+
+async function getBlock(provider: providers.Provider, blockTag: number | ConfirmBlockTag): Promise<Block> {
+    const block = await provider.getBlock(blockTag);
+    if (!block) throw new Error(`Block ${blockTag} not found`);
+    return block;
+}
+
+/**
+ * The lowest block number in [low, high.number] whose timestamp is at least `target`, or high.number + 1 if there is
+ * none. Interpolation steps alternate with bisection steps.
+ */
+async function firstBlockAtOrAfter(
+    provider: providers.Provider,
+    target: number,
+    low: number,
+    high: Block,
+): Promise<number> {
+    if (high.timestamp < target) return high.number + 1;
+    if (low >= high.number) return high.number;
+    let lo = low;
+    let loTs = (await getBlock(provider, lo)).timestamp;
+    if (loTs >= target) return lo;
+    let hi = high.number;
+    let hiTs = high.timestamp;
+    for (let step = 0; hi - lo > 1; step++) {
+        let mid = step % 2 === 0
+            ? lo + Math.floor(((target - loTs) * (hi - lo)) / (hiTs - loTs))
+            : lo + Math.floor((hi - lo) / 2);
+        if (mid <= lo) mid = lo + 1;
+        if (mid >= hi) mid = hi - 1;
+        const ts = (await getBlock(provider, mid)).timestamp;
+        if (ts >= target) {
+            hi = mid;
+            hiTs = ts;
+        } else {
+            lo = mid;
+            loTs = ts;
+        }
+    }
+    return hi;
+}
+
+/**
+ * The eth_getLogs filters of the event search, each matching only events the sender caused: its TransferRelayed
+ * events (any version of the payment; the nonce is compared in the log data) and its NonceInvalidated of this nonce.
+ */
+function searchFilters({ contract, request }: Context): string[][] {
+    const sender = `0x${request.from.slice(2).toLowerCase().padStart(64, '0')}`;
+    return [
+        [contract.interface.getEventTopic('TransferRelayed'), null as unknown as string, sender],
+        [contract.interface.getEventTopic('NonceInvalidated'), sender, request.nonce],
+    ];
+}
+
+async function firstNonceUse(
+    context: Context,
+    logs: readonly providers.Log[],
+    lo: number,
+    hi: number,
+): Promise<OnChainConfirmation | undefined> {
+    for (const log of logs) {
+        if (!log.transactionHash || typeof log.blockNumber !== 'number' || !log.blockHash) continue;
+        if (log.blockNumber < lo || log.blockNumber > hi) continue;
+        const use = nonceUseOf(context, log);
+        if (use) {
+            // Only canonical evidence may decide the outcome, as log responses can be cached across reorgs.
+            const canonical = await getBlock(context.provider, log.blockNumber);
+            if (canonical.hash.toLowerCase() === log.blockHash.toLowerCase()) {
+                return answerOf(use, context.request, log.transactionHash, log.blockNumber);
+            }
+        }
+    }
+    return undefined;
+}
+
+async function scan(
+    context: Context,
+    bounds: { readonly from: number, readonly to: number, readonly downward: boolean },
+    cursor: { range: number },
+): Promise<OnChainConfirmation | undefined> {
+    const filters = searchFilters(context);
+    let { from, to } = bounds;
+    while (from <= to) {
+        const size = cursor.range;
+        const lo = bounds.downward ? (to - from + 1 > size ? to - size + 1 : from) : from;
+        const hi = bounds.downward ? to : (to - from + 1 > size ? from + size - 1 : to);
+        let refused = false;
+        for (const topics of filters) {
+            let logs: providers.Log[];
+            try {
+                logs = await context.provider.getLogs({
+                    address: context.contract.address,
+                    topics,
+                    fromBlock: lo,
+                    toBlock: hi,
+                });
+            } catch (error) {
+                // Providers limit the range of one query, and differently: try half of it.
+                if (hi === lo) throw error;
+                cursor.range = Math.floor((hi - lo + 1) / 2);
+                refused = true;
+                break;
+            }
+            // At most one event uses a nonce, so the first match is the answer.
+            const answer = await firstNonceUse(context, logs, lo, hi);
+            if (answer) return answer;
+        }
+        if (refused) continue;
+        if (bounds.downward) to = lo - 1;
+        else from = hi + 1;
+    }
+    return undefined;
+}
+
+async function findNonceUse(context: Context, pins: ChainPins, block: Block): Promise<OnChainConfirmation | undefined> {
+    const floor = pins.deployBlock ?? 0;
+    const deadline = Number(context.request.deadline);
+    let from = await firstBlockAtOrAfter(context.provider, deadline - SEARCH_BEFORE_DEADLINE_SECONDS, floor, block);
+    if (from < floor) from = floor;
+    if (from > block.number) return undefined;
+    const executionEnd = block.timestamp <= deadline
+        ? block.number
+        : (await firstBlockAtOrAfter(context.provider, deadline + 1, from, block)) - 1;
+    const cursor = { range: LOG_RANGE_BLOCKS };
+    return (await scan(context, { from, to: executionEnd, downward: true }, cursor))
+        ?? scan(context, { from: executionEnd + 1, to: block.number, downward: false }, cursor);
+}
+
+/**
+ * Independent on-chain check of a payment at one block (default the latest). See `confirmOnChain` in the SDK.
+ */
+export async function confirmOnChain(
+    provider: providers.Provider,
+    contract: Contract,
+    pins: ChainPins,
+    request: TransferRequest,
+    options: { readonly txHash?: string, readonly blockTag?: ConfirmBlockTag } = {},
+): Promise<OnChainConfirmation> {
+    const { chainId } = await provider.getNetwork();
+    if (chainId !== pins.chainId) throw new Error(`Polygon client is on chain ${chainId}, expected ${pins.chainId}`);
+
+    const context: Context = { provider, contract, request };
+    const block = await getBlock(provider, options.blockTag || 'latest');
+    const deadline = Number(request.deadline);
+    if (pins.deployBlock !== null && block.number < pins.deployBlock) {
+        return notUsed(block.timestamp > deadline ? 'expired' : 'pending');
+    }
+    const used = await contract.nonceUsed(request.from, request.nonce, { blockTag: block.number }) as boolean;
+    if (!used) return notUsed(block.timestamp > deadline ? 'expired' : 'pending');
+
+    // The nonce is used: by this intent, by another version of the payment, or by the sender's invalidation.
+    if (options.txHash) {
+        const receipt = await provider.getTransactionReceipt(options.txHash);
+        // A replaced (sped-up) transaction has no receipt; fall back to the event search.
+        if (receipt && receipt.status === 1 && receipt.blockNumber <= block.number) {
+            const canonical = receipt.blockNumber === block.number
+                ? block
+                : await getBlock(provider, receipt.blockNumber);
+            if (canonical.hash.toLowerCase() === receipt.blockHash.toLowerCase()) {
+                for (const log of receipt.logs) {
+                    if (log.blockHash.toLowerCase() !== receipt.blockHash.toLowerCase()) continue;
+                    const use = nonceUseOf(context, log);
+                    if (use) return answerOf(use, request, receipt.transactionHash, receipt.blockNumber);
+                }
+            }
+        }
+    }
+    return (await findNonceUse(context, pins, block)) ?? notUsed('unresolved');
+}
+
+/**
+ * Waits until the chain shows the payment executed (by this or another version), expired or its nonce consumed, read
+ * at the finalized block by default. Pass the payment's latest version. The relay only says when reading the chain is
+ * worthwhile, and its txHash saves the log search. See `waitForTransferOutcome` in the SDK.
+ */
+export async function waitForTransferOutcome(
+    provider: providers.Provider,
+    contract: Contract,
+    pins: ChainPins,
+    request: TransferRequest,
+    id: string,
+    options: {
+        readonly relay?: RelayClient,
+        readonly blockTag?: ConfirmBlockTag,
+        readonly pollIntervalMs?: number,
+        readonly timeoutMs?: number,
+    } = {},
+): Promise<TransferOutcome> {
+    const blockTag = options.blockTag || 'finalized';
+    const pollIntervalMs = options.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS;
+    const now = () => Math.floor(Date.now() / 1000);
+    const deadline = Number(request.deadline);
+    const start = now();
+    const lastDeadline = Math.min(deadline, start + MAX_DEADLINE_SECONDS);
+    const giveUpAt = Date.now()
+        + (options.timeoutMs
+            ?? Math.max(MIN_DEFAULT_WAIT_SECONDS, lastDeadline + FINALITY_SLACK_SECONDS - start) * 1000);
+
+    let relayState: RequestState | null = null;
+    let unresolved = false;
+    for (;;) {
+        // Before the deadline, the chain is only read once the relay reports a decision or does not answer. After the
+        // deadline, on every poll.
+        let readChain = now() > deadline;
+        if (options.relay && !readChain) {
+            try {
+                relayState = await options.relay.getRequest(id as `0x${string}`);
+                readChain = DECIDED.includes(relayState.status);
+            } catch (error) {
+                readChain = true;
+            }
+        } else if (!options.relay) {
+            readChain = true;
+        }
+
+        if (readChain) {
+            const confirmation = await confirmOnChain(provider, contract, pins, request, {
+                txHash: relayState?.txHash || undefined,
+                blockTag,
+            });
+            if (FINAL.includes(confirmation.status)) {
+                return { ...confirmation, relayState } as TransferOutcome;
+            }
+            unresolved = confirmation.status === 'unresolved';
+        }
+
+        if (Date.now() >= giveUpAt) {
+            throw new Error(`The outcome of transfer ${id} is not final yet${unresolved
+                ? ': its nonce is used, but the event that used it was not found'
+                : ''}; do not sign again for this payment`);
+        }
+        await new Promise((resolve) => { window.setTimeout(resolve, pollIntervalMs); });
+    }
+}
diff --git a/src/main.ts b/src/main.ts
index 57049c99a..500330356 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -15,6 +15,7 @@ import { initHubApi, syncFromHub } from './hub';
 import { launchNetwork } from './network';
 import { launchElectrum } from './electrum';
 import { launchPolygon } from './ethers';
+import { resumePendingGaslessPayments } from './lib/usdc/Gasless';
 import { initMatomo } from './matomo';
 import { useAccountStore } from './stores/Account';
 import { useFiatStore } from './stores/Fiat';
@@ -143,6 +144,7 @@ async function start() {
     watch(() => {
         if (!config.polygon.enabled) return;
         launchPolygon();
+        resumePendingGaslessPayments();
     });
 
     // Watch for currency and address changes to recalculate staking fiat values
diff --git a/src/router.ts b/src/router.ts
index ef68dd8a0..262002b09 100644
--- a/src/router.ts
+++ b/src/router.ts
@@ -67,7 +67,7 @@ const BtcTransactionModal = () =>
 // Stablecoin Modals
 const PolygonActivationModal = () =>
     import(/* webpackChunkName: "polygon-activation-modal" */ './components/modals/PolygonActivationModal.vue');
-const StablecoinSendModal = () => (Config.polygon.isGasAbstractionUnderMaintenance
+const StablecoinSendModal = () => (Config.polygon.isGaslessTransferUnderMaintenance
     ? import(/* webpackChunkName: "warning-modal" */ './components/modals/WarningModal.vue')
         .then(({ createWarningModal }) => createWarningModal(() => ({
             title: i18n.t('Gas abstraction is under maintenance') as string,
@@ -747,7 +747,7 @@ router.beforeEach(createActivationNavigationGuard(
 router.beforeEach(createActivationNavigationGuard(
     CryptoCurrency.USDC,
     new Set([
-        ...(Config.polygon.isGasAbstractionUnderMaintenance ? [] : [StablecoinSendModal]),
+        ...(Config.polygon.isGaslessTransferUnderMaintenance ? [] : [StablecoinSendModal]),
         StablecoinReceiveModal,
     ]),
     (accountType: AccountType) => [AccountType.BIP39].includes(accountType),
@@ -756,7 +756,7 @@ router.beforeEach(createActivationNavigationGuard(
 router.beforeEach(createActivationNavigationGuard(
     CryptoCurrency.USDT,
     new Set([
-        ...(Config.polygon.isGasAbstractionUnderMaintenance ? [] : [StablecoinSendModal]),
+        ...(Config.polygon.isGaslessTransferUnderMaintenance ? [] : [StablecoinSendModal]),
         StablecoinReceiveModal,
     ]),
     (accountType: AccountType) => [AccountType.BIP39].includes(accountType),
diff --git a/src/storage.ts b/src/storage.ts
index 5dbd8b97d..82b9ea35c 100644
--- a/src/storage.ts
+++ b/src/storage.ts
@@ -20,6 +20,7 @@ import { useUsdcTransactionsStore } from './stores/UsdcTransactions';
 import { useUsdtContactsStore } from './stores/UsdtContacts';
 import { useUsdtTransactionsStore } from './stores/UsdtTransactions';
 import { useSwapsStore } from './stores/Swaps';
+import { useGaslessPaymentsStore } from './stores/GaslessPayments';
 import { useBankStore } from './stores/Bank';
 import { useKycStore } from './stores/Kyc';
 import { useStakingStore } from './stores/Staking';
@@ -43,6 +44,7 @@ const StorageKeys = {
     USDCTRANSACTIONS: 'wallet_usdctransactions_v01',
     USDTTRANSACTIONS: 'wallet_usdttransactions_v01',
     SWAPS: 'wallet_swaps_v01',
+    GASLESSPAYMENTS: 'wallet_gaslesspayments_v00',
     BANK: 'wallet_bank_v01',
     KYC: 'wallet_kyc_v00',
     STAKING: 'wallet_staking_v00',
@@ -188,6 +190,7 @@ export async function initStorage() {
             });
         }),
         initStoreStore(useSwapsStore(), StorageKeys.SWAPS),
+        initStoreStore(useGaslessPaymentsStore(), StorageKeys.GASLESSPAYMENTS),
         initStoreStore(useBankStore(), StorageKeys.BANK),
         initStoreStore(
             useKycStore(),
diff --git a/src/stores/GaslessPayments.ts b/src/stores/GaslessPayments.ts
new file mode 100644
index 000000000..fc19f776e
--- /dev/null
+++ b/src/stores/GaslessPayments.ts
@@ -0,0 +1,68 @@
+import Vue from 'vue';
+import { createStore } from 'pinia';
+import type { TransferRequest } from '@nimiq/gasless-sdk/core';
+
+/**
+ * Gasless USDC/USDT0 payments whose outcome is not final yet.
+ *
+ * Every version of a payment (e.g. re-signed with a higher fee) keeps the payment's intent nonce, so that at most one
+ * version executes. To never let the user pay twice, the latest signed version of each payment is recorded as soon as
+ * it is signed, before it is submitted, and kept until the chain shows at the finalized block that the payment either
+ * executed or can no longer execute. Only the signed fields are stored, never signatures or the token permit.
+ */
+export enum GaslessPaymentStatus {
+    /** Signed, but not (yet) known to be stored by the relay. */
+    SIGNED = 'signed',
+    /** Stored by the relay, and on its way to be executed. */
+    SUBMITTED = 'submitted',
+    /**
+     * Sending this version failed, as far as the user was told. It might still execute, though. The next send of the
+     * same token to the same recipient is therefore a correction of it, with the same nonce.
+     */
+    FAILED = 'failed',
+}
+
+export interface GaslessPayment {
+    /** The payment's latest signed version. */
+    latest: TransferRequest;
+    /** EIP-712 digest of `latest`, the relay request id. */
+    id: string;
+    status: GaslessPaymentStatus;
+    /** Unix milliseconds */
+    signedAt: number;
+}
+
+/** Keyed by sender and intent nonce, which identify a payment. */
+export function gaslessPaymentKey(request: Pick<TransferRequest, 'from' | 'nonce'>) {
+    return `${request.from.toLowerCase()}-${request.nonce.toLowerCase()}`;
+}
+
+export const useGaslessPaymentsStore = createStore({
+    id: 'gaslessPayments',
+    state: () => ({
+        payments: {} as Record<string, GaslessPayment>,
+    }),
+    getters: {
+        payments: (state): Readonly<Record<string, GaslessPayment>> => state.payments,
+    },
+    actions: {
+        /** Records a newly signed version of a payment, replacing an earlier version of it. */
+        recordSigned(latest: TransferRequest, id: string) {
+            Vue.set(this.state.payments, gaslessPaymentKey(latest), {
+                latest,
+                id,
+                status: GaslessPaymentStatus.SIGNED,
+                signedAt: Date.now(),
+            });
+        },
+        setStatus(request: Pick<TransferRequest, 'from' | 'nonce'>, status: GaslessPaymentStatus) {
+            const payment = this.state.payments[gaslessPaymentKey(request)];
+            if (!payment) return;
+            Vue.set(this.state.payments, gaslessPaymentKey(request), { ...payment, status });
+        },
+        /** Removes a payment once its outcome is final. */
+        settle(request: Pick<TransferRequest, 'from' | 'nonce'>) {
+            Vue.delete(this.state.payments, gaslessPaymentKey(request));
+        },
+    },
+});
diff --git a/tsconfig.json b/tsconfig.json
index a9e5af3f9..60700a54e 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -20,6 +20,9 @@
       "@/*": [
         "src/*"
       ],
+      "@nimiq/gasless-sdk/*": [
+        "node_modules/@nimiq/gasless-sdk/dist/*/index.d.ts"
+      ],
       "config": [
         "src/config/config.local.ts"
       ]
diff --git a/tsconfig.local.json b/tsconfig.local.json
index 9b442f989..4082cfdff 100644
--- a/tsconfig.local.json
+++ b/tsconfig.local.json
@@ -2,6 +2,9 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "paths": {
+      "@nimiq/gasless-sdk/*": [
+        "node_modules/@nimiq/gasless-sdk/dist/*/index.d.ts"
+      ],
       "config": [
         "src/config/config.local.ts"
       ]
diff --git a/tsconfig.mainnet.json b/tsconfig.mainnet.json
index b0da0bca6..99d81393f 100644
--- a/tsconfig.mainnet.json
+++ b/tsconfig.mainnet.json
@@ -2,6 +2,9 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "paths": {
+      "@nimiq/gasless-sdk/*": [
+        "node_modules/@nimiq/gasless-sdk/dist/*/index.d.ts"
+      ],
       "config": [
         "src/config/config.mainnet.ts"
       ]
diff --git a/tsconfig.testnet.json b/tsconfig.testnet.json
index d50e2234e..613868bfc 100644
--- a/tsconfig.testnet.json
+++ b/tsconfig.testnet.json
@@ -2,6 +2,9 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "paths": {
+      "@nimiq/gasless-sdk/*": [
+        "node_modules/@nimiq/gasless-sdk/dist/*/index.d.ts"
+      ],
       "config": [
         "src/config/config.testnet.ts"
       ]
diff --git a/yarn.lock b/yarn.lock
index 78bc02413..56b2afe6a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1495,6 +1495,9 @@
   resolved "https://registry.yarnpkg.com/@nimiq/fastspot-api/-/fastspot-api-1.10.3.tgz#9a4b6c5594708f3dd76f8bf1b0fd189ca886dbce"
   integrity sha512-CUkIAcF7R3OlN45idB+yC9Wnuz2YXTPx25xYswCdmbMGu/EGZFNnGHLIe6HkbHd8Eh+uBrwqBmLZGm8jyQ9+6A==
 
+"@nimiq/gasless-sdk@file:../gas-abstraction/sdk":
+  version "0.1.0"
+
 "@nimiq/hub-api@^1.15.0":
   version "1.15.0"
   resolved "https://registry.yarnpkg.com/@nimiq/hub-api/-/hub-api-1.15.0.tgz#d655a6554c6710d63d772ed3492c5b1145d04574"