@aastar/dapp 0.16.7

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

@@ -0,0 +1,533 @@
+import { MySBTABI } from '../abis/index.js';
+export const sbtActions = (address) => (client) => ({
+    // SBT specific
+    async sbtSafeMintForRole({ roleId, to, tokenURI, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'safeMintForRole',
+            args: [roleId, to, tokenURI],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtAirdropMint({ roleId, to, tokenURI, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'airdropMint',
+            args: [roleId, to, tokenURI],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtGetUserSBT({ user, roleId }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'getUserSBT',
+            args: [user]
+        });
+    },
+    async sbtGetSBTData({ tokenId }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'getSBTData',
+            args: [tokenId]
+        });
+    },
+    async sbtGetCommunityMembership({ user, community }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'getCommunityMembership',
+            args: [user, community]
+        });
+    },
+    // ERC721 Standard
+    async sbtBalanceOf({ owner }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'balanceOf',
+            args: [owner]
+        });
+    },
+    async sbtOwnerOf({ tokenId }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'ownerOf',
+            args: [tokenId]
+        });
+    },
+    async sbtSafeTransferFrom({ from, to, tokenId, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'safeTransferFrom',
+            args: [from, to, tokenId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtTransferFrom({ from, to, tokenId, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'transferFrom',
+            args: [from, to, tokenId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtApprove({ to, tokenId, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'approve',
+            args: [to, tokenId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtSetApprovalForAll({ operator, approved, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'setApprovalForAll',
+            args: [operator, approved],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtGetApproved({ tokenId }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'getApproved',
+            args: [tokenId]
+        });
+    },
+    async sbtIsApprovedForAll({ owner, operator }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'isApprovedForAll',
+            args: [owner, operator]
+        });
+    },
+    // ERC721 Metadata
+    async sbtName() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'name',
+            args: []
+        });
+    },
+    async sbtSymbol() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'symbol',
+            args: []
+        });
+    },
+    async sbtTokenURI({ tokenId }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'tokenURI',
+            args: [tokenId]
+        });
+    },
+    // ERC721 Enumerable
+    async sbtTotalSupply() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'totalSupply',
+            args: []
+        });
+    },
+    async sbtTokenByIndex({ index }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'tokenByIndex',
+            args: [index]
+        });
+    },
+    async sbtTokenOfOwnerByIndex({ owner, index }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'tokenOfOwnerByIndex',
+            args: [owner, index]
+        });
+    },
+    // Admin/Minting
+    async sbtMint({ to, tokenURI, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'mint',
+            args: [to, tokenURI],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtBurn({ tokenId, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'burn',
+            args: [tokenId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtDeactivateAllMemberships({ user, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'deactivateAllMemberships',
+            args: [user],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtSetBaseURI({ baseURI, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'setBaseURI',
+            args: [baseURI],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Constants
+    async sbtREGISTRY() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'REGISTRY',
+            args: []
+        });
+    },
+    async sbtGTOKEN_STAKING() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'GTOKEN_STAKING',
+            args: []
+        });
+    },
+    async sbtGTOKEN() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'GTOKEN',
+            args: []
+        });
+    },
+    async sbtSUPER_PAYMASTER() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'SUPER_PAYMASTER',
+            args: []
+        });
+    },
+    // Ownership
+    async sbtOwner() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'owner',
+            args: []
+        });
+    },
+    async sbtTransferSBTOwnership({ newOwner, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'transferOwnership',
+            args: [newOwner],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtRenounceOwnership({ account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'renounceOwnership',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    // Additional SBT-specific functions
+    async sbtMintForRole({ roleId, to, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'mintForRole',
+            args: [roleId, to],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtGetMemberships({ user }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'getMemberships',
+            args: [user]
+        });
+    },
+    async sbtGetActiveMemberships({ user }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'getActiveMemberships',
+            args: [user]
+        });
+    },
+    async sbtVerifyCommunityMembership({ user, community }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'verifyCommunityMembership',
+            args: [user, community]
+        });
+    },
+    async sbtUserToSBT({ user }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'userToSBT',
+            args: [user]
+        });
+    },
+    async sbtSbtData({ tokenId }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'sbtData',
+            args: [tokenId]
+        });
+    },
+    async sbtMembershipIndex({ user, index }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'membershipIndex',
+            args: [user, index]
+        });
+    },
+    async sbtSupportsInterface({ interfaceId }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'supportsInterface',
+            args: [interfaceId]
+        });
+    },
+    async sbtNextTokenId() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'nextTokenId',
+            args: []
+        });
+    },
+    async sbtBurnSBT({ tokenId, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'burnSBT',
+            args: [tokenId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtLeaveCommunity({ community, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'leaveCommunity',
+            args: [community],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtDeactivateMembership({ tokenId, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'deactivateMembership',
+            args: [tokenId],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtRecordActivity({ user, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'recordActivity',
+            args: [user],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtLastActivityTime({ user }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'lastActivityTime',
+            args: [user]
+        });
+    },
+    async sbtWeeklyActivity({ user }) {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'weeklyActivity',
+            args: [user]
+        });
+    },
+    async sbtReputationCalculator() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'reputationCalculator',
+            args: []
+        });
+    },
+    async sbtSetReputationCalculator({ calculator, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'setReputationCalculator',
+            args: [calculator],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtMintFee() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'mintFee',
+            args: []
+        });
+    },
+    async sbtSetMintFee({ fee, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'setMintFee',
+            args: [fee],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtMinLockAmount() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'minLockAmount',
+            args: []
+        });
+    },
+    async sbtSetMinLockAmount({ amount, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'setMinLockAmount',
+            args: [amount],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtPause({ account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'pause',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtUnpause({ account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'unpause',
+            args: [],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtPaused() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'paused',
+            args: []
+        });
+    },
+    async sbtDaoMultisig() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'daoMultisig',
+            args: []
+        });
+    },
+    async sbtSetDAOMultisig({ multisig, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'setDAOMultisig',
+            args: [multisig],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtSetRegistry({ registry, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'setRegistry',
+            args: [registry],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtSetSuperPaymaster({ paymaster, account }) {
+        return client.writeContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'setSuperPaymaster',
+            args: [paymaster],
+            account: account,
+            chain: client.chain
+        });
+    },
+    async sbtVersion() {
+        return client.readContract({
+            address,
+            abi: MySBTABI,
+            functionName: 'version',
+            args: []
+        });
+    }
+});

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

@@ -0,0 +1,132 @@
+import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type StakingActions = {
+    lockStake: (args: {
+        user: Address;
+        roleId: Hex;
+        stakeAmount: bigint;
+        entryBurn: bigint;
+        payer: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    unlockStake: (args: {
+        user: Address;
+        roleId: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    unlockAndTransfer: (args: {
+        user: Address;
+        roleId: Hex;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    stake: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    topUpStake: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    unstake: (args: {
+        amount: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    slash: (args: {
+        user: Address;
+        roleId: Hex;
+        amount: bigint;
+        reason: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    slashByDVT: (args: {
+        user: Address;
+        roleId: Hex;
+        amount: bigint;
+        reason: string;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setAuthorizedSlasher: (args: {
+        slasher: Address;
+        authorized: boolean;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    getStakeInfo: (args: {
+        operator: Address;
+        roleId: Hex;
+    }) => Promise<any>;
+    getStakingBalance: (args: {
+        user: Address;
+    }) => Promise<bigint>;
+    getLockedStake: (args: {
+        user: Address;
+        roleId: Hex;
+    }) => Promise<bigint>;
+    getUserRoleLocks: (args: {
+        user: Address;
+    }) => Promise<any[]>;
+    hasRoleLock: (args: {
+        user: Address;
+        roleId: Hex;
+    }) => Promise<boolean>;
+    availableBalance: (args: {
+        user: Address;
+    }) => Promise<bigint>;
+    previewExitFee: (args: {
+        user: Address;
+        roleId: Hex;
+    }) => Promise<bigint>;
+    setRegistry: (args: {
+        registry: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    transferOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setRoleExitFee: (args: {
+        roleId: Hex;
+        feePercent: bigint;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    setTreasury: (args: {
+        treasury: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    stakes: (args: {
+        user: Address;
+    }) => Promise<any>;
+    roleLocks: (args: {
+        user: Address;
+        roleId: Hex;
+    }) => Promise<any>;
+    roleExitConfigs: (args: {
+        roleId: Hex;
+    }) => Promise<any>;
+    userActiveRoles: (args: {
+        user: Address;
+        index: bigint;
+    }) => Promise<Hex>;
+    authorizedSlashers: (args: {
+        slasher: Address;
+    }) => Promise<boolean>;
+    getStake: (args: {
+        account: Address;
+    }) => Promise<bigint>;
+    balanceOf: (args: {
+        account: Address;
+    }) => Promise<bigint>;
+    totalStaked: () => Promise<bigint>;
+    getTotalStaked: () => Promise<bigint>;
+    treasury: () => Promise<Address>;
+    owner: () => Promise<Address>;
+    transferStakingOwnership: (args: {
+        newOwner: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    renounceOwnership: (args: {
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    version: () => Promise<string>;
+    REGISTRY: () => Promise<Address>;
+    GTOKEN: () => Promise<Address>;
+};
+export declare const stakingActions: (address: Address) => (client: PublicClient | WalletClient) => StakingActions;