@aastar/paymaster 0.16.7

package/dist/core/src/actions/tokens.d.ts

@@ -0,0 +1,229 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type TokenActions = {
+    tokenTotalSupply: (args: {
+        token: Address;
+    }) => Promise<bigint>;
+    tokenBalanceOf: (args: {
+        token: Address;
+        account: Address;
+    }) => Promise<bigint>;
+    tokenCap: (args: {
+        token: Address;
+    }) => Promise<bigint>;
+    tokenRemainingMintableSupply: (args: {
+        token: Address;
+    }) => Promise<bigint>;
+    tokenTransfer: (args: {
+        token: Address;
+        to: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenTransferFrom: (args: {
+        token: Address;
+        from: Address;
+        to: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenApprove: (args: {
+        token: Address;
+        spender: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenAllowance: (args: {
+        token: Address;
+        owner: Address;
+        spender: Address;
+    }) => Promise<bigint>;
+    tokenMint: (args: {
+        token: Address;
+        to: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenBurn: (args: {
+        token: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenBurnFrom: (args: {
+        token: Address;
+        from: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenName: (args: {
+        token: Address;
+    }) => Promise<string>;
+    tokenSymbol: (args: {
+        token: Address;
+    }) => Promise<string>;
+    tokenDecimals: (args: {
+        token: Address;
+    }) => Promise<number>;
+    tokenOwner: (args: {
+        token: Address;
+    }) => Promise<Address>;
+    tokenTransferTokenOwnership: (args: {
+        token: Address;
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenRenounceOwnership: (args: {
+        token: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenUpdateExchangeRate: (args: {
+        token: Address;
+        newRate: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenGetDebt: (args: {
+        token: Address;
+        user: Address;
+    }) => Promise<bigint>;
+    tokenRepayDebt: (args: {
+        token: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenTransferAndCall: (args: {
+        token: Address;
+        to: Address;
+        amount: bigint;
+        data?: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenAddAutoApprovedSpender: (args: {
+        token: Address;
+        spender: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenRemoveAutoApprovedSpender: (args: {
+        token: Address;
+        spender: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenIsAutoApprovedSpender: (args: {
+        token: Address;
+        spender: Address;
+    }) => Promise<boolean>;
+    tokenSUPERPAYMASTER_ADDRESS: (args: {
+        token: Address;
+    }) => Promise<Address>;
+    tokenFACTORY: (args: {
+        token: Address;
+    }) => Promise<Address>;
+    tokenTransferOwnership: (args: {
+        token: Address;
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenTransferCommunityOwnership: (args: {
+        token: Address;
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenCommunityName: (args: {
+        token: Address;
+    }) => Promise<string>;
+    tokenCommunityENS: (args: {
+        token: Address;
+    }) => Promise<string>;
+    tokenExchangeRate: (args: {
+        token: Address;
+    }) => Promise<bigint>;
+    tokenSpendingLimits: (args: {
+        token: Address;
+        user: Address;
+    }) => Promise<bigint>;
+    tokenDefaultSpendingLimitXPNTs: (args: {
+        token: Address;
+    }) => Promise<bigint>;
+    tokenCumulativeSpent: (args: {
+        token: Address;
+        user: Address;
+    }) => Promise<bigint>;
+    tokenDebts: (args: {
+        token: Address;
+        user: Address;
+    }) => Promise<bigint>;
+    tokenUsedOpHashes: (args: {
+        token: Address;
+        hash: Hex;
+    }) => Promise<boolean>;
+    tokenDOMAIN_SEPARATOR: (args: {
+        token: Address;
+    }) => Promise<Hex>;
+    tokenNonces: (args: {
+        token: Address;
+        owner: Address;
+    }) => Promise<bigint>;
+    tokenPermit: (args: {
+        token: Address;
+        owner: Address;
+        spender: Address;
+        value: bigint;
+        deadline: bigint;
+        v: number;
+        r: Hex;
+        s: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenAutoApprovedSpenders: (args: {
+        token: Address;
+        spender: Address;
+    }) => Promise<boolean>;
+    tokenBurnFromWithOpHash: (args: {
+        token: Address;
+        account: Address;
+        amount: bigint;
+        opHash: Hex;
+        userOpAccount?: Account | Address;
+    }) => Promise<Hash>;
+    tokenCommunityOwner: (args: {
+        token: Address;
+    }) => Promise<Address>;
+    tokenEip712Domain: (args: {
+        token: Address;
+    }) => Promise<any>;
+    tokenGetDefaultSpendingLimitXPNTs: (args: {
+        token: Address;
+    }) => Promise<bigint>;
+    tokenGetMetadata: (args: {
+        token: Address;
+    }) => Promise<string>;
+    tokenNeedsApproval: (args: {
+        token: Address;
+        owner: Address;
+        spender: Address;
+        amount: bigint;
+    }) => Promise<boolean>;
+    tokenRecordDebt: (args: {
+        token: Address;
+        user: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenDEFAULT_SPENDING_LIMIT_APNTS: (args: {
+        token: Address;
+    }) => Promise<bigint>;
+    tokenSetPaymasterLimit: (args: {
+        token: Address;
+        user: Address;
+        limit: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenSetSuperPaymasterAddress: (args: {
+        token: Address;
+        superPaymaster: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    tokenVersion: (args: {
+        token: Address;
+    }) => Promise<string>;
+};
+export declare const gTokenActions: () => (client: PublicClient | WalletClient) => TokenActions;
+export declare const tokenActions: () => (client: PublicClient | WalletClient) => TokenActions;

package/dist/core/src/actions/tokens.js

@@ -0,0 +1,415 @@
+import { GTokenABI, xPNTsTokenABI } from '../abis/index.js';
+function getTokenABI(token) {
+    // Auto-detect ABI based on token type or use generic xPNTsTokenABI
+    return xPNTsTokenABI;
+}
+export const gTokenActions = () => (client) => ({
+    // Use GTokenABI for everything
+    ...tokenActions()(client),
+    async tokenTotalSupply({ token }) {
+        return client.readContract({ address: token, abi: GTokenABI, functionName: 'totalSupply', args: [] });
+    },
+    async tokenBalanceOf({ token, account }) {
+        return client.readContract({ address: token, abi: GTokenABI, functionName: 'balanceOf', args: [account] });
+    },
+    async tokenTransfer({ token, to, amount, account }) {
+        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'transfer', args: [to, amount], account: account, chain: client.chain });
+    },
+    async tokenTransferFrom({ token, from, to, amount, account }) {
+        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'transferFrom', args: [from, to, amount], account: account, chain: client.chain });
+    },
+    async tokenApprove({ token, spender, amount, account }) {
+        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'approve', args: [spender, amount], account: account, chain: client.chain });
+    },
+    async tokenAllowance({ token, owner, spender }) {
+        return client.readContract({ address: token, abi: GTokenABI, functionName: 'allowance', args: [owner, spender] });
+    },
+    async tokenMint({ token, to, amount, account }) {
+        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'mint', args: [to, amount], account: account, chain: client.chain });
+    },
+    async tokenBurn({ token, amount, account }) {
+        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'burn', args: [amount], account: account, chain: client.chain });
+    },
+    async tokenBurnFrom({ token, from, amount, account }) {
+        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'burnFrom', args: [from, amount], account: account, chain: client.chain });
+    },
+    async tokenName({ token }) {
+        return client.readContract({ address: token, abi: GTokenABI, functionName: 'name', args: [] });
+    },
+    async tokenSymbol({ token }) {
+        return client.readContract({ address: token, abi: GTokenABI, functionName: 'symbol', args: [] });
+    },
+    async tokenDecimals({ token }) {
+        return client.readContract({ address: token, abi: GTokenABI, functionName: 'decimals', args: [] });
+    },
+    async tokenOwner({ token }) {
+        return client.readContract({ address: token, abi: GTokenABI, functionName: 'owner', args: [] });
+    },
+    async tokenTransferTokenOwnership({ token, newOwner, account }) {
+        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'transferOwnership', args: [newOwner], account: account, chain: client.chain });
+    },
+    async tokenRenounceOwnership({ token, account }) {
+        return client.writeContract({ address: token, abi: GTokenABI, functionName: 'renounceOwnership', args: [], account: account, chain: client.chain });
+    },
+    async tokenCap({ token }) {
+        return client.readContract({ address: token, abi: GTokenABI, functionName: 'cap', args: [] });
+    },
+    async tokenRemainingMintableSupply({ token }) {
+        return client.readContract({ address: token, abi: GTokenABI, functionName: 'remainingMintableSupply', args: [] });
+    },
+});
+export const tokenActions = () => (client) => ({
+    // ERC20 Standard
+    async tokenTotalSupply({ token }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'totalSupply',
+            args: []
+        });
+    },
+    async tokenCap({ token }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'cap',
+            args: []
+        });
+    },
+    async tokenRemainingMintableSupply({ token }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'remainingMintableSupply',
+            args: []
+        });
+    },
+    async tokenBalanceOf({ token, account }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'balanceOf',
+            args: [account]
+        });
+    },
+    async tokenTransfer({ token, to, amount, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'transfer',
+            args: [to, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenTransferFrom({ token, from, to, amount, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'transferFrom',
+            args: [from, to, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenApprove({ token, spender, amount, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'approve',
+            args: [spender, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenAllowance({ token, owner, spender }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'allowance',
+            args: [owner, spender]
+        });
+    },
+    // Mintable/Burnable
+    async tokenMint({ token, to, amount, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'mint',
+            args: [to, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenBurn({ token, amount, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'burn',
+            args: [amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenBurnFrom({ token, from, amount, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'burnFrom',
+            args: [from, amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // ERC20 Metadata
+    async tokenName({ token }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'name',
+            args: []
+        });
+    },
+    async tokenSymbol({ token }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'symbol',
+            args: []
+        });
+    },
+    async tokenDecimals({ token }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'decimals',
+            args: []
+        });
+    },
+    // Ownable
+    async tokenOwner({ token }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async tokenTransferTokenOwnership({ token, newOwner, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenRenounceOwnership({ token, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // xPNTs/aPNTs specific
+    async tokenUpdateExchangeRate({ token, newRate, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'updateExchangeRate',
+            args: [newRate],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenGetDebt({ token, user }) {
+        return client.readContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'getDebt',
+            args: [user]
+        });
+    },
+    async tokenRepayDebt({ token, amount, account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'repayDebt',
+            args: [amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenTransferAndCall({ token, to, amount, data = '0x', account }) {
+        return client.writeContract({
+            address: token,
+            abi: getTokenABI(token),
+            functionName: 'transferAndCall',
+            args: [to, amount, data],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Auto Approval
+    async tokenAddAutoApprovedSpender({ token, spender, account }) {
+        return client.writeContract({
+            address: token,
+            abi: xPNTsTokenABI,
+            functionName: 'addAutoApprovedSpender',
+            args: [spender],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenRemoveAutoApprovedSpender({ token, spender, account }) {
+        return client.writeContract({
+            address: token,
+            abi: xPNTsTokenABI,
+            functionName: 'removeAutoApprovedSpender',
+            args: [spender],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenIsAutoApprovedSpender({ token, spender }) {
+        return client.readContract({
+            address: token,
+            abi: xPNTsTokenABI,
+            functionName: 'isAutoApprovedSpender',
+            args: [spender]
+        });
+    },
+    // Constants
+    async tokenSUPERPAYMASTER_ADDRESS({ token }) {
+        return client.readContract({
+            address: token,
+            abi: xPNTsTokenABI,
+            functionName: 'SUPERPAYMASTER_ADDRESS',
+            args: []
+        });
+    },
+    async tokenFACTORY({ token }) {
+        return client.readContract({
+            address: token,
+            abi: xPNTsTokenABI,
+            functionName: 'FACTORY',
+            args: []
+        });
+    },
+    async tokenTransferOwnership(args) {
+        return this.tokenTransferTokenOwnership(args);
+    },
+    async tokenTransferCommunityOwnership({ token, newOwner, account }) {
+        return client.writeContract({
+            address: token,
+            abi: xPNTsTokenABI,
+            functionName: 'transferCommunityOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // xPNTs Views
+    async tokenCommunityName({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'communityName', args: [] });
+    },
+    async tokenCommunityENS({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'communityENS', args: [] });
+    },
+    async tokenExchangeRate({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'exchangeRate', args: [] });
+    },
+    async tokenSpendingLimits({ token, user }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'spendingLimits', args: [user] });
+    },
+    async tokenDefaultSpendingLimitXPNTs({ token }) {
+        try {
+            return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'defaultSpendingLimitXPNTs', args: [] });
+        }
+        catch {
+            return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'getDefaultSpendingLimitXPNTs', args: [] });
+        }
+    },
+    async tokenCumulativeSpent({ token, user }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'cumulativeSpent', args: [user] });
+    },
+    async tokenDebts({ token, user }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'debts', args: [user] });
+    },
+    async tokenUsedOpHashes({ token, hash }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'usedOpHashes', args: [hash] });
+    },
+    // EIP2612
+    async tokenDOMAIN_SEPARATOR({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'DOMAIN_SEPARATOR', args: [] });
+    },
+    async tokenNonces({ token, owner }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'nonces', args: [owner] });
+    },
+    async tokenPermit({ token, owner, spender, value, deadline, v, r, s, account }) {
+        return client.writeContract({
+            address: token,
+            abi: xPNTsTokenABI,
+            functionName: 'permit',
+            args: [owner, spender, value, deadline, v, r, s],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // xPNTs Additional
+    async tokenAutoApprovedSpenders({ token, spender }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'autoApprovedSpenders', args: [spender] });
+    },
+    async tokenBurnFromWithOpHash({ token, account: user, amount, opHash, userOpAccount }) {
+        return client.writeContract({ address: token, abi: xPNTsTokenABI, functionName: 'burnFromWithOpHash', args: [user, amount, opHash], account: userOpAccount, chain: client.chain });
+    },
+    async tokenCommunityOwner({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'communityOwner', args: [] });
+    },
+    async tokenEip712Domain({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'eip712Domain', args: [] });
+    },
+    async tokenGetDefaultSpendingLimitXPNTs({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'getDefaultSpendingLimitXPNTs', args: [] });
+    },
+    async tokenGetMetadata({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'getMetadata', args: [] });
+    },
+    async tokenNeedsApproval({ token, owner, spender, amount }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'needsApproval', args: [owner, spender, amount] });
+    },
+    async tokenRecordDebt({ token, user, amount, account }) {
+        return client.writeContract({ address: token, abi: xPNTsTokenABI, functionName: 'recordDebt', args: [user, amount], account: account, chain: client.chain });
+    },
+    async tokenDEFAULT_SPENDING_LIMIT_APNTS({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'DEFAULT_SPENDING_LIMIT_APNTS', args: [] });
+    },
+    // Admin
+    async tokenSetPaymasterLimit({ token, user, limit, account }) {
+        return client.writeContract({
+            address: token,
+            abi: xPNTsTokenABI,
+            functionName: 'setPaymasterLimit',
+            args: [user, limit],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenSetSuperPaymasterAddress({ token, superPaymaster, account }) {
+        return client.writeContract({
+            address: token,
+            abi: xPNTsTokenABI,
+            functionName: 'setSuperPaymasterAddress',
+            args: [superPaymaster],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async tokenVersion({ token }) {
+        return client.readContract({ address: token, abi: xPNTsTokenABI, functionName: 'version', args: [] });
+    }
+});

package/dist/core/src/branding.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AAStar Community Branding Configuration
+ */
+export declare const BRANDING: {
+    readonly logo: "https://raw.githubusercontent.com/jhfnetboy/MarkDownImg/main/img/202505031325963.png";
+    readonly icon: "https://www.aastar.io/favicon.ico";
+    readonly colors: {
+        readonly primary: "#FF6B35";
+        readonly primaryLight: "#FF8C42";
+        readonly secondary: "#4A90E2";
+        readonly secondaryDark: "#357ABD";
+        readonly success: "#4CAF50";
+        readonly warning: "#FFC107";
+        readonly error: "#F44336";
+        readonly gray50: "#F9FAFB";
+        readonly gray100: "#F3F4F6";
+        readonly gray700: "#374151";
+        readonly gray800: "#1F2937";
+        readonly gray900: "#111827";
+    };
+};
+export declare const LINKS: {
+    readonly main: "https://aastar.io";
+    readonly airAccount: "https://airAccount.aastar.io";
+    readonly superPaymaster: "https://superpaymaster.aastar.io";
+    readonly demo: "https://aastar.io/demo";
+    readonly github: "https://github.com/AAStarCommunity";
+    readonly discord: "https://discord.gg/aastar";
+    readonly twitter: "https://twitter.com/AAStarCommunity";
+};

package/dist/core/src/branding.js

@@ -0,0 +1,30 @@
+/**
+ * AAStar Community Branding Configuration
+ */
+export const BRANDING = {
+    logo: "https://raw.githubusercontent.com/jhfnetboy/MarkDownImg/main/img/202505031325963.png",
+    icon: "https://www.aastar.io/favicon.ico",
+    colors: {
+        primary: "#FF6B35",
+        primaryLight: "#FF8C42",
+        secondary: "#4A90E2",
+        secondaryDark: "#357ABD",
+        success: "#4CAF50",
+        warning: "#FFC107",
+        error: "#F44336",
+        gray50: "#F9FAFB",
+        gray100: "#F3F4F6",
+        gray700: "#374151",
+        gray800: "#1F2937",
+        gray900: "#111827",
+    },
+};
+export const LINKS = {
+    main: "https://aastar.io",
+    airAccount: "https://airAccount.aastar.io",
+    superPaymaster: "https://superpaymaster.aastar.io",
+    demo: "https://aastar.io/demo",
+    github: "https://github.com/AAStarCommunity",
+    discord: "https://discord.gg/aastar",
+    twitter: "https://twitter.com/AAStarCommunity",
+};