@aastar/paymaster 0.16.7

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

@@ -0,0 +1,330 @@
+import { GTokenStakingABI } from '../abis/index.js';
+export const stakingActions = (address) => (client) => ({
+    // Staking Operations
+    /**
+     * @internal
+     * @warning This is a low-level internal API. Use high-level clients instead.
+     */
+    async lockStake({ user, roleId, stakeAmount, entryBurn, payer, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'lockStake',
+            args: [user, roleId, stakeAmount, entryBurn, payer],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async unlockStake({ user, roleId, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'unlockAndTransfer',
+            args: [user, roleId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async unlockAndTransfer({ user, roleId, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'unlockAndTransfer',
+            args: [user, roleId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async stake({ amount, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'stake',
+            args: [amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async topUpStake({ amount, account }) {
+        // topUpStake typically calls stake internally or is a distinct function. Assuming distinct based on request.
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'topUpStake',
+            args: [amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async unstake({ amount, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'unstake',
+            args: [amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Slashing
+    async slash({ user, roleId, amount, reason, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'slash',
+            args: [user, roleId, amount, reason],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async slashByDVT({ user, roleId, amount, reason, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'slashByDVT',
+            args: [user, roleId, amount, reason],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setAuthorizedSlasher({ slasher, authorized, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'setAuthorizedSlasher',
+            args: [slasher, authorized],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Query Functions
+    async getStakeInfo({ operator, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'stakes',
+            args: [operator]
+        });
+    },
+    async getStakingBalance({ user }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'balanceOf',
+            args: [user]
+        });
+    },
+    async getLockedStake({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'getLockedStake',
+            args: [user, roleId]
+        });
+    },
+    async getUserRoleLocks({ user }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'getUserRoleLocks',
+            args: [user]
+        });
+    },
+    async hasRoleLock({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'hasRoleLock',
+            args: [user, roleId]
+        });
+    },
+    async availableBalance({ user }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'availableBalance',
+            args: [user]
+        });
+    },
+    async previewExitFee({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'previewExitFee',
+            args: [user, roleId]
+        });
+    },
+    // Admin Functions
+    async setRegistry({ registry, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async transferOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setRoleExitFee({ roleId, feePercent, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'setRoleExitFee',
+            args: [roleId, feePercent],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async setTreasury({ treasury, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'setTreasury',
+            args: [treasury],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // View Functions
+    async stakes({ user }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'stakes',
+            args: [user]
+        });
+    },
+    async roleLocks({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'roleLocks',
+            args: [user, roleId]
+        });
+    },
+    async roleExitConfigs({ roleId }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'roleExitConfigs',
+            args: [roleId]
+        });
+    },
+    async userActiveRoles({ user, index }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'userActiveRoles',
+            args: [user, index]
+        });
+    },
+    async authorizedSlashers({ slasher }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'authorizedSlashers',
+            args: [slasher]
+        });
+    },
+    async getStake({ account }) {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'getStake',
+            args: [account]
+        });
+    },
+    async balanceOf({ account }) {
+        // GTokenStaking might implement balanceOf if it's an ERC20-like or just tracking stakes
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'balanceOf',
+            args: [account]
+        });
+    },
+    async totalStaked() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'totalStaked',
+            args: []
+        });
+    },
+    async getTotalStaked() {
+        return this.totalStaked();
+    },
+    async treasury() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'treasury',
+            args: []
+        });
+    },
+    async owner() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    // Ownership
+    async transferStakingOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async renounceOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Version
+    async version() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'version',
+            args: []
+        });
+    },
+    // Constants
+    async REGISTRY() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'REGISTRY',
+            args: []
+        });
+    },
+    async GTOKEN() {
+        return client.readContract({
+            address,
+            abi: GTokenStakingABI,
+            functionName: 'GTOKEN',
+            args: []
+        });
+    }
+});

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

@@ -0,0 +1,237 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type SuperPaymasterActions = {
+    superPaymasterDeposit: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    /** @deprecated Use superPaymasterDeposit for clarity */
+    superPaymasterDepositAPNTs: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterDepositETH: (args: {
+        value: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterDepositFor: (args: {
+        operator: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterWithdrawTo: (args: {
+        to: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterAddSuperStake: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterUnlockSuperStake: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterWithdrawStake: (args: {
+        to: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterConfigureOperator: (args: {
+        xPNTsToken: Address;
+        treasury: Address;
+        exchangeRate: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSetOperatorPaused: (args: {
+        operator: Address;
+        paused: boolean;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSetOperatorLimits: (args: {
+        operator: Address;
+        limits: any;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterUpdateReputation: (args: {
+        operator: Address;
+        newReputation: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterExecuteSlashWithBLS: (args: {
+        operator: Address;
+        roleId: Hex;
+        amount: bigint;
+        reason: string;
+        blsSignature: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSlashOperator: (args: {
+        operator: Address;
+        amount: bigint;
+        reason: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSetAPNTsPrice: (args: {
+        priceUSD: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSetCachedPrice: (args: {
+        price: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSetProtocolFee: (args: {
+        feeRecipient: Address;
+        feeBps: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterBlockUser: (args: {
+        user: Address;
+        blocked: boolean;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterUpdateBlockedStatus: (args: {
+        user: Address;
+        blocked: boolean;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterValidatePaymasterUserOp: (args: {
+        userOp: any;
+        userOpHash: Hex;
+        maxCost: bigint;
+    }) => Promise<any>;
+    superPaymasterPostOp: (args: {
+        mode: number;
+        context: Hex;
+        actualGasCost: bigint;
+        actualUserOpFeePerGas: bigint;
+    }) => Promise<void>;
+    superPaymasterOperators: (args: {
+        operator: Address;
+    }) => Promise<any>;
+    superPaymasterGetDeposit: () => Promise<bigint>;
+    superPaymasterGetAvailableCredit: (args: {
+        operator: Address;
+        user: Address;
+    }) => Promise<bigint>;
+    superPaymasterBlockedUsers: (args: {
+        user: Address;
+    }) => Promise<boolean>;
+    superPaymasterBalanceOfOperator: (args: {
+        operator: Address;
+    }) => Promise<bigint>;
+    superPaymasterAPNTsPriceUSD: () => Promise<bigint>;
+    superPaymasterCachedPrice: () => Promise<any>;
+    superPaymasterProtocolFee: () => Promise<any>;
+    superPaymasterProtocolFeeBPS: () => Promise<bigint>;
+    superPaymasterProtocolRevenue: () => Promise<bigint>;
+    superPaymasterTreasury: () => Promise<Address>;
+    superPaymasterXpntsFactory: () => Promise<Address>;
+    superPaymasterEntryPoint: () => Promise<Address>;
+    superPaymasterTotalTrackedBalance: () => Promise<bigint>;
+    superPaymasterLastUserOpTimestamp: (args: {
+        user: Address;
+    }) => Promise<bigint>;
+    superPaymasterGetSlashHistory: (args: {
+        operator: Address;
+    }) => Promise<any[]>;
+    superPaymasterGetSlashCount: (args: {
+        operator: Address;
+    }) => Promise<bigint>;
+    superPaymasterGetLatestSlash: (args: {
+        operator: Address;
+    }) => Promise<any>;
+    superPaymasterSlashHistory: (args: {
+        operator: Address;
+        index: bigint;
+    }) => Promise<any>;
+    superPaymasterUpdatePrice: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterUpdatePriceDVT: (args: {
+        price: bigint;
+        proof: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSetTreasury: (args: {
+        treasury: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterWithdrawProtocolRevenue: (args: {
+        to: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSetXPNTsFactory: (args: {
+        factory: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSetAPNTsToken: (args: {
+        token: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterSetBLSAggregator: (args: {
+        aggregator: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterOnTransferReceived: (args: {
+        from: Address;
+        amount: bigint;
+        data: Hex;
+    }) => Promise<any>;
+    superPaymasterWithdrawAPNTs: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterAPNTS_TOKEN: () => Promise<Address>;
+    superPaymasterREGISTRY: () => Promise<Address>;
+    superPaymasterBLS_AGGREGATOR: () => Promise<Address>;
+    superPaymasterETH_USD_PRICE_FEED: () => Promise<Address>;
+    superPaymasterPAYMASTER_DATA_OFFSET: () => Promise<bigint>;
+    superPaymasterRATE_OFFSET: () => Promise<bigint>;
+    superPaymasterBPS_DENOMINATOR: () => Promise<bigint>;
+    superPaymasterPRICE_CACHE_DURATION: () => Promise<bigint>;
+    superPaymasterPRICE_STALENESS_THRESHOLD: () => Promise<bigint>;
+    superPaymasterMAX_ETH_USD_PRICE: () => Promise<bigint>;
+    superPaymasterMIN_ETH_USD_PRICE: () => Promise<bigint>;
+    transferSuperPaymasterOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterOwner: () => Promise<Address>;
+    renounceSuperPaymasterOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterAddStake: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterDepositForAlias: (args: {
+        operator: Address;
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterUnlockStake: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterWithdraw: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterWithdrawAlias: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterMAX_PROTOCOL_FEE: () => Promise<bigint>;
+    superPaymasterVALIDATION_BUFFER_BPS: () => Promise<bigint>;
+    superPaymasterPriceStalenessThreshold: () => Promise<bigint>;
+    superPaymasterSbtHolders: (args: {
+        user: Address;
+    }) => Promise<boolean>;
+    superPaymasterUserOpState: (args: {
+        userOpHash: Hex;
+    }) => Promise<any>;
+    superPaymasterUpdateSBTStatus: (args: {
+        user: Address;
+        hasSBT: boolean;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    superPaymasterVersion: () => Promise<string>;
+};
+export declare const superPaymasterActions: (address: Address) => (client: PublicClient | WalletClient) => SuperPaymasterActions;