Manage Your Stablecoin

import React from 'react'
import { Hooks } from 'wagmi/tempo'
import { parseUnits } from 'viem'
 
export function SetSupplyCap() {
  const tokenAddress = '0x...' // Your token address
 
  const { data: metadata, refetch: refetchMetadata
    Hooks.token.useGetMetadata({ token: tokenAddress }) 
 
  const setSupplyCap = Hooks.token.useSetSupplyCapSync({ 
    mutation: { onSettled: () => refetchMetadata
  }) 
 
  const handleSetSupplyCap = () => { 
    setSupplyCap.mutate({ 
      token: tokenAddress, 
      supplyCap: parseUnits('1000', metadata?.decimals || 6), 
    }) 
  } 
 
  return (
    <button
      disabled={setSupplyCap.isPending}
      onClick={handleSetSupplyCap}
      type="button"
    > 
    {setSupplyCap.isPending ? 'Setting...' : 'Set Cap'}
    </button> {}
  )
}

import { createConfig, http } from 'wagmi'
import { tempo } 

import React from 'react'
import { Hooks } from 'wagmi/tempo'
 
export function CreateTokenPolicy() {
  const tokenAddress = '0x...' // Your token address
 
  const createPolicy = Hooks.policy.useCreateSync({ 
    mutation: { 
      onSuccess(result) { 
        // Store policyId for the next step
        console.log('Policy ID:', result.policyId) 
      }, 
    }, 
  }) 
 
  const handleCreatePolicy = async () => { 
    await createPolicy.mutateAsync({ 
      addresses: [ 
        '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb', 
      ], 
      type: 'blacklist', 
    }) 
  } 
 
  return (
    <button
      disabled={createPolicy.isPending}
      onClick={handleCreatePolicy}
      type="button"
    > 
    {createPolicy.isPending ? 'Creating...' : 'Create Policy'}
    </button> {}
  )
}

import React from 'react'
import { Hooks } from 'wagmi/tempo'
 
export function LinkTokenPolicy() {
  const tokenAddress = '0x...' // Your token address

import { createConfig, http } from 'wagmi'
import { tempo } 

import React from 'react'
import { Hooks } from 'wagmi/tempo'
 
export function PauseUnpauseTransfers() {
  const tokenAddress = '0x...' // Your token address
 
  const { data: metadata, refetch: refetchMetadata
    Hooks.token.useGetMetadata({ token: tokenAddress }) 
 
  const pause = Hooks.token.usePauseSync({ 
    mutation: { onSettled: () => refetchMetadata
  }) 
 
  const unpause = Hooks.token.useUnpauseSync({ 
    mutation: { onSettled: () => refetchMetadata
  }) 
 
  const paused = metadata?.paused || false
 
  const handleToggle = () => { 
    if (paused) { 
      unpause.mutate({ 
        token: tokenAddress, 
      }) 
    } else { 
      pause.mutate({ 
        token: tokenAddress, 
      }) 
    } 
  } 
 
  const isProcessing = pause.isPending || unpause.isPending
 
  return (
    <button
      disabled={isProcessing}
      onClick={handleToggle}
      type="button"
    > 
    {isProcessing ? 'Processing...' : paused ? 'Unpause' : 'Pause'}
    </button> {}
  )
}

import { createConfig, http } from 'wagmi'
import { tempo } 

import React from 'react'
import { Hooks } from 'wagmi/tempo'
import { parseUnits } from 'viem'
 
export function BurnBlocked() {
  const tokenAddress = '0x...' // Your token address
  const blockedAddress = '0x...' // The blocked address to burn tokens from
 
  const { data: metadata } = Hooks.token.useGetMetadata
    token: tokenAddress, 
  }) 
 
  const burnBlocked = Hooks.token.useBurnBlockedSync() 
 
  const handleBurnBlocked = async () => { 
    if (!metadata) return
 
    await burnBlocked.mutateAsync({ 
      token: tokenAddress, 
      from: blockedAddress, 
      amount: parseUnits('100', metadata.decimals), 
    }) 
  } 
 
  return (
    <button
      disabled={burnBlocked.isPending}
      onClick={handleBurnBlocked}
      type="button"
    > 
    {burnBlocked.isPending ? 'Burning...' : 'Burn Blocked Tokens'}
    </button> {}
  )
}

import { createConfig, http } from 'wagmi'
import { tempo } 

import React from 'react'
import { Hooks } from 'wagmi/tempo'
import { useQueryClient } from '@tanstack/react-query'
 
export function GrantRoles() {
  const queryClient = useQueryClient()
  const tokenAddress = '0x...' // Your token address
  const treasuryAddress = '0x...' // Address to grant the issuer role
 
  // Grant the issuer role
  const grant = Hooks.token.useGrantRolesSync({
    mutation: { 
      onSettled() { 
        queryClient.refetchQueries({ queryKey: ['hasRole'] }) 
      }, 
    }, 
  })
 
  const handleGrantIssuer = async () => {
    await grant.mutate({
      token: tokenAddress,
      roles: ['issuer'],
      to: treasuryAddress,
    })
  }
 
  const { data: hasIssuerRole } = Hooks.token.useHasRole
    account: treasuryAddress, 
    token: tokenAddress, 
    role: 'issuer', 
  }) 
 
  return (
    <div>
      <button
        disabled={grant.isPending}
        onClick={handleGrantIssuer}
        type="button"
      >
        {grant.isPending ? 'Granting...' : 'Grant Issuer Role'}
      </button>
 
      {hasIssuerRole !== undefined && ( 
        <div> 
        Treasury {hasIssuerRole ? 'has' : 'does not have'} the issuer role // [!code ++]
        </div> {}
        )}
    </div>
  )
}

import { createConfig, http } from 'wagmi'
import { tempo } 

import React from 'react'
import { Hooks } from 'wagmi/tempo'
import { useQueryClient } from '@tanstack/react-query'
 
export function RevokeRoles() {
  const queryClient = useQueryClient()
  const tokenAddress = '0x...' // Your token address
  const treasuryAddress = '0x...' // Address to grant/revoke the issuer role
 
  // Grant the issuer role
  const grant = Hooks.token.useGrantRolesSync({
    mutation: {
      onSettled() {
        queryClient.refetchQueries({ queryKey: ['hasRole'] })
      },
    },
  })
 
  const handleGrantIssuer = async () => {
    await grant.mutate({
      token: tokenAddress,
      roles: ['issuer'],
      to: treasuryAddress,
    })
  }
 
  // Check if the treasury has the issuer role
  const { data: hasIssuerRole } = Hooks.token.useHasRole
    account: treasuryAddress,
    token: tokenAddress,
    role: 'issuer',
  })
 
  // Revoke the issuer role
  const revoke = Hooks.token.useRevokeRolesSync({ 
    mutation: { 
      onSettled() { 
        queryClient.refetchQueries({ queryKey: ['hasRole'] }) 
      }, 
    }, 
  }) 
 
  const handleRevokeIssuer = async () => { 
    await revoke.mutate({ 
      token: tokenAddress, 
      roles: ['issuer'], 
      from: treasuryAddress, 
    }) 
  } 
 
  return (
    <div>
      <button
        disabled={grant.isPending}
        onClick={handleGrantIssuer}
        type="button"
      >
        {grant.isPending ? 'Granting...' : 'Grant Issuer Role'}
      </button>
 
      <button
        disabled={revoke.isPending || !hasIssuerRole}
        onClick={handleRevokeIssuer}
        type="button"
      > 
      {revoke.isPending ? 'Revoking...' : 'Revoke Issuer Role'}
      </button> 
 
      {hasIssuerRole !== undefined && (
        <div>
          Treasury {hasIssuerRole ? 'has' : 'does not have'} the issuer role
        </div>
      )}
    </div>
  )
}

import { createConfig, http } from 'wagmi'
import { tempo }