@aastar/core 0.16.8 → 0.16.12

package/dist/actions/sbt.d.ts

@@ -1,190 +1,180 @@
 import { type Address, type PublicClient, type WalletClient, type Hex, type Hash, type Account } from 'viem';
+export type SBTMembership = {
+    community: Address;
+    joinedAt: bigint;
+    lastActiveTime: bigint;
+    isActive: boolean;
+    metadata: string;
+};
+export type SBTData = {
+    holder: Address;
+    firstCommunity: Address;
+    mintedAt: bigint;
+    totalCommunities: bigint;
+};
 export type SBTActions = {
-    sbtSafeMintForRole: (args: {
-        roleId: Hex;
-        to: Address;
-        tokenURI: string;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    sbtAirdropMint: (args: {
+    airdropMint: (args: {
+        user: Address;
         roleId: Hex;
-        to: Address;
-        tokenURI: string;
+        roleData: Hex;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtMintForRole: (args: {
+    mintForRole: (args: {
+        user: Address;
         roleId: Hex;
-        to: Address;
+        roleData: Hex;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtGetUserSBT: (args: {
+    getUserSBT: (args: {
         user: Address;
-        roleId: Hex;
     }) => Promise<bigint>;
-    sbtGetSBTData: (args: {
+    getSBTData: (args: {
+        tokenId: bigint;
+    }) => Promise<SBTData>;
+    getCommunityMembership: (args: {
         tokenId: bigint;
-    }) => Promise<any>;
-    sbtGetCommunityMembership: (args: {
-        user: Address;
         community: Address;
-    }) => Promise<bigint>;
-    sbtGetMemberships: (args: {
-        user: Address;
-    }) => Promise<any[]>;
-    sbtGetActiveMemberships: (args: {
-        user: Address;
-    }) => Promise<any[]>;
-    sbtVerifyCommunityMembership: (args: {
+    }) => Promise<SBTMembership>;
+    getMemberships: (args: {
+        tokenId: bigint;
+    }) => Promise<SBTMembership[]>;
+    getActiveMemberships: (args: {
+        tokenId: bigint;
+    }) => Promise<Address[]>;
+    verifyCommunityMembership: (args: {
         user: Address;
         community: Address;
     }) => Promise<boolean>;
-    sbtUserToSBT: (args: {
+    userToSBT: (args: {
         user: Address;
     }) => Promise<bigint>;
-    sbtSbtData: (args: {
+    sbtData: (args: {
         tokenId: bigint;
-    }) => Promise<any>;
-    sbtMembershipIndex: (args: {
-        user: Address;
-        index: bigint;
-    }) => Promise<any>;
-    sbtBalanceOf: (args: {
+    }) => Promise<SBTData>;
+    membershipIndex: (args: {
+        tokenId: bigint;
+        community: Address;
+    }) => Promise<bigint>;
+    balanceOf: (args: {
         owner: Address;
     }) => Promise<bigint>;
-    sbtOwnerOf: (args: {
+    ownerOf: (args: {
         tokenId: bigint;
     }) => Promise<Address>;
-    sbtSafeTransferFrom: (args: {
+    safeTransferFrom: (args: {
         from: Address;
         to: Address;
         tokenId: bigint;
+        data?: Hex;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtTransferFrom: (args: {
+    transferFrom: (args: {
         from: Address;
         to: Address;
         tokenId: bigint;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtApprove: (args: {
+    approve: (args: {
         to: Address;
         tokenId: bigint;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtSetApprovalForAll: (args: {
+    setApprovalForAll: (args: {
         operator: Address;
         approved: boolean;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtGetApproved: (args: {
+    getApproved: (args: {
         tokenId: bigint;
     }) => Promise<Address>;
-    sbtIsApprovedForAll: (args: {
+    isApprovedForAll: (args: {
         owner: Address;
         operator: Address;
     }) => Promise<boolean>;
-    sbtName: () => Promise<string>;
-    sbtSymbol: () => Promise<string>;
-    sbtTokenURI: (args: {
+    name: () => Promise<string>;
+    symbol: () => Promise<string>;
+    tokenURI: (args: {
         tokenId: bigint;
     }) => Promise<string>;
-    sbtTotalSupply: () => Promise<bigint>;
-    sbtTokenByIndex: (args: {
-        index: bigint;
-    }) => Promise<bigint>;
-    sbtTokenOfOwnerByIndex: (args: {
-        owner: Address;
-        index: bigint;
-    }) => Promise<bigint>;
-    sbtSupportsInterface: (args: {
+    nextTokenId: () => Promise<bigint>;
+    supportsInterface: (args: {
         interfaceId: Hex;
     }) => Promise<boolean>;
-    sbtNextTokenId: () => Promise<bigint>;
-    sbtMint: (args: {
-        to: Address;
-        tokenURI: string;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    sbtBurn: (args: {
-        tokenId: bigint;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    sbtBurnSBT: (args: {
-        tokenId: bigint;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    sbtDeactivateAllMemberships: (args: {
+    burnSBT: (args: {
         user: Address;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtSetBaseURI: (args: {
+    setBaseURI: (args: {
         baseURI: string;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtLeaveCommunity: (args: {
+    leaveCommunity: (args: {
         community: Address;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtDeactivateMembership: (args: {
-        tokenId: bigint;
+    deactivateMembership: (args: {
+        user: Address;
+        community: Address;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtRecordActivity: (args: {
+    deactivateAllMemberships: (args: {
         user: Address;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtLastActivityTime: (args: {
-        user: Address;
-    }) => Promise<bigint>;
-    sbtWeeklyActivity: (args: {
+    recordActivity: (args: {
         user: Address;
+        account?: Account | Address;
+    }) => Promise<Hash>;
+    lastActivityTime: (args: {
+        tokenId: bigint;
+        community: Address;
     }) => Promise<bigint>;
-    sbtReputationCalculator: () => Promise<Address>;
-    sbtSetReputationCalculator: (args: {
+    weeklyActivity: (args: {
+        tokenId: bigint;
+        community: Address;
+        week: bigint;
+    }) => Promise<boolean>;
+    reputationCalculator: () => Promise<Address>;
+    setReputationCalculator: (args: {
         calculator: Address;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtMintFee: () => Promise<bigint>;
-    sbtSetMintFee: (args: {
+    mintFee: () => Promise<bigint>;
+    setMintFee: (args: {
         fee: bigint;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtMinLockAmount: () => Promise<bigint>;
-    sbtSetMinLockAmount: (args: {
+    minLockAmount: () => Promise<bigint>;
+    setMinLockAmount: (args: {
         amount: bigint;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtPause: (args: {
+    pause: (args: {
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtUnpause: (args: {
+    unpause: (args: {
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtPaused: () => Promise<boolean>;
-    sbtDaoMultisig: () => Promise<Address>;
-    sbtSetDAOMultisig: (args: {
+    paused: () => Promise<boolean>;
+    daoMultisig: () => Promise<Address>;
+    setDAOMultisig: (args: {
         multisig: Address;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtSetRegistry: (args: {
+    setRegistry: (args: {
         registry: Address;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtSetSuperPaymaster: (args: {
-        paymaster: Address;
-        account?: Account | Address;
-    }) => Promise<Hash>;
-    sbtVersion: () => Promise<string>;
-    sbtREGISTRY: () => Promise<Address>;
-    sbtGTOKEN_STAKING: () => Promise<Address>;
-    sbtGTOKEN: () => Promise<Address>;
-    sbtSUPER_PAYMASTER: () => Promise<Address>;
-    sbtOwner: () => Promise<Address>;
-    sbtTransferSBTOwnership: (args: {
+    version: () => Promise<string>;
+    REGISTRY: () => Promise<Address>;
+    GTOKEN_STAKING: () => Promise<Address>;
+    GTOKEN: () => Promise<Address>;
+    owner: () => Promise<Address>;
+    transferOwnership: (args: {
         newOwner: Address;
         account?: Account | Address;
     }) => Promise<Hash>;
-    sbtRenounceOwnership: (args: {
+    renounceOwnership: (args: {
         account?: Account | Address;
     }) => Promise<Hash>;
 };