PHP WebShell
Текущая директория: /usr/lib/node_modules/bitgo/node_modules/viem/zksync/actions
Просмотр файла: claimFailedDeposit.ts
import { type Address, parseAbi } from 'abitype'
import type { Account } from '../../accounts/types.js'
import { getTransaction } from '../../actions/public/getTransaction.js'
import { getTransactionReceipt } from '../../actions/public/getTransactionReceipt.js'
import { readContract } from '../../actions/public/readContract.js'
import {
type SendTransactionErrorType,
type SendTransactionParameters,
type SendTransactionReturnType,
sendTransaction,
} from '../../actions/wallet/sendTransaction.js'
import type { Client } from '../../clients/createClient.js'
import type { Transport } from '../../clients/transports/createTransport.js'
import { zeroHash } from '../../constants/bytes.js'
import { AccountNotFoundError } from '../../errors/account.js'
import { ClientChainNotConfiguredError } from '../../errors/chain.js'
import type { TransactionReceiptNotFoundErrorType } from '../../errors/transaction.js'
import type { GetAccountParameter } from '../../types/account.js'
import type {
Chain,
DeriveChain,
GetChainParameter,
} from '../../types/chain.js'
import type { Hash, Hex } from '../../types/misc.js'
import type { UnionEvaluate, UnionOmit } from '../../types/utils.js'
import {
decodeAbiParameters,
decodeFunctionData,
encodeAbiParameters,
encodeFunctionData,
type FormattedTransactionRequest,
isAddressEqual,
parseAccount,
} from '../../utils/index.js'
import { bootloaderFormalAddress } from '../constants/address.js'
import {
CannotClaimSuccessfulDepositError,
type CannotClaimSuccessfulDepositErrorType,
L2BridgeNotFoundError,
type L2BridgeNotFoundErrorType,
LogProofNotFoundError,
type LogProofNotFoundErrorType,
} from '../errors/bridge.js'
import type { ChainEIP712 } from '../types/chain.js'
import type { BridgeContractAddresses } from '../types/contract.js'
import type { ZksyncTransactionReceipt } from '../types/transaction.js'
import { undoL1ToL2Alias } from '../utils/bridge/undoL1ToL2Alias.js'
import { getDefaultBridgeAddresses } from './getDefaultBridgeAddresses.js'
import { getLogProof } from './getLogProof.js'
export type ClaimFailedDepositParameters<
chain extends Chain | undefined = Chain | undefined,
account extends Account | undefined = Account | undefined,
chainOverride extends Chain | undefined = Chain | undefined,
chainL2 extends ChainEIP712 | undefined = ChainEIP712 | undefined,
accountL2 extends Account | undefined = Account | undefined,
_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
> = UnionEvaluate<
UnionOmit<FormattedTransactionRequest<_derivedChain>, 'data' | 'to' | 'from'>
> &
Partial<GetChainParameter<chain, chainOverride>> &
Partial<GetAccountParameter<account>> & {
/** L2 client. */
client: Client<Transport, chainL2, accountL2>
/** The L2 transaction hash of the failed deposit. */
depositHash: Hash
}
export type ClaimFailedDepositReturnType = SendTransactionReturnType
export type ClaimFailedDepositErrorType =
| SendTransactionErrorType
| TransactionReceiptNotFoundErrorType
| CannotClaimSuccessfulDepositErrorType
| LogProofNotFoundErrorType
| L2BridgeNotFoundErrorType
/**
* Withdraws funds from the initiated deposit, which failed when finalizing on L2.
* If the deposit L2 transaction has failed, it sends an L1 transaction calling `claimFailedDeposit` method of the
* L1 bridge, which results in returning L1 tokens back to the depositor.
*
* @param client - Client to use
* @param parameters - {@link ClaimFailedDepositParameters}
* @returns hash - The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link ClaimFailedDepositReturnType}
*
* @example
* import { createPublicClient, http } from 'viem'
* import { privateKeyToAccount } from 'viem/accounts'
* import { zksync, mainnet } from 'viem/chains'
* import { claimFailedDeposit, publicActionsL2 } from 'viem/zksync'
*
* const client = createPublicClient({
* chain: mainnet,
* transport: http(),
* })
*
* const clientL2 = createPublicClient({
* chain: zksync,
* transport: http(),
* }).extend(publicActionsL2())
*
* const account = privateKeyToAccount('0x…')
*
* const hash = await claimFailedDeposit(client, {
* client: clientL2,
* account,
* depositHash: <L2_HASH_OF_FAILED_DEPOSIT>,
* })
*
* @example Account Hoisting
* import { createPublicClient, createWalletClient, http } from 'viem'
* import { privateKeyToAccount } from 'viem/accounts'
* import { zksync, mainnet } from 'viem/chains'
* import { publicActionsL2 } from 'viem/zksync'
*
* const walletClient = createWalletClient({
* chain: mainnet,
* transport: http(),
* account: privateKeyToAccount('0x…'),
* })
*
* const clientL2 = createPublicClient({
* chain: zksync,
* transport: http(),
* }).extend(publicActionsL2())
*
* const hash = await claimFailedDeposit(walletClient, {
* client: clientL2,
* depositHash: <L2_HASH_OF_FAILED_DEPOSIT>,
* })
*/
export async function claimFailedDeposit<
chain extends Chain | undefined,
account extends Account | undefined,
chainOverride extends Chain | undefined = Chain | undefined,
chainL2 extends ChainEIP712 | undefined = ChainEIP712 | undefined,
accountL2 extends Account | undefined = Account | undefined,
_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
>(
client: Client<Transport, chain, account>,
parameters: ClaimFailedDepositParameters<
chain,
account,
chainOverride,
chainL2,
accountL2
>,
): Promise<ClaimFailedDepositReturnType> {
const {
account: account_ = client.account,
chain: chain_ = client.chain,
client: l2Client,
depositHash,
...rest
} = parameters
const account = account_ ? parseAccount(account_) : client.account
if (!account)
throw new AccountNotFoundError({
docsPath: '/docs/actions/wallet/sendTransaction',
})
if (!l2Client.chain) throw new ClientChainNotConfiguredError()
const receipt = <ZksyncTransactionReceipt>(
await getTransactionReceipt(l2Client, { hash: depositHash })
)
const successL2ToL1LogIndex = receipt.l2ToL1Logs.findIndex(
(l2ToL1log) =>
isAddressEqual(<Hex>l2ToL1log.sender, bootloaderFormalAddress) &&
l2ToL1log.key === depositHash,
)
const successL2ToL1Log = receipt.l2ToL1Logs[successL2ToL1LogIndex]
if (successL2ToL1Log?.value !== zeroHash)
throw new CannotClaimSuccessfulDepositError({ hash: depositHash })
const tx = await getTransaction(l2Client, { hash: depositHash })
// Undo the aliasing, since the Mailbox contract set it as for contract address.
const l1BridgeAddress = undoL1ToL2Alias(receipt.from)
const l2BridgeAddress = receipt.to
if (!l2BridgeAddress) throw new L2BridgeNotFoundError()
const l1NativeTokenVault = (await getBridgeAddresses(client, l2Client))
.l1NativeTokenVault
let depositSender: Hex
let assetId: Hex
let assetData: Hex
try {
const { args } = decodeFunctionData({
abi: parseAbi([
'function finalizeDeposit(address _l1Sender, address _l2Receiver, address _l1Token, uint256 _amount, bytes _data)',
]),
data: tx.input,
})
assetData = encodeAbiParameters(
[{ type: 'uint256' }, { type: 'address' }, { type: 'address' }],
[args[3], args[1], args[2]],
)
assetId = await readContract(client, {
address: l1NativeTokenVault,
abi: parseAbi(['function assetId(address token) view returns (bytes32)']),
functionName: 'assetId',
args: [args[2]],
})
depositSender = args[0]
if (assetId === zeroHash)
throw new Error(`Token ${args[2]} not registered in NTV`)
} catch (_e) {
const { args } = decodeFunctionData({
abi: parseAbi([
'function finalizeDeposit(uint256 _chainId, bytes32 _assetId, bytes _transferData)',
]),
data: tx.input,
})
assetId = args[1]
const transferData = args[2]
const l1TokenAddress = await readContract(client, {
address: l1NativeTokenVault,
abi: parseAbi([
'function tokenAddress(bytes32 assetId) view returns (address)',
]),
functionName: 'tokenAddress',
args: [assetId],
})
const transferDataDecoded = decodeAbiParameters(
[
{ type: 'address' },
{ type: 'address' },
{ type: 'address' },
{ type: 'uint256' },
{ type: 'bytes' },
],
transferData,
)
assetData = encodeAbiParameters(
[{ type: 'uint256' }, { type: 'address' }, { type: 'address' }],
[transferDataDecoded[3], transferDataDecoded[1], l1TokenAddress],
)
depositSender = transferDataDecoded[0]
}
const proof = await getLogProof(l2Client, {
txHash: depositHash,
index: successL2ToL1LogIndex,
})
if (!proof)
throw new LogProofNotFoundError({
hash: depositHash,
index: successL2ToL1LogIndex,
})
const data = encodeFunctionData({
abi: parseAbi([
'function bridgeRecoverFailedTransfer(uint256 _chainId, address _depositSender, bytes32 _assetId, bytes _assetData, bytes32 _l2TxHash, uint256 _l2BatchNumber, uint256 _l2MessageIndex, uint16 _l2TxNumberInBatch, bytes32[] _merkleProof)',
]),
functionName: 'bridgeRecoverFailedTransfer',
args: [
BigInt(l2Client.chain.id),
depositSender,
assetId,
assetData,
depositHash,
receipt.l1BatchNumber!,
BigInt(proof.id),
Number(receipt.l1BatchTxIndex),
proof.proof,
],
})
return await sendTransaction(client, {
chain: chain_,
account,
to: l1BridgeAddress,
data,
...rest,
} as SendTransactionParameters)
}
async function getBridgeAddresses<
chain extends Chain | undefined,
chainL2 extends ChainEIP712 | undefined,
>(
client: Client<Transport, chain>,
l2Client: Client<Transport, chainL2>,
): Promise<
BridgeContractAddresses & {
l1Nullifier: Address
l1NativeTokenVault: Address
}
> {
const addresses = await getDefaultBridgeAddresses(l2Client)
let l1Nullifier = addresses.l1Nullifier
let l1NativeTokenVault = addresses.l1NativeTokenVault
if (!l1Nullifier)
l1Nullifier = await readContract(client, {
address: addresses.sharedL1,
abi: parseAbi(['function L1_NULLIFIER() view returns (address)']),
functionName: 'L1_NULLIFIER',
args: [],
})
if (!l1NativeTokenVault)
l1NativeTokenVault = await readContract(client, {
address: addresses.sharedL1,
abi: parseAbi(['function nativeTokenVault() view returns (address)']),
functionName: 'nativeTokenVault',
args: [],
})
return {
...addresses,
l1Nullifier,
l1NativeTokenVault,
}
}
Выполнить команду
Для локальной разработки. Не используйте в интернете!