@aastar/sdk 0.16.8 → 0.16.12

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

@@ -1,533 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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;