tempo.ts 0.0.2 → 0.0.4

package/src/viem/actions/amm.ts

@@ -484,11 +484,11 @@ export async function rebalanceSwapSync<
   client: Client<Transport, chain, account>,
   parameters: rebalanceSwapSync.Parameters<chain, account>,
 ): Promise<rebalanceSwapSync.ReturnValue> {
-  const receipt = await rebalanceSwap.inner(
-    writeContractSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await rebalanceSwap.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = rebalanceSwap.extractEvent(receipt.logs)
   return {
     ...args,
@@ -727,7 +727,11 @@ export async function mintSync<
   client: Client<Transport, chain, account>,
   parameters: mintSync.Parameters<chain, account>,
 ): Promise<mintSync.ReturnValue> {
-  const receipt = await mint.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await mint.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = mint.extractEvent(receipt.logs)
   return {
     ...args,
@@ -937,7 +941,11 @@ export async function burnSync<
   client: Client<Transport, chain, account>,
   parameters: burnSync.Parameters<chain, account>,
 ): Promise<burnSync.ReturnValue> {
-  const receipt = await burn.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await burn.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = burn.extractEvent(receipt.logs)
   return {
     ...args,

package/src/viem/actions/fee.ts

@@ -261,11 +261,11 @@ export async function setUserTokenSync<
   client: Client<Transport, chain, account>,
   parameters: setUserTokenSync.Parameters<chain, account>,
 ): Promise<setUserTokenSync.ReturnValue> {
-  const receipt = await setUserToken.inner(
-    writeContractSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await setUserToken.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = setUserToken.extractEvent(receipt.logs)
   return {
     ...args,

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,
     })
   }
 
@@ -223,7 +228,11 @@ export async function createSync<
   client: Client<Transport, chain, account>,
   parameters: createSync.Parameters<chain, account>,
 ): Promise<createSync.ReturnValue> {
-  const receipt = await create.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await create.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = create.extractEvent(receipt.logs)
   return {
     ...args,
@@ -415,7 +424,11 @@ export async function setAdminSync<
   client: Client<Transport, chain, account>,
   parameters: setAdminSync.Parameters<chain, account>,
 ): Promise<setAdminSync.ReturnValue> {
-  const receipt = await setAdmin.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await setAdmin.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = setAdmin.extractEvent(receipt.logs)
   return {
     ...args,
@@ -614,11 +627,11 @@ export async function modifyWhitelistSync<
   client: Client<Transport, chain, account>,
   parameters: modifyWhitelistSync.Parameters<chain, account>,
 ): Promise<modifyWhitelistSync.ReturnValue> {
-  const receipt = await modifyWhitelist.inner(
-    writeContractSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await modifyWhitelist.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = modifyWhitelist.extractEvent(receipt.logs)
   return {
     ...args,
@@ -817,11 +830,11 @@ export async function modifyBlacklistSync<
   client: Client<Transport, chain, account>,
   parameters: modifyBlacklistSync.Parameters<chain, account>,
 ): Promise<modifyBlacklistSync.ReturnValue> {
-  const receipt = await modifyBlacklist.inner(
-    writeContractSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await modifyBlacklist.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = modifyBlacklist.extractEvent(receipt.logs)
   return {
     ...args,

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

@@ -206,11 +206,20 @@ export async function approveSync<
   client: Client<Transport, chain, account>,
   parameters: approveSync.Parameters<chain, account>,
 ): Promise<approveSync.ReturnValue> {
-  const { token = usdAddress, ...rest } = parameters
-  const receipt = await approve.inner(writeContractSync, client, parameters, {
-    ...rest,
-    token,
-  })
+  const {
+    throwOnReceiptRevert = true,
+    token = usdAddress,
+    ...rest
+  } = parameters
+  const receipt = await approve.inner(
+    writeContractSync,
+    client,
+    { ...parameters, throwOnReceiptRevert } as never,
+    {
+      ...rest,
+      token,
+    },
+  )
   const { args } = approve.extractEvent(receipt.logs)
   return {
     ...args,
@@ -406,7 +415,11 @@ export async function burnBlockedSync<
   client: Client<Transport, chain, account>,
   parameters: burnBlockedSync.Parameters<chain, account>,
 ): Promise<burnBlockedSync.ReturnValue> {
-  const receipt = await burnBlocked.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await burnBlocked.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = burnBlocked.extractEvent(receipt.logs)
   return {
     ...args,
@@ -607,7 +620,11 @@ export async function burnSync<
   client: Client<Transport, chain, account>,
   parameters: burnSync.Parameters<chain, account>,
 ): Promise<burnSync.ReturnValue> {
-  const receipt = await burn.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await burn.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = burn.extractEvent(receipt.logs)
   return {
     ...args,
@@ -797,11 +814,11 @@ export async function changeTransferPolicySync<
   client: Client<Transport, chain, account>,
   parameters: changeTransferPolicySync.Parameters<chain, account>,
 ): Promise<changeTransferPolicySync.ReturnValue> {
-  const receipt = await changeTransferPolicy.inner(
-    writeContractSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await changeTransferPolicy.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = changeTransferPolicy.extractEvent(receipt.logs)
   return {
     ...args,
@@ -1019,7 +1036,11 @@ export async function createSync<
   client: Client<Transport, chain, account>,
   parameters: createSync.Parameters<chain, account>,
 ): Promise<createSync.ReturnValue> {
-  const receipt = await create.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await create.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
 
   const { args } = create.extractEvent(receipt.logs)
 
@@ -1081,12 +1102,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 +1354,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 +1451,7 @@ export declare namespace getMetadata {
  * const result = await actions.token.grantRoles(client, {
  *   token: '0x...',
  *   to: '0x...',
- *   roles: ['minter'],
+ *   roles: ['issuer'],
  * })
  * ```
  *
@@ -1509,11 +1608,11 @@ export async function grantRolesSync<
   client: Client<Transport, chain, account>,
   parameters: grantRolesSync.Parameters<chain, account>,
 ): Promise<grantRolesSync.ReturnValue> {
-  const receipt = await grantRoles.inner(
-    sendTransactionSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await grantRoles.inner(sendTransactionSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const events = grantRoles.extractEvents(receipt.logs)
   const value = events.map((event) => event.args)
   return {
@@ -1716,7 +1815,11 @@ export async function mintSync<
   client: Client<Transport, chain, account>,
   parameters: mintSync.Parameters<chain, account>,
 ): Promise<mintSync.ReturnValue> {
-  const receipt = await mint.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await mint.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = mint.extractEvent(receipt.logs)
   return {
     ...args,
@@ -1901,7 +2004,11 @@ export async function pauseSync<
   client: Client<Transport, chain, account>,
   parameters: pauseSync.Parameters<chain, account>,
 ): Promise<pauseSync.ReturnValue> {
-  const receipt = await pause.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await pause.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = pause.extractEvent(receipt.logs)
   return {
     ...args,
@@ -2121,7 +2228,11 @@ export async function permitSync<
   client: Client<Transport, chain, account>,
   parameters: permitSync.Parameters<chain, account>,
 ): Promise<permitSync.ReturnValue> {
-  const receipt = await permit.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await permit.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = permit.extractEvent(receipt.logs)
   return {
     ...args,
@@ -2317,11 +2428,11 @@ export async function renounceRolesSync<
   client: Client<Transport, chain, account>,
   parameters: renounceRolesSync.Parameters<chain, account>,
 ): Promise<renounceRolesSync.ReturnValue> {
-  const receipt = await renounceRoles.inner(
-    sendTransactionSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await renounceRoles.inner(sendTransactionSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const events = renounceRoles.extractEvents(receipt.logs)
   const value = events.map((event) => event.args)
   return {
@@ -2524,11 +2635,11 @@ export async function revokeRolesSync<
   client: Client<Transport, chain, account>,
   parameters: revokeRolesSync.Parameters<chain, account>,
 ): Promise<revokeRolesSync.ReturnValue> {
-  const receipt = await revokeRoles.inner(
-    sendTransactionSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await revokeRoles.inner(sendTransactionSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const events = revokeRoles.extractEvents(receipt.logs)
   const value = events.map((event) => event.args)
   return {
@@ -2715,11 +2826,11 @@ export async function setSupplyCapSync<
   client: Client<Transport, chain, account>,
   parameters: setSupplyCapSync.Parameters<chain, account>,
 ): Promise<setSupplyCapSync.ReturnValue> {
-  const receipt = await setSupplyCap.inner(
-    writeContractSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await setSupplyCap.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = setSupplyCap.extractEvent(receipt.logs)
   return {
     ...args,
@@ -2911,11 +3022,11 @@ export async function setRoleAdminSync<
   client: Client<Transport, chain, account>,
   parameters: setRoleAdminSync.Parameters<chain, account>,
 ): Promise<setRoleAdminSync.ReturnValue> {
-  const receipt = await setRoleAdmin.inner(
-    writeContractSync,
-    client,
-    parameters,
-  )
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await setRoleAdmin.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = setRoleAdmin.extractEvent(receipt.logs)
   return {
     ...args,
@@ -3127,7 +3238,11 @@ export async function transferSync<
   client: Client<Transport, chain, account>,
   parameters: transferSync.Parameters<chain, account>,
 ): Promise<transferSync.ReturnValue> {
-  const receipt = await transfer.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await transfer.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = transfer.extractEvent(receipt.logs)
   return {
     ...args,
@@ -3307,7 +3422,11 @@ export async function unpauseSync<
   client: Client<Transport, chain, account>,
   parameters: unpauseSync.Parameters<chain, account>,
 ): Promise<unpauseSync.ReturnValue> {
-  const receipt = await unpause.inner(writeContractSync, client, parameters)
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await unpause.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
   const { args } = unpause.extractEvent(receipt.logs)
   return {
     ...args,

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],