Sponsor Gas Fees on Cosmos

This guide demonstrates how to implement gas sponsorship on Cosmos networks using fee grants. Unlike EVM chains that use account abstraction for gasless transactions, Cosmos networks natively support gas sponsorship through fee grants, allowing a grantor address to pay for another account’s transaction fees.

Prerequisites

Understanding Fee Grants

Fee grants in Cosmos allow one account (grantor) to pay transaction fees for another account (grantee). This mechanism provides native gas sponsorship without requiring smart contracts or account abstraction. Key concepts:

Grantor: The account that pays for gas fees
Grantee: The account whose transactions are sponsored
Allowance: Defines spending limits and expiration for the grant

Only one fee grant is allowed per granter-grantee pair. Self-grants are not permitted.

Creating a Basic Fee Grant

Create a basic allowance to grant gas sponsorship to another address:

import { MsgGrantAllowance } from "cosmjs-types/cosmos/feegrant/v1beta1/tx";
import { BasicAllowance } from "cosmjs-types/cosmos/feegrant/v1beta1/feegrant";

const granterAddress = paraSigner.address; // From your Para signer setup
const granteeAddress = "cosmos1grantee..."; // Replace with actual grantee address

// Create basic allowance with spending limits
const basicAllowance = BasicAllowance.fromPartial({
  spendLimit: [{
    denom: "uatom",
    amount: "1000000" // 1 ATOM limit
  }],
  expiration: {
    seconds: BigInt(Math.floor(Date.now() / 1000) + 86400), // 24 hours from now
    nanos: 0
  }
});

// Create the grant message
const grantMsg = {
  typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
  value: MsgGrantAllowance.fromPartial({
    granter: granterAddress,
    grantee: granteeAddress,
    allowance: {
      typeUrl: "/cosmos.feegrant.v1beta1.BasicAllowance",
      value: BasicAllowance.encode(basicAllowance).finish()
    }
  })
};

// Sign and broadcast the grant transaction
const result = await client.signAndBroadcast(
  granterAddress,
  [grantMsg],
  "auto", // Let the client estimate gas
  "Granting fee allowance"
);

Using Fee Grants as a Grantee

Once a fee grant is established, the grantee can perform transactions with sponsored gas fees:

// Create a signer for the grantee
const granteeSigner = createParaProtoSigner({ para: granteeParaInstance, prefix: "cosmos" });
const granteeClient = await SigningStargateClient.connectWithSigner(rpcUrl, granteeSigner);

// Send tokens with sponsored gas
const result = await granteeClient.sendTokens(
  granteeAddress,
  "cosmos1recipient...",
  [{ denom: "uatom", amount: "100000" }], // 0.1 ATOM
  {
    amount: [{ denom: "uatom", amount: "5000" }],
    gas: "200000",
    granter: granterAddress // This tells the network to use the fee grant
  }
);

Querying Fee Grants

Check existing grants before creating new ones:

// Query grants for a specific grantee
const grantsByGrantee = await fetch(
  `${restUrl}/cosmos/feegrant/v1beta1/allowances/${granteeAddress}`
).then(res => res.json());

// Query all grants by a specific granter
const grantsByGranter = await fetch(
  `${restUrl}/cosmos/feegrant/v1beta1/issued/${granterAddress}`
).then(res => res.json());

// Query a specific grant
const specificGrant = await fetch(
  `${restUrl}/cosmos/feegrant/v1beta1/allowance/${granterAddress}/${granteeAddress}`
).then(res => res.json());

Other Allowance Types

Periodic Allowance

Resets spending limits periodically:

import { PeriodicAllowance } from "cosmjs-types/cosmos/feegrant/v1beta1/feegrant";

const periodicAllowance = PeriodicAllowance.fromPartial({
  basic: {
    spendLimit: [{
      denom: "uatom",
      amount: "10000000" // 10 ATOM total limit
    }],
    expiration: null // No expiration
  },
  period: { seconds: BigInt(86400), nanos: 0 }, // 24 hours
  periodSpendLimit: [{
    denom: "uatom",
    amount: "1000000" // 1 ATOM per period
  }]
});

Allowed Message Allowance

Restricts which message types can be sponsored:

import { AllowedMsgAllowance } from "cosmjs-types/cosmos/feegrant/v1beta1/feegrant";

const allowedMsgAllowance = AllowedMsgAllowance.fromPartial({
  allowance: {
    typeUrl: "/cosmos.feegrant.v1beta1.BasicAllowance",
    value: BasicAllowance.encode(basicAllowance).finish()
  },
  allowedMessages: [
    "/cosmos.bank.v1beta1.MsgSend",
    "/cosmos.staking.v1beta1.MsgDelegate"
  ]
});

Revoking Fee Grants

Remove a fee grant when it’s no longer needed:

import { MsgRevokeAllowance } from "cosmjs-types/cosmos/feegrant/v1beta1/tx";

const revokeMsg = {
  typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
  value: MsgRevokeAllowance.fromPartial({
    granter: granterAddress,
    grantee: granteeAddress
  })
};

const result = await client.signAndBroadcast(
  granterAddress,
  [revokeMsg],
  "auto"
);

Advanced: Server-Controlled Gas Sponsorship

For production applications, use server-side controlled wallets as grantors while allowing users to authenticate client-side as grantees. This pattern uses Para’s pregenerated wallets to create an app-controlled grantor wallet.

Server-Side Setup

Create and manage a grantor wallet on your server:

// server.ts
import { Para } from "@getpara/server-sdk";
import { SigningStargateClient } from "@cosmjs/stargate";
import { createParaProtoSigner } from "@getpara/cosmjs-adapter";

const serverPara = new Para(process.env.PARA_API_KEY);

// Create a pregen wallet for gas sponsorship
const grantorWallet = await serverPara.createPregenWallet({
  type: 'COSMOS',
  pregenId: { customId: "app-gas-sponsor-wallet" }
});

// Store the user share securely
const userShare = await serverPara.getUserShare();
// Store userShare in your secure database

API Endpoint for Creating Grants

// POST /api/create-fee-grant
async function createFeeGrantForUser(userAddress: string) {
  // Load the grantor wallet
  await serverPara.setUserShare(storedUserShare);
  
  // Set up Cosmos client
  const granterSigner = createParaProtoSigner({ para: serverPara, prefix: "cosmos" });
  const client = await SigningStargateClient.connectWithSigner(rpcUrl, granterSigner);
  
  // Check if grant already exists
  const existingGrant = await fetch(
    `${restUrl}/cosmos/feegrant/v1beta1/allowance/${granterSigner.address}/${userAddress}`
  ).then(res => res.json());
  
  if (existingGrant.allowance) {
    // Revoke existing grant first
    const revokeMsg = {
      typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
      value: MsgRevokeAllowance.fromPartial({
        granter: granterSigner.address,
        grantee: userAddress
      })
    };
    
    await client.signAndBroadcast(
      granterSigner.address,
      [revokeMsg],
      "auto"
    );
  }
  
  // Create new grant with daily limit
  const basicAllowance = BasicAllowance.fromPartial({
    spendLimit: [{
      denom: "uatom",
      amount: "1000000" // 1 ATOM daily limit
    }],
    expiration: {
      seconds: BigInt(Math.floor(Date.now() / 1000) + 86400),
      nanos: 0
    }
  });

  const grantMsg = {
    typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
    value: MsgGrantAllowance.fromPartial({
      granter: granterSigner.address,
      grantee: userAddress,
      allowance: {
        typeUrl: "/cosmos.feegrant.v1beta1.BasicAllowance",
        value: BasicAllowance.encode(basicAllowance).finish()
      }
    })
  };

  const result = await client.signAndBroadcast(
    granterSigner.address,
    [grantMsg],
    "auto"
  );
  
  return {
    transactionHash: result.transactionHash,
    granterAddress: granterSigner.address
  };
}

Client-Side Integration

import { useState } from "react";
import { useParaCosmjsProtoSigner } from "@getpara/react-sdk/cosmos";
import { SigningStargateClient } from "@cosmjs/stargate";

const RPC_URL = "https://rpc.cosmos.directory/cosmoshub";

function MyApp() {
  const { protoSigner, isLoading } = useParaCosmjsProtoSigner();
  const [granterAddress, setGranterAddress] = useState<string>();

  const address = protoSigner?.address;

  const setupGasSponsorship = async () => {
    if (!address) return;

    const response = await fetch('/api/create-fee-grant', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ userAddress: address })
    });

    const { granterAddress: granter } = await response.json();
    setGranterAddress(granter);
  };

  const performSponsoredTransaction = async (recipientAddress: string, amount: string) => {
    if (!protoSigner || !address || !granterAddress) return;

    const client = await SigningStargateClient.connectWithSigner(RPC_URL, protoSigner);

    const result = await client.sendTokens(
      address,
      recipientAddress,
      [{ denom: "uatom", amount }],
      {
        amount: [{ denom: "uatom", amount: "5000" }],
        gas: "200000",
        granter: granterAddress
      }
    );

    return result.transactionHash;
  };

  if (isLoading) return <div>Loading...</div>;

  return (
    <>
      <p>Address: {address}</p>
      <button onClick={setupGasSponsorship}>
        Activate Gas Sponsorship
      </button>
      <button onClick={() => performSponsoredTransaction("cosmos1...", "100000")}>
        Send Sponsored Transaction
      </button>
    </>
  );
}

Complete Server Implementation

// Complete server implementation with grant management
class FeeGrantService {
  private serverPara: Para;
  private granterAddress?: string;
  
  constructor() {
    this.serverPara = new Para(process.env.PARA_API_KEY);
  }
  
  async initialize() {
    // Load or create grantor wallet
    const userShare = await loadUserShareFromDatabase();
    await this.serverPara.setUserShare(userShare);
    
    const signer = createParaProtoSigner({ para: this.serverPara, prefix: "cosmos" });
    this.granterAddress = signer.address;
  }
  
  async createGrant(userAddress: string, limitAmount: string, periodSeconds: number) {
    const signer = createParaProtoSigner({ para: this.serverPara, prefix: "cosmos" });
    const client = await SigningStargateClient.connectWithSigner(rpcUrl, signer);
    
    const allowance = BasicAllowance.fromPartial({
      spendLimit: [{
        denom: "uatom",
        amount: limitAmount
      }],
      expiration: {
        seconds: BigInt(Math.floor(Date.now() / 1000) + periodSeconds),
        nanos: 0
      }
    });
    
    const msg = {
      typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
      value: MsgGrantAllowance.fromPartial({
        granter: this.granterAddress,
        grantee: userAddress,
        allowance: {
          typeUrl: "/cosmos.feegrant.v1beta1.BasicAllowance",
          value: BasicAllowance.encode(allowance).finish()
        }
      })
    };
    
    return client.signAndBroadcast(this.granterAddress, [msg], "auto");
  }
  
  async revokeGrant(userAddress: string) {
    const signer = createParaProtoSigner({ para: this.serverPara, prefix: "cosmos" });
    const client = await SigningStargateClient.connectWithSigner(rpcUrl, signer);
    
    const msg = {
      typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
      value: MsgRevokeAllowance.fromPartial({
        granter: this.granterAddress,
        grantee: userAddress
      })
    };
    
    return client.signAndBroadcast(this.granterAddress, [msg], "auto");
  }
}

Best Practices

Set appropriate spending limits based on expected transaction volume
Use expiration times to automatically clean up unused grants
Monitor grant usage to control costs and detect abuse
Consider using periodic allowances for regular users
Use allowed message allowances to restrict transaction types
Remember that creating and revoking grants also incur gas costs

Fee grants provide native gas sponsorship on Cosmos networks without requiring smart contracts, making them more efficient than EVM account abstraction solutions.

​Prerequisites

​Understanding Fee Grants

​Creating a Basic Fee Grant

​Using Fee Grants as a Grantee

​Querying Fee Grants

​Other Allowance Types

​Periodic Allowance

​Allowed Message Allowance

​Revoking Fee Grants

​Advanced: Server-Controlled Gas Sponsorship

​Server-Side Setup

​API Endpoint for Creating Grants

​Client-Side Integration

​Complete Server Implementation

​Best Practices

Prerequisites

Understanding Fee Grants

Creating a Basic Fee Grant

Using Fee Grants as a Grantee

Querying Fee Grants

Other Allowance Types

Periodic Allowance

Allowed Message Allowance

Revoking Fee Grants

Advanced: Server-Controlled Gas Sponsorship

Server-Side Setup

API Endpoint for Creating Grants

Client-Side Integration

Complete Server Implementation

Best Practices