tempo.ts 0.0.1 → 0.0.3

package/src/viem/actions/policy.ts

@@ -162,13 +162,18 @@ export namespace create {
   export function call(args: Args) {
     const { admin, type, addresses } = args
     const callArgs = addresses
-      ? ([admin, policyTypeMap[type], addresses] as const)
-      : ([admin, policyTypeMap[type]] as const)
+      ? ({
+          functionName: 'createPolicyWithAccounts',
+          args: [admin, policyTypeMap[type], addresses],
+        } as const)
+      : ({
+          functionName: 'createPolicy',
+          args: [admin, policyTypeMap[type]],
+        } as const)
     return defineCall({
       address: tip403RegistryAddress,
       abi: tip403RegistryAbi,
-      functionName: 'createPolicy',
-      args: callArgs,
+      ...callArgs,
     })
   }
 

package/src/viem/actions/token.test.ts

@@ -1087,6 +1087,196 @@ describe('unpause', () => {
 
 describe.todo('setTokenSupplyCap')
 
+describe('hasRole', () => {
+  test('default', async () => {
+    // Create a new token where we're the admin
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'HasRole Test Token',
+      symbol: 'HRTEST',
+    })
+
+    // Client account should have defaultAdmin role on the new token
+    const hasDefaultAdminRole = await actions.token.hasRole(client, {
+      token: address,
+      role: 'defaultAdmin',
+    })
+    expect(hasDefaultAdminRole).toBe(true)
+
+    // Client account should not have issuer role initially on the new token
+    const hasIssuerRole = await actions.token.hasRole(client, {
+      token: address,
+      role: 'issuer',
+    })
+    expect(hasIssuerRole).toBe(false)
+
+    // Grant issuer role
+    await actions.token.grantRolesSync(client, {
+      token: address,
+      roles: ['issuer'],
+      to: client.account.address,
+    })
+
+    // Now should have issuer role
+    const hasIssuerRoleAfterGrant = await actions.token.hasRole(client, {
+      token: address,
+      role: 'issuer',
+    })
+    expect(hasIssuerRoleAfterGrant).toBe(true)
+  })
+
+  test('behavior: check other account', async () => {
+    // Create a new token
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'HasRole Other Account',
+      symbol: 'HROAC',
+    })
+
+    // Account2 should not have issuer role
+    const hasIssuerBefore = await actions.token.hasRole(client, {
+      token: address,
+      account: account2.address,
+      role: 'issuer',
+    })
+    expect(hasIssuerBefore).toBe(false)
+
+    // Grant issuer role to account2
+    await actions.token.grantRolesSync(client, {
+      token: address,
+      roles: ['issuer'],
+      to: account2.address,
+    })
+
+    // Account2 should now have issuer role
+    const hasIssuerAfter = await actions.token.hasRole(client, {
+      token: address,
+      account: account2.address,
+      role: 'issuer',
+    })
+    expect(hasIssuerAfter).toBe(true)
+
+    // Account3 should still not have issuer role
+    const account3HasIssuer = await actions.token.hasRole(client, {
+      token: address,
+      account: account3.address,
+      role: 'issuer',
+    })
+    expect(account3HasIssuer).toBe(false)
+  })
+
+  test('behavior: multiple roles', async () => {
+    // Create a new token
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'HasRole Multiple',
+      symbol: 'HRMULTI',
+    })
+
+    // Grant multiple roles to account2
+    await actions.token.grantRolesSync(client, {
+      token: address,
+      roles: ['issuer', 'pause'],
+      to: account2.address,
+    })
+
+    // Check issuer role
+    const hasIssuer = await actions.token.hasRole(client, {
+      token: address,
+      account: account2.address,
+      role: 'issuer',
+    })
+    expect(hasIssuer).toBe(true)
+
+    // Check pause role
+    const hasPause = await actions.token.hasRole(client, {
+      token: address,
+      account: account2.address,
+      role: 'pause',
+    })
+    expect(hasPause).toBe(true)
+
+    // Check unpause role (not granted)
+    const hasUnpause = await actions.token.hasRole(client, {
+      token: address,
+      account: account2.address,
+      role: 'unpause',
+    })
+    expect(hasUnpause).toBe(false)
+  })
+
+  test('behavior: after revoke', async () => {
+    // Create a new token
+    const { token: address } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'HasRole Revoke',
+      symbol: 'HRREV',
+    })
+
+    // Grant issuer role to account2
+    await actions.token.grantRolesSync(client, {
+      token: address,
+      roles: ['issuer'],
+      to: account2.address,
+    })
+
+    // Verify has role
+    const hasRoleBefore = await actions.token.hasRole(client, {
+      token: address,
+      account: account2.address,
+      role: 'issuer',
+    })
+    expect(hasRoleBefore).toBe(true)
+
+    // Revoke the role
+    await actions.token.revokeRolesSync(client, {
+      token: address,
+      roles: ['issuer'],
+      from: account2.address,
+    })
+
+    // Verify no longer has role
+    const hasRoleAfter = await actions.token.hasRole(client, {
+      token: address,
+      account: account2.address,
+      role: 'issuer',
+    })
+    expect(hasRoleAfter).toBe(false)
+  })
+
+  test('behavior: with token ID', async () => {
+    // Create a new token
+    const { token: address, tokenId } = await actions.token.createSync(client, {
+      currency: 'USD',
+      name: 'HasRole Token ID',
+      symbol: 'HRTID',
+    })
+
+    // Grant issuer role
+    await actions.token.grantRolesSync(client, {
+      token: tokenId,
+      roles: ['issuer'],
+      to: account2.address,
+    })
+
+    // Check using token ID
+    const hasRole = await actions.token.hasRole(client, {
+      token: tokenId,
+      account: account2.address,
+      role: 'issuer',
+    })
+    expect(hasRole).toBe(true)
+
+    // Verify same result with address
+    const hasRoleWithAddress = await actions.token.hasRole(client, {
+      token: address,
+      account: account2.address,
+      role: 'issuer',
+    })
+    expect(hasRoleWithAddress).toBe(true)
+  })
+})
+
 describe('grantRoles', () => {
   test('default', async () => {
     // Create a new token where we're the admin

package/src/viem/actions/token.ts

@@ -1081,12 +1081,12 @@ export async function getAllowance<
   client: Client<Transport, chain, account>,
   parameters: getAllowance.Parameters<account>,
 ): Promise<getAllowance.ReturnValue> {
-  const { account = client.account, ...rest } = parameters
+  const { account = client.account } = parameters
   const address = account ? parseAccount(account).address : undefined
   if (!address) throw new Error('account is required.')
   return readContract(client, {
-    ...rest,
-    ...getAllowance.call({ account: address, ...rest }),
+    ...parameters,
+    ...getAllowance.call({ ...parameters, account: address }),
   })
 }
 
@@ -1333,6 +1333,84 @@ export declare namespace getMetadata {
   }>
 }
 
+/**
+ * Checks if an account has a specific role for a TIP20 token.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'tempo.ts/chains'
+ * import * as actions from 'tempo.ts/viem/actions'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const hasRole = await actions.token.hasRole(client, {
+ *   account: '0x...',
+ *   role: 'issuer',
+ *   token: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Whether the account has the role.
+ */
+export async function hasRole<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: hasRole.Parameters<account>,
+): Promise<hasRole.ReturnValue> {
+  const { account = client.account } = parameters
+  const address = account ? parseAccount(account).address : undefined
+  if (!address) throw new Error('account is required.')
+  return readContract(client, {
+    ...parameters,
+    ...hasRole.call({ ...parameters, account: address }),
+  })
+}
+
+export namespace hasRole {
+  export type Parameters<
+    account extends Account | undefined = Account | undefined,
+  > = ReadParameters & Omit<Args, 'account'> & GetAccountParameter<account>
+
+  export type Args = {
+    /** Account address to check. */
+    account: Address
+    /** Role to check. */
+    role: TokenRole.TokenRole
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof tip20Abi,
+    'hasRole',
+    never
+  >
+
+  /**
+   * Defines a call to the `hasRole` function.
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { account, role, token } = args
+    return defineCall({
+      address: TokenId.toAddress(token),
+      abi: tip20Abi,
+      functionName: 'hasRole',
+      args: [account, TokenRole.serialize(role)],
+    })
+  }
+}
+
 /**
  * Grants a role for a TIP20 token.
  *
@@ -1352,7 +1430,7 @@ export declare namespace getMetadata {
  * const result = await actions.token.grantRoles(client, {
  *   token: '0x...',
  *   to: '0x...',
- *   roles: ['minter'],
+ *   roles: ['issuer'],
  * })
  * ```
  *

package/src/viem/client.test.ts

@@ -107,6 +107,7 @@ test('createTempoClient', () => {
         "getMetadata": [Function],
         "grantRoles": [Function],
         "grantRolesSync": [Function],
+        "hasRole": [Function],
         "mint": [Function],
         "mintSync": [Function],
         "pause": [Function],

package/src/viem/decorator.bench-d.ts

@@ -7,5 +7,5 @@ test('decorator', () => {
   createClient({
     transport: http('https://cloudflare-eth.com'),
   }).extend(decorator())
-  attest.instantiations([27597, 'instantiations'])
+  attest.instantiations([26939, 'instantiations'])
 })

package/src/viem/decorator.ts

@@ -1099,6 +1099,31 @@ export type Decorator<
     getMetadata: (
       parameters: tokenActions.getMetadata.Parameters,
     ) => Promise<tokenActions.getMetadata.ReturnValue>
+    /**
+     * Checks if an account has a specific role for a TIP20 token.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const hasRole = await client.token.hasRole({
+     *   token: '0x...',
+     *   role: 'issuer',
+     * })
+     * ```
+     *
+     * @param client - Client.
+     * @param parameters - Parameters.
+     * @returns Whether the account has the role.
+     */
+    hasRole: (
+      parameters: tokenActions.hasRole.Parameters<account>,
+    ) => Promise<tokenActions.hasRole.ReturnValue>
     /**
      * Grants a role for a TIP20 token.
      *
@@ -1866,6 +1891,7 @@ export function decorator() {
         getBalance: (parameters) => tokenActions.getBalance(client, parameters),
         getMetadata: (parameters) =>
           tokenActions.getMetadata(client, parameters),
+        hasRole: (parameters) => tokenActions.hasRole(client, parameters),
         grantRoles: (parameters) => tokenActions.grantRoles(client, parameters),
         grantRolesSync: (parameters) =>
           tokenActions.grantRolesSync(client, parameters),

package/src/viem/index.ts

@@ -1,5 +1,6 @@
 export * from './abis.js'
 export * as actions from './actions/index.js'
+export * from './addresses.js'
 export * from './chain.js'
 export * from './client.js'
 export { decorator as tempoActions } from './decorator.js'