Claim Blocked Funds

Claims blocked funds for a receipt.

Usage

import { client } from './viem.config'
 
const { amount, receipt } = await client.receivePolicy.claimSync({
  receipt: '0x1234',
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb',
})
 
console.log('Amount:', amount)
console.log('Transaction hash:', receipt.transactionHash)
Amount: 1000000n
Transaction hash: 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef

import { Account, Client } from 'viem/tempo'
 
export const client = Client.create({
  account: Account.fromSecp256k1('0x...'),
})

Asynchronous Usage

The examples above use a *Sync variant of the action, that will wait for the transaction to be included before returning.

If you are optimizing for performance, you should use the non-sync receivePolicy.claim action and wait for inclusion manually:

import { Actions } from 'viem/tempo'
import { client } from './viem.config'
 
const hash = await client.receivePolicy.claim({
  receipt: '0x1234',
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb',
})
const receipt = await client.transaction.waitForReceipt({ hash }).receipt
 
const { args } = Actions.receivePolicy.claim.extractEvent(receipt.logs)

Recipes

Recover a Payment Your Transfer Blocked

A transfer blocked by the recipient's policy still succeeds, with the funds held instead of credited. When the policy's claimer is 'sender', extract the claim receipt from your token.transferSync receipt and reclaim the funds.

import { ReceivePolicyReceipt } from 'viem/tempo'
import { client } from './viem.config'
 
const { receipt } = await client.token.transferSync({
  amount: { decimals: 6, formatted: '500' },
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb',
  token: '0x20c0000000000000000000000000000000000001',
})
 
const [blocked] = ReceivePolicyReceipt.fromTransactionReceipt(receipt)
if (blocked)
  await client.receivePolicy.claimSync({
    receipt: blocked,
    to: client.account.address,
  })

import { Account, Client } from 'viem/tempo'
 
export const client = Client.create({
  account: Account.fromSecp256k1('0x...'),
})

Return a Blocked Payment to Its Sender

As the policy's claimer, decode the receipt with ReceivePolicyReceipt.decode and release the funds straight back to the originator: to accepts any destination, not just your own account.

import { ReceivePolicyReceipt } from 'viem/tempo'
import { client } from './viem.config'
 
// Receipt captured from a `TransferBlocked` event.
const blockedReceipt = '0x1234'
 
const { originator } = ReceivePolicyReceipt.decode(blockedReceipt)
 
const { amount, token } = await client.receivePolicy.claimSync({
  receipt: blockedReceipt,
  to: originator,
})
 
console.log(`Returned ${amount} of ${token} to ${originator}`)

import { Account, Client } from 'viem/tempo'
 
export const client = Client.create({
  account: Account.fromSecp256k1('0x...'),
})

Return Value

type ReturnType = {
  token: Address
  receiver: Address
  blockedNonce: bigint
  blockedAt: bigint
  receiptVersion: number
  originator: Address
  recipient: Address
  recoveryAuthority: Address
  caller: Address
  to: Address
  amount: bigint
  /** Transaction receipt. */
  receipt: TransactionReceipt
}

The claimed receipt event arguments and the transaction receipt.

Parameters

receipt

• Type: Hex

The encoded claim receipt.

to

• Type: Address

Destination to release the blocked funds to.

account (optional)

• Type: Account | Address

Account that will be used to send the transaction.

feePayer (optional)

• Type: Account | boolean

Fee payer for the transaction (TIP-1 gas sponsorship).

Pass true to defer the fee token to an external fee payer (e.g. a relay), or a local Account to co-sign the transaction as the fee payer.

feeToken (optional)

• Type: Address | bigint

Fee token for the transaction.

Can be an unpaused USD-denominated TIP-20 token address or ID.

gas (optional)

• Type: bigint

Gas limit for the transaction.

keyAuthorization (optional)

• Type: KeyAuthorization

Signed key authorization to include with the transaction, authorizing an access key to act for the sending account.

maxFeePerGas (optional)

• Type: bigint

Max fee per gas for the transaction.

maxPriorityFeePerGas (optional)

• Type: bigint

Max priority fee per gas for the transaction.

nonce (optional)

• Type: number

Nonce for the transaction.

nonceKey (optional)

• Type: 'expiring' | 'random' | bigint

Nonce key for the transaction (TIP-1009 2D nonces).

Use 'expiring' to select an expiring nonce, which enables concurrent transaction submission without nonce ordering. Use 'random' to select a random key.

throwOnReceiptRevert (optional)

• Type: boolean
• Default: true

Whether a Sync action throws when the receipt reports a revert.

validAfter (optional)

• Type: number

Unix timestamp after which the transaction can be included.

validBefore (optional)

• Type: number

Unix timestamp before which the transaction must be included.