编译器
0.8.23+commit.f704f362
文件 1 的 40：Address.sol
pragma solidity ^0.8.20;
library Address {
error AddressInsufficientBalance(address account);
error AddressEmptyCode(address target);
error FailedInnerCall();
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
function _revert(bytes memory returndata) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}
文件 2 的 40：AxelarExecutable.sol
pragma solidity ^0.8.0;
import { IAxelarGateway } from '../interfaces/IAxelarGateway.sol';
import { IAxelarExecutable } from '../interfaces/IAxelarExecutable.sol';
contract AxelarExecutable is IAxelarExecutable {
IAxelarGateway public gateway;
constructor(address gateway_) {
if (gateway_ == address(0)) revert InvalidAddress();
gateway = IAxelarGateway(gateway_);
}
function execute(
bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
bytes calldata payload
) external {
bytes32 payloadHash = keccak256(payload);
if (!gateway.validateContractCall(commandId, sourceChain, sourceAddress, payloadHash))
revert NotApprovedByGateway();
_execute(sourceChain, sourceAddress, payload);
}
function executeWithToken(
bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
bytes calldata payload,
string calldata tokenSymbol,
uint256 amount
) external {
bytes32 payloadHash = keccak256(payload);
if (
!gateway.validateContractCallAndMint(
commandId,
sourceChain,
sourceAddress,
payloadHash,
tokenSymbol,
amount
)
) revert NotApprovedByGateway();
_executeWithToken(sourceChain, sourceAddress, payload, tokenSymbol, amount);
}
function _execute(
string calldata sourceChain,
string calldata sourceAddress,
bytes calldata payload
) internal virtual {}
function _executeWithToken(
string calldata sourceChain,
string calldata sourceAddress,
bytes calldata payload,
string calldata tokenSymbol,
uint256 amount
) internal virtual {}
}
文件 3 的 40：ECDSA.sol
pragma solidity ^0.8.20;
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
error ECDSAInvalidSignature();
error ECDSAInvalidSignatureLength(uint256 length);
error ECDSAInvalidSignatureS(bytes32 s);
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
unchecked {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError, bytes32) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
_throwError(error, errorArg);
return recovered;
}
function _throwError(RecoverError error, bytes32 errorArg) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} else if (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} else if (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}
文件 4 的 40：EIP712.sol
pragma solidity ^0.8.20;
import {MessageHashUtils} from "./MessageHashUtils.sol";
import {ShortStrings, ShortString} from "../ShortStrings.sol";
import {IERC5267} from "../../interfaces/IERC5267.sol";
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
function _EIP712Name() internal view returns (string memory) {
return _name.toStringWithFallback(_nameFallback);
}
function _EIP712Version() internal view returns (string memory) {
return _version.toStringWithFallback(_versionFallback);
}
}
文件 5 的 40：GasEstimationTypes.sol
pragma solidity ^0.8.0;
enum GasEstimationType {
Default,
OptimismEcotone,
OptimismBedrock,
Arbitrum,
Scroll
}
struct GasInfo {
uint64 gasEstimationType;
uint64 l1FeeScalar;
uint128 axelarBaseFee;
uint128 relativeGasPrice;
uint128 relativeBlobBaseFee;
uint128 expressFee;
}
文件 6 的 40：IAllowanceTransfer.sol
pragma solidity ^0.8.0;
import {IEIP712} from "./IEIP712.sol";
interface IAllowanceTransfer is IEIP712 {
error AllowanceExpired(uint256 deadline);
error InsufficientAllowance(uint256 amount);
error ExcessiveInvalidation();
error TransferFailed();
event NonceInvalidation(
address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce
);
event Approval(
address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration
);
event Permit(
address indexed owner,
address indexed token,
address indexed spender,
uint160 amount,
uint48 expiration,
uint48 nonce
);
event Lockdown(address indexed owner, address token, address spender);
struct PermitDetails {
address token;
uint160 amount;
uint48 expiration;
uint48 nonce;
}
struct PermitSingle {
PermitDetails details;
address spender;
uint256 sigDeadline;
}
struct PermitBatch {
PermitDetails[] details;
address spender;
uint256 sigDeadline;
}
struct PackedAllowance {
uint160 amount;
uint48 expiration;
uint48 nonce;
}
struct TokenSpenderPair {
address token;
address spender;
}
struct AllowanceTransferDetails {
address from;
address to;
uint160 amount;
address token;
}
function allowance(address user, address token, address spender)
external
view
returns (uint160 amount, uint48 expiration, uint48 nonce);
function approve(address token, address spender, uint160 amount, uint48 expiration) external;
function permit(address owner, PermitSingle memory permitSingle, bytes calldata signature) external;
function permit(address owner, PermitBatch memory permitBatch, bytes calldata signature) external;
function transferFrom(address from, address to, uint160 amount, address token) external;
function transferFrom(AllowanceTransferDetails[] calldata transferDetails) external;
function lockdown(TokenSpenderPair[] calldata approvals) external;
function invalidateNonces(address token, address spender, uint48 newNonce) external;
}
文件 7 的 40：IAxelarExecutable.sol
pragma solidity ^0.8.0;
import { IAxelarGateway } from './IAxelarGateway.sol';
interface IAxelarExecutable {
error InvalidAddress();
error NotApprovedByGateway();
function gateway() external view returns (IAxelarGateway);
function execute(
bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
bytes calldata payload
) external;
function executeWithToken(
bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
bytes calldata payload,
string calldata tokenSymbol,
uint256 amount
) external;
}
文件 8 的 40：IAxelarGasService.sol
pragma solidity ^0.8.0;
import { GasInfo } from '../types/GasEstimationTypes.sol';
import { IInterchainGasEstimation } from './IInterchainGasEstimation.sol';
import { IUpgradable } from './IUpgradable.sol';
interface IAxelarGasService is IInterchainGasEstimation, IUpgradable {
error InvalidAddress();
error NotCollector();
error InvalidAmounts();
error InvalidGasUpdates();
error InvalidParams();
error InsufficientGasPayment(uint256 required, uint256 provided);
event GasPaidForContractCall(
address indexed sourceAddress,
string destinationChain,
string destinationAddress,
bytes32 indexed payloadHash,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
);
event GasPaidForContractCallWithToken(
address indexed sourceAddress,
string destinationChain,
string destinationAddress,
bytes32 indexed payloadHash,
string symbol,
uint256 amount,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
);
event NativeGasPaidForContractCall(
address indexed sourceAddress,
string destinationChain,
string destinationAddress,
bytes32 indexed payloadHash,
uint256 gasFeeAmount,
address refundAddress
);
event NativeGasPaidForContractCallWithToken(
address indexed sourceAddress,
string destinationChain,
string destinationAddress,
bytes32 indexed payloadHash,
string symbol,
uint256 amount,
uint256 gasFeeAmount,
address refundAddress
);
event GasPaidForExpressCall(
address indexed sourceAddress,
string destinationChain,
string destinationAddress,
bytes32 indexed payloadHash,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
);
event GasPaidForExpressCallWithToken(
address indexed sourceAddress,
string destinationChain,
string destinationAddress,
bytes32 indexed payloadHash,
string symbol,
uint256 amount,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
);
event NativeGasPaidForExpressCall(
address indexed sourceAddress,
string destinationChain,
string destinationAddress,
bytes32 indexed payloadHash,
uint256 gasFeeAmount,
address refundAddress
);
event NativeGasPaidForExpressCallWithToken(
address indexed sourceAddress,
string destinationChain,
string destinationAddress,
bytes32 indexed payloadHash,
string symbol,
uint256 amount,
uint256 gasFeeAmount,
address refundAddress
);
event GasAdded(
bytes32 indexed txHash,
uint256 indexed logIndex,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
);
event NativeGasAdded(bytes32 indexed txHash, uint256 indexed logIndex, uint256 gasFeeAmount, address refundAddress);
event ExpressGasAdded(
bytes32 indexed txHash,
uint256 indexed logIndex,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
);
event NativeExpressGasAdded(
bytes32 indexed txHash,
uint256 indexed logIndex,
uint256 gasFeeAmount,
address refundAddress
);
event Refunded(
bytes32 indexed txHash,
uint256 indexed logIndex,
address payable receiver,
address token,
uint256 amount
);
function payGas(
address sender,
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
uint256 executionGasLimit,
bool estimateOnChain,
address refundAddress,
bytes calldata params
) external payable;
function payGasForContractCall(
address sender,
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
) external;
function payGasForContractCallWithToken(
address sender,
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
string calldata symbol,
uint256 amount,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
) external;
function payNativeGasForContractCall(
address sender,
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
address refundAddress
) external payable;
function payNativeGasForContractCallWithToken(
address sender,
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
string calldata symbol,
uint256 amount,
address refundAddress
) external payable;
function payGasForExpressCall(
address sender,
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
) external;
function payGasForExpressCallWithToken(
address sender,
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
string calldata symbol,
uint256 amount,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
) external;
function payNativeGasForExpressCall(
address sender,
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
address refundAddress
) external payable;
function payNativeGasForExpressCallWithToken(
address sender,
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
string calldata symbol,
uint256 amount,
address refundAddress
) external payable;
function addGas(
bytes32 txHash,
uint256 logIndex,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
) external;
function addNativeGas(
bytes32 txHash,
uint256 logIndex,
address refundAddress
) external payable;
function addExpressGas(
bytes32 txHash,
uint256 logIndex,
address gasToken,
uint256 gasFeeAmount,
address refundAddress
) external;
function addNativeExpressGas(
bytes32 txHash,
uint256 logIndex,
address refundAddress
) external payable;
function updateGasInfo(string[] calldata chains, GasInfo[] calldata gasUpdates) external;
function collectFees(
address payable receiver,
address[] calldata tokens,
uint256[] calldata amounts
) external;
function refund(
bytes32 txHash,
uint256 logIndex,
address payable receiver,
address token,
uint256 amount
) external;
function gasCollector() external returns (address);
}
文件 9 的 40：IAxelarGateway.sol
pragma solidity ^0.8.0;
import { IGovernable } from './IGovernable.sol';
import { IImplementation } from './IImplementation.sol';
interface IAxelarGateway is IImplementation, IGovernable {
error NotSelf();
error InvalidCodeHash();
error SetupFailed();
error InvalidAuthModule();
error InvalidTokenDeployer();
error InvalidAmount();
error InvalidChainId();
error InvalidCommands();
error TokenDoesNotExist(string symbol);
error TokenAlreadyExists(string symbol);
error TokenDeployFailed(string symbol);
error TokenContractDoesNotExist(address token);
error BurnFailed(string symbol);
error MintFailed(string symbol);
error InvalidSetMintLimitsParams();
error ExceedMintLimit(string symbol);
event TokenSent(
address indexed sender,
string destinationChain,
string destinationAddress,
string symbol,
uint256 amount
);
event ContractCall(
address indexed sender,
string destinationChain,
string destinationContractAddress,
bytes32 indexed payloadHash,
bytes payload
);
event ContractCallWithToken(
address indexed sender,
string destinationChain,
string destinationContractAddress,
bytes32 indexed payloadHash,
bytes payload,
string symbol,
uint256 amount
);
event Executed(bytes32 indexed commandId);
event TokenDeployed(string symbol, address tokenAddresses);
event ContractCallApproved(
bytes32 indexed commandId,
string sourceChain,
string sourceAddress,
address indexed contractAddress,
bytes32 indexed payloadHash,
bytes32 sourceTxHash,
uint256 sourceEventIndex
);
event ContractCallApprovedWithMint(
bytes32 indexed commandId,
string sourceChain,
string sourceAddress,
address indexed contractAddress,
bytes32 indexed payloadHash,
string symbol,
uint256 amount,
bytes32 sourceTxHash,
uint256 sourceEventIndex
);
event ContractCallExecuted(bytes32 indexed commandId);
event TokenMintLimitUpdated(string symbol, uint256 limit);
event OperatorshipTransferred(bytes newOperatorsData);
event Upgraded(address indexed implementation);
function sendToken(
string calldata destinationChain,
string calldata destinationAddress,
string calldata symbol,
uint256 amount
) external;
function callContract(
string calldata destinationChain,
string calldata contractAddress,
bytes calldata payload
) external;
function callContractWithToken(
string calldata destinationChain,
string calldata contractAddress,
bytes calldata payload,
string calldata symbol,
uint256 amount
) external;
function isContractCallApproved(
bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
address contractAddress,
bytes32 payloadHash
) external view returns (bool);
function isContractCallAndMintApproved(
bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
address contractAddress,
bytes32 payloadHash,
string calldata symbol,
uint256 amount
) external view returns (bool);
function validateContractCall(
bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
bytes32 payloadHash
) external returns (bool);
function validateContractCallAndMint(
bytes32 commandId,
string calldata sourceChain,
string calldata sourceAddress,
bytes32 payloadHash,
string calldata symbol,
uint256 amount
) external returns (bool);
function authModule() external view returns (address);
function tokenDeployer() external view returns (address);
function tokenMintLimit(string memory symbol) external view returns (uint256);
function tokenMintAmount(string memory symbol) external view returns (uint256);
function allTokensFrozen() external view returns (bool);
function implementation() external view returns (address);
function tokenAddresses(string memory symbol) external view returns (address);
function tokenFrozen(string memory symbol) external view returns (bool);
function isCommandExecuted(bytes32 commandId) external view returns (bool);
function setTokenMintLimits(string[] calldata symbols, uint256[] calldata limits) external;
function upgrade(
address newImplementation,
bytes32 newImplementationCodeHash,
bytes calldata setupParams
) external;
function execute(bytes calldata input) external;
}
文件 10 的 40：IContractIdentifier.sol
pragma solidity ^0.8.0;
interface IContractIdentifier {
function contractId() external pure returns (bytes32);
}
文件 11 的 40：ICoral.sol
pragma solidity ^0.8.0;
interface ICoral {
enum FillType {
SINGLE,
MULTI
}
}
文件 12 的 40：IEIP712.sol
pragma solidity ^0.8.0;
interface IEIP712 {
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 13 的 40：IERC1271.sol
pragma solidity ^0.8.20;
interface IERC1271 {
function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}
文件 14 的 40：IERC20.sol
pragma solidity ^0.8.20;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
文件 15 的 40：IERC20Permit.sol
pragma solidity ^0.8.20;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 16 的 40：IERC5267.sol
pragma solidity ^0.8.20;
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
文件 17 的 40：IGovernable.sol
pragma solidity ^0.8.0;
interface IGovernable {
error NotGovernance();
error NotMintLimiter();
error InvalidGovernance();
error InvalidMintLimiter();
event GovernanceTransferred(address indexed previousGovernance, address indexed newGovernance);
event MintLimiterTransferred(address indexed previousGovernance, address indexed newGovernance);
function governance() external view returns (address);
function mintLimiter() external view returns (address);
function transferGovernance(address newGovernance) external;
function transferMintLimiter(address newGovernance) external;
}
文件 18 的 40：IImplementation.sol
pragma solidity ^0.8.0;
import { IContractIdentifier } from './IContractIdentifier.sol';
interface IImplementation is IContractIdentifier {
error NotProxy();
function setup(bytes calldata data) external;
}
文件 19 的 40：IInterchainAddressTracker.sol
pragma solidity ^0.8.0;
interface IInterchainAddressTracker {
error ZeroAddress();
error LengthMismatch();
error ZeroStringLength();
error UntrustedChain();
event TrustedAddressSet(string chain, string address_);
event TrustedAddressRemoved(string chain);
function chainName() external view returns (string memory);
function trustedAddress(string memory chain) external view returns (string memory trustedAddress_);
function trustedAddressHash(string memory chain) external view returns (bytes32 trustedAddressHash_);
function isTrustedAddress(string calldata chain, string calldata address_) external view returns (bool);
}
文件 20 的 40：IInterchainGasEstimation.sol
pragma solidity ^0.8.0;
import { GasEstimationType, GasInfo } from '../types/GasEstimationTypes.sol';
interface IInterchainGasEstimation {
error UnsupportedEstimationType(GasEstimationType gasEstimationType);
event GasInfoUpdated(string chain, GasInfo info);
function getGasInfo(string calldata chain) external view returns (GasInfo memory);
function estimateGasFee(
string calldata destinationChain,
string calldata destinationAddress,
bytes calldata payload,
uint256 executionGasLimit,
bytes calldata params
) external view returns (uint256 gasEstimate);
}
文件 21 的 40：IOwnable.sol
pragma solidity ^0.8.0;
interface IOwnable {
error NotOwner();
error InvalidOwner();
error InvalidOwnerAddress();
event OwnershipTransferStarted(address indexed newOwner);
event OwnershipTransferred(address indexed newOwner);
function owner() external view returns (address);
function pendingOwner() external view returns (address);
function transferOwnership(address newOwner) external;
function proposeOwnership(address newOwner) external;
function acceptOwnership() external;
}
文件 22 的 40：IPermit2.sol
pragma solidity ^0.8.0;
import {ISignatureTransfer} from "./ISignatureTransfer.sol";
import {IAllowanceTransfer} from "./IAllowanceTransfer.sol";
interface IPermit2 is ISignatureTransfer, IAllowanceTransfer {
}
文件 23 的 40：ISignatureTransfer.sol
pragma solidity ^0.8.0;
import {IEIP712} from "./IEIP712.sol";
interface ISignatureTransfer is IEIP712 {
error InvalidAmount(uint256 maxAmount);
error LengthMismatch();
event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);
struct TokenPermissions {
address token;
uint256 amount;
}
struct PermitTransferFrom {
TokenPermissions permitted;
uint256 nonce;
uint256 deadline;
}
struct SignatureTransferDetails {
address to;
uint256 requestedAmount;
}
struct PermitBatchTransferFrom {
TokenPermissions[] permitted;
uint256 nonce;
uint256 deadline;
}
function nonceBitmap(address, uint256) external view returns (uint256);
function permitTransferFrom(
PermitTransferFrom memory permit,
SignatureTransferDetails calldata transferDetails,
address owner,
bytes calldata signature
) external;
function permitWitnessTransferFrom(
PermitTransferFrom memory permit,
SignatureTransferDetails calldata transferDetails,
address owner,
bytes32 witness,
string calldata witnessTypeString,
bytes calldata signature
) external;
function permitTransferFrom(
PermitBatchTransferFrom memory permit,
SignatureTransferDetails[] calldata transferDetails,
address owner,
bytes calldata signature
) external;
function permitWitnessTransferFrom(
PermitBatchTransferFrom memory permit,
SignatureTransferDetails[] calldata transferDetails,
address owner,
bytes32 witness,
string calldata witnessTypeString,
bytes calldata signature
) external;
function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external;
}
文件 24 的 40：ISpoke.sol
pragma solidity ^0.8.0;
import {IAxelarGateway} from "./IAxelarGateway.sol";
import {IAxelarGasService} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol";
import {ICoral} from "./ICoral.sol";
import {IPermit2} from "./IPermit2.sol";
import {ISquidMulticall} from "./ISquidMulticall.sol";
interface ISpoke is ICoral {
enum OrderStatus {
EMPTY,
CREATED,
SETTLED,
REFUNDED
}
enum SettlementStatus {
EMPTY,
FILLED,
FORWARDED
}
struct Order {
address fromAddress;
address toAddress;
address filler;
address fromToken;
address toToken;
uint256 expiry;
uint256 fromAmount;
uint256 fillAmount;
uint256 feeRate;
uint256 fromChain;
uint256 toChain;
bytes32 postHookHash;
}
event SpokeInitialized(
IAxelarGateway indexed gateway,
IAxelarGasService indexed gasService,
IPermit2 indexed permit2,
ISquidMulticall squidMulticall,
address feeCollector,
string hubChainName,
string hubAddress
);
event FeesCollected(
address indexed feeCollector,
address indexed token,
uint256 indexed amount
);
event OrderCreated(bytes32 indexed orderHash, Order order);
event OrderRefunded(bytes32 indexed orderHash);
event TokensReleased(bytes32 indexed orderHash);
event OrderFilled(bytes32 indexed orderHash, Order order);
event SettlementForwarded(bytes32 indexed orderHash);
error GasRequired();
error InvalidAmount();
error InvalidArrayLength();
error InvalidDestinationChain();
error InvalidFillType();
error InvalidNativeAmount();
error InvalidPostHookProvided();
error InvalidSettlementFiller();
error InvalidSettlementSourceToken();
error InvalidSourceChain();
error InvalidTotalNativeAmount();
error InvalidUserSignature();
error NativeTokensNotAllowed();
error OnlyFeeCollector();
error OnlyFillerCanSettle();
error OnlyTrustedAddress();
error OrderAlreadyExists();
error OrderAlreadySettled();
error OrderExpired();
error OrderNotExpired();
error OrderNotSettled();
error OrderStateNotCreated();
error UnexpectedNativeToken();
function createOrder(Order calldata order) external payable;
function sponsorOrder(Order calldata order, bytes calldata signature) external;
function sponsorOrderUsingPermit2(
Order calldata order,
IPermit2.PermitTransferFrom calldata permit,
bytes calldata signature
) external;
function refundOrder(Order calldata order) external;
function collectFees(address[] calldata tokens) external;
function batchFillOrder(Order[] calldata orders, ISquidMulticall.Call[][] calldata calls) external payable;
function fillOrder(Order calldata order, ISquidMulticall.Call[] calldata calls) external payable;
function forwardSettlements(bytes32[] calldata orders) external payable;
function fillSingleChainAtomic(
Order calldata order,
ISquidMulticall.Call[] calldata calls,
bytes calldata signature
) external payable;
function batchSingleChainSettlements(
Order[] calldata orders,
address fromToken,
address filler
) external payable;
function batchMultiTokenSingleChainSettlements(
Order[] calldata orders,
address[] calldata fromTokens,
address filler
) external payable;
}
文件 25 的 40：ISquidMulticall.sol
pragma solidity ^0.8.9;
interface ISquidMulticall {
enum CallType {
Default,
FullTokenBalance,
FullNativeBalance,
CollectTokenBalance
}
struct Call {
CallType callType;
address target;
uint256 value;
bytes callData;
bytes payload;
}
error CallFailed(uint256 callPosition, bytes reason);
function run(Call[] calldata calls) external payable;
}
文件 26 的 40：IUpgradable.sol
pragma solidity ^0.8.0;
import { IOwnable } from './IOwnable.sol';
import { IImplementation } from './IImplementation.sol';
interface IUpgradable is IOwnable, IImplementation {
error InvalidCodeHash();
error InvalidImplementation();
error SetupFailed();
event Upgraded(address indexed newImplementation);
function implementation() external view returns (address);
function upgrade(
address newImplementation,
bytes32 newImplementationCodeHash,
bytes calldata params
) external;
}
文件 27 的 40：Initializable.sol
pragma solidity ^0.8.20;
abstract contract Initializable {
struct InitializableStorage {
uint64 _initialized;
bool _initializing;
}
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
error InvalidInitialization();
error NotInitializing();
event Initialized(uint64 version);
modifier initializer() {
InitializableStorage storage $ = _getInitializableStorage();
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint64 version) {
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
_checkInitializing();
_;
}
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
function _disableInitializers() internal virtual {
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}
文件 28 的 40：InterchainAddressTracker.sol
pragma solidity ^0.8.0;
import { IInterchainAddressTracker } from '../interfaces/IInterchainAddressTracker.sol';
import { StringStorage } from '../libs/StringStorage.sol';
contract InterchainAddressTracker is IInterchainAddressTracker {
bytes32 internal constant PREFIX_ADDRESS_MAPPING = keccak256('interchain-address-tracker-address-mapping');
bytes32 internal constant PREFIX_ADDRESS_HASH_MAPPING =
keccak256('interchain-address-tracker-address-hash-mapping');
bytes32 internal constant _CHAIN_NAME_SLOT = 0x0e2c162a1f4b5cff9fdbd6b34678a9bcb9898a0b9fbca695b112d61688d8b2ac;
function _setChainName(string memory chainName_) internal {
StringStorage.set(_CHAIN_NAME_SLOT, chainName_);
}
function chainName() external view returns (string memory chainName_) {
chainName_ = StringStorage.get(_CHAIN_NAME_SLOT);
}
function trustedAddress(string memory chain) public view returns (string memory trustedAddress_) {
trustedAddress_ = StringStorage.get(_getTrustedAddressSlot(chain));
}
function trustedAddressHash(string memory chain) public view returns (bytes32 trustedAddressHash_) {
bytes32 slot = _getTrustedAddressHashSlot(chain);
assembly {
trustedAddressHash_ := sload(slot)
}
}
function isTrustedAddress(string calldata chain, string calldata address_) public view returns (bool) {
bytes32 addressHash = keccak256(bytes(address_));
return addressHash == trustedAddressHash(chain);
}
function _getTrustedAddressSlot(string memory chain) internal pure returns (bytes32 slot) {
slot = keccak256(abi.encode(PREFIX_ADDRESS_MAPPING, chain));
}
function _getTrustedAddressHashSlot(string memory chain) internal pure returns (bytes32 slot) {
slot = keccak256(abi.encode(PREFIX_ADDRESS_HASH_MAPPING, chain));
}
function _setTrustedAddress(string memory chain, string memory address_) internal {
if (bytes(chain).length == 0) revert ZeroStringLength();
if (bytes(address_).length == 0) revert ZeroStringLength();
StringStorage.set(_getTrustedAddressSlot(chain), address_);
bytes32 slot = _getTrustedAddressHashSlot(chain);
bytes32 addressHash = keccak256(bytes(address_));
assembly {
sstore(slot, addressHash)
}
emit TrustedAddressSet(chain, address_);
}
function _removeTrustedAddress(string memory chain) internal {
if (bytes(chain).length == 0) revert ZeroStringLength();
StringStorage.clear(_getTrustedAddressSlot(chain));
bytes32 slot = _getTrustedAddressHashSlot(chain);
assembly {
sstore(slot, 0)
}
emit TrustedAddressRemoved(chain);
}
}
文件 29 的 40：Math.sol
pragma solidity ^0.8.20;
library Math {
error MathOverflowedMulDiv();
enum Rounding {
Floor,
Ceil,
Trunc,
Expand
}
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
return a / b;
}
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0 = x * y;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (0 - denominator);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
文件 30 的 40：MessageHashUtils.sol
pragma solidity ^0.8.20;
import {Strings} from "../Strings.sol";
library MessageHashUtils {
function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, messageHash)
digest := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
return
keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}
文件 31 的 40：ReentrancyGuard.sol
pragma solidity ^0.8.20;
abstract contract ReentrancyGuard {
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
uint256 private _status;
error ReentrancyGuardReentrantCall();
constructor() {
_status = NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
if (_status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
_status = ENTERED;
}
function _nonReentrantAfter() private {
_status = NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == ENTERED;
}
}
文件 32 的 40：SafeERC20.sol
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
error SafeERC20FailedOperation(address token);
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}
文件 33 的 40：ShortStrings.sol
pragma solidity ^0.8.20;
import {StorageSlot} from "./StorageSlot.sol";
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
文件 34 的 40：SignatureChecker.sol
pragma solidity ^0.8.20;
import {ECDSA} from "./ECDSA.sol";
import {IERC1271} from "../../interfaces/IERC1271.sol";
library SignatureChecker {
function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
(address recovered, ECDSA.RecoverError error, ) = ECDSA.tryRecover(hash, signature);
return
(error == ECDSA.RecoverError.NoError && recovered == signer) ||
isValidERC1271SignatureNow(signer, hash, signature);
}
function isValidERC1271SignatureNow(
address signer,
bytes32 hash,
bytes memory signature
) internal view returns (bool) {
(bool success, bytes memory result) = signer.staticcall(
abi.encodeCall(IERC1271.isValidSignature, (hash, signature))
);
return (success &&
result.length >= 32 &&
abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
}
}
文件 35 的 40：SignedMath.sol
pragma solidity ^0.8.20;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 36 的 40：Spoke.sol
pragma solidity ^0.8.0;
import {AxelarExecutable} from "./axelar/AxelarExecutable.sol";
import {IAxelarGateway} from "./interfaces/IAxelarGateway.sol";
import {IAxelarGasService} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol";
import {InterchainAddressTracker} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/utils/InterchainAddressTracker.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ISquidMulticall} from "./interfaces/ISquidMulticall.sol";
import {IPermit2} from "./interfaces/IPermit2.sol";
import {ISpoke} from "./interfaces/ISpoke.sol";
import {Utils} from "./libraries/Utils.sol";
contract Spoke is ISpoke, AxelarExecutable, Initializable, InterchainAddressTracker, ReentrancyGuard, EIP712 {
using Address for address payable;
using SafeERC20 for IERC20;
mapping(address => uint256) public tokenToCollectedFees;
mapping(bytes32 => OrderStatus) public orderHashToStatus;
mapping(bytes32 => SettlementStatus) public settlementToStatus;
IAxelarGasService public gasService;
IPermit2 public permit2;
ISquidMulticall public squidMulticall;
address public feeCollector;
string public hubChainName;
string public hubAddress;
modifier onlyFeeCollector() {
if (msg.sender != feeCollector) revert OnlyFeeCollector();
_;
}
modifier onlyTrustedAddress(string calldata fromChainName, string calldata fromContractAddress) {
if (!isTrustedAddress(fromChainName, fromContractAddress)) revert OnlyTrustedAddress();
_;
}
constructor() AxelarExecutable(0x1111111111111111111111111111111111111111) EIP712("Spoke", "1") {}
function initialize(
IAxelarGateway _axelarGateway,
IAxelarGasService _axelarGasService,
IPermit2 _permit2,
ISquidMulticall _squidMulticall,
address _feeCollector,
string memory _hubChainName,
string memory _hubAddress
) external initializer {
gateway = _axelarGateway;
gasService = _axelarGasService;
permit2 = _permit2;
squidMulticall = _squidMulticall;
feeCollector = _feeCollector;
hubChainName = _hubChainName;
hubAddress = _hubAddress;
_setTrustedAddress(_hubChainName, _hubAddress);
emit SpokeInitialized(
gateway,
gasService,
permit2,
squidMulticall,
feeCollector,
hubChainName,
hubAddress
);
}
function createOrder(Order calldata order) external payable {
_createOrder(order, msg.sender);
}
function sponsorOrder(Order calldata order, bytes calldata signature) external {
if (order.fromToken == Utils.NATIVE_TOKEN) revert NativeTokensNotAllowed();
if (
!SignatureChecker.isValidSignatureNow(
order.fromAddress,
_hashTypedDataV4(_hashOrderTyped(order)),
signature
)
) revert InvalidUserSignature();
_createOrder(order, order.fromAddress);
}
function _createOrder(Order calldata order, address fromAddress) private nonReentrant {
bytes32 orderHash = keccak256(abi.encode(order));
if (orderHashToStatus[orderHash] != OrderStatus.EMPTY) revert OrderAlreadyExists();
if (block.timestamp > order.expiry) revert OrderExpired();
if (order.fromChain != _getChainId()) revert InvalidSourceChain();
if (order.fromToken != Utils.NATIVE_TOKEN && msg.value != 0) revert UnexpectedNativeToken();
orderHashToStatus[orderHash] = OrderStatus.CREATED;
if (order.fromToken == Utils.NATIVE_TOKEN) {
if (msg.value != order.fromAmount) revert InvalidNativeAmount();
} else {
IERC20(order.fromToken).safeTransferFrom(fromAddress, address(this), order.fromAmount);
}
emit OrderCreated(orderHash, order);
}
function sponsorOrderUsingPermit2(
Order calldata order,
IPermit2.PermitTransferFrom calldata permit,
bytes calldata signature
) external nonReentrant {
bytes32 orderHash = keccak256(abi.encode(order));
if (orderHashToStatus[orderHash] != OrderStatus.EMPTY) revert OrderAlreadyExists();
if (block.timestamp > order.expiry) revert OrderExpired();
if (order.fromChain != _getChainId()) revert InvalidSourceChain();
if (order.fromToken == Utils.NATIVE_TOKEN) revert NativeTokensNotAllowed();
orderHashToStatus[orderHash] = OrderStatus.CREATED;
IPermit2.SignatureTransferDetails memory transferDetails;
transferDetails.to = address(this);
transferDetails.requestedAmount = order.fromAmount;
bytes32 witness = _hashOrderTyped(order);
permit2.permitWitnessTransferFrom(
permit,
transferDetails,
order.fromAddress,
witness,
Utils.ORDER_WITNESS_TYPE_STRING,
signature
);
emit OrderCreated(orderHash, order);
}
function refundOrder(Order calldata order) external nonReentrant {
bytes32 orderHash = keccak256(abi.encode(order));
if (orderHashToStatus[orderHash] != OrderStatus.CREATED) revert OrderStateNotCreated();
if (msg.sender != order.filler) {
if (!(block.timestamp > (order.expiry + 1 days))) revert OrderNotExpired();
}
if (order.fromChain != _getChainId()) revert InvalidSourceChain();
orderHashToStatus[orderHash] = OrderStatus.REFUNDED;
if (order.fromToken == Utils.NATIVE_TOKEN) {
payable(order.fromAddress).sendValue(order.fromAmount);
} else {
IERC20(order.fromToken).safeTransfer(order.fromAddress, order.fromAmount);
}
emit OrderRefunded(orderHash);
}
function collectFees(address[] calldata tokens) external onlyFeeCollector {
if (tokens.length == 0) revert InvalidArrayLength();
for (uint256 i = 0; i < tokens.length; i++) {
uint256 feeAmount = tokenToCollectedFees[tokens[i]];
if (feeAmount > 0) {
tokenToCollectedFees[tokens[i]] = 0;
if (tokens[i] == Utils.NATIVE_TOKEN) {
payable(feeCollector).sendValue(feeAmount);
} else {
IERC20(tokens[i]).safeTransfer(feeCollector, feeAmount);
}
}
emit FeesCollected(feeCollector, tokens[i], feeAmount);
}
}
function batchFillOrder(Order[] calldata orders, ISquidMulticall.Call[][] calldata calls) external payable {
if (
orders.length == 0 ||
orders.length != calls.length
) revert InvalidArrayLength();
uint256 remainingNativeTokenValue = msg.value;
for (uint256 i = 0; i < orders.length; i++) {
if (orders[i].toToken == Utils.NATIVE_TOKEN) {
if (remainingNativeTokenValue < orders[i].fillAmount) revert InvalidTotalNativeAmount();
remainingNativeTokenValue -= orders[i].fillAmount;
}
_fillOrder(orders[i], calls[i]);
}
}
function fillOrder(Order calldata order, ISquidMulticall.Call[] calldata calls) public payable {
if (order.toToken == Utils.NATIVE_TOKEN && msg.value != order.fillAmount) {
revert InvalidNativeAmount();
}
_fillOrder(order, calls);
}
function _fillOrder(Order memory order, ISquidMulticall.Call[] calldata calls) internal nonReentrant {
bytes32 orderHash = keccak256(abi.encode(order));
if (settlementToStatus[orderHash] != SettlementStatus.EMPTY) revert OrderAlreadySettled();
if (msg.sender != order.filler) revert OnlyFillerCanSettle();
if (order.toChain != _getChainId()) revert InvalidDestinationChain();
settlementToStatus[orderHash] = SettlementStatus.FILLED;
if (order.toToken == Utils.NATIVE_TOKEN) {
if (order.postHookHash != bytes32(0)) {
bytes memory callsData = abi.encode(calls);
if (keccak256(callsData) != order.postHookHash) revert InvalidPostHookProvided();
ISquidMulticall(squidMulticall).run{value: order.fillAmount}(calls);
} else {
payable(order.toAddress).sendValue(order.fillAmount);
}
} else {
if (order.postHookHash != bytes32(0)) {
bytes memory callsData = abi.encode(calls);
if (keccak256(callsData) != order.postHookHash) revert InvalidPostHookProvided();
IERC20(order.toToken).safeTransferFrom(
order.filler,
address(squidMulticall),
order.fillAmount
);
ISquidMulticall(squidMulticall).run(calls);
} else {
IERC20(order.toToken).safeTransferFrom(
order.filler,
order.toAddress,
order.fillAmount
);
}
}
emit OrderFilled(orderHash, order);
}
function forwardSettlements(bytes32[] calldata orderHashes) external payable nonReentrant {
if (msg.value == 0) revert GasRequired();
if (orderHashes.length == 0) revert InvalidArrayLength();
for (uint256 i = 0; i < orderHashes.length; i++) {
if (
settlementToStatus[orderHashes[i]] == SettlementStatus.EMPTY
) revert OrderNotSettled();
settlementToStatus[orderHashes[i]] = SettlementStatus.FORWARDED;
emit SettlementForwarded(orderHashes[i]);
}
bytes memory payload = abi.encode(orderHashes);
gasService.payNativeGasForContractCall{value: msg.value}(
address(this),
hubChainName,
hubAddress,
payload,
msg.sender
);
gateway.callContract(hubChainName, hubAddress, payload);
}
function fillSingleChainAtomic(
Order calldata order,
ISquidMulticall.Call[] calldata calls,
bytes calldata signature
) external payable nonReentrant {
bytes32 orderHash = keccak256(abi.encode(order));
if (
!SignatureChecker.isValidSignatureNow(
order.fromAddress,
_hashTypedDataV4(_hashOrderTyped(order)),
signature
)
) revert InvalidUserSignature();
if (orderHashToStatus[orderHash] != OrderStatus.EMPTY) revert OrderAlreadyExists();
if (settlementToStatus[orderHash] != SettlementStatus.EMPTY) revert OrderAlreadySettled();
if (block.timestamp > order.expiry) revert OrderExpired();
if (order.fromChain != _getChainId()) revert InvalidSourceChain();
if (order.toChain != _getChainId()) revert InvalidDestinationChain();
if (order.fromToken == Utils.NATIVE_TOKEN) revert NativeTokensNotAllowed();
if (order.toToken != Utils.NATIVE_TOKEN && msg.value != 0) revert UnexpectedNativeToken();
if (order.fromAmount == 0) revert InvalidAmount();
if (msg.sender != order.filler) revert OnlyFillerCanSettle();
uint256 fee = (order.fromAmount * order.feeRate) / Utils.FEE_DIVISOR;
uint256 fromAmount = order.fromAmount - fee;
tokenToCollectedFees[order.fromToken] += fee;
orderHashToStatus[orderHash] = OrderStatus.SETTLED;
IERC20(order.fromToken).safeTransferFrom(order.fromAddress, order.filler, fromAmount);
settlementToStatus[orderHash] = SettlementStatus.FORWARDED;
if (order.toToken == Utils.NATIVE_TOKEN) {
if (order.postHookHash != bytes32(0)) {
bytes memory callsData = abi.encode(calls);
if (keccak256(callsData) != order.postHookHash) revert InvalidPostHookProvided();
ISquidMulticall(squidMulticall).run{value: order.fillAmount}(calls);
} else {
payable(order.toAddress).sendValue(order.fillAmount);
}
} else {
if (order.postHookHash != bytes32(0)) {
bytes memory callsData = abi.encode(calls);
if (keccak256(callsData) != order.postHookHash) revert InvalidPostHookProvided();
IERC20(order.toToken).safeTransferFrom(
order.filler,
address(squidMulticall),
order.fillAmount
);
ISquidMulticall(squidMulticall).run(calls);
} else {
IERC20(order.toToken).safeTransferFrom(
order.filler,
order.toAddress,
order.fillAmount
);
}
}
emit OrderFilled(orderHash, order);
}
function batchSingleChainSettlements(
Order[] calldata orders,
address fromToken,
address filler
) external payable {
if (orders.length == 0) revert InvalidArrayLength();
bytes32[] memory orderHashes = new bytes32[](orders.length);
uint256 fromAmount = 0;
uint256 fees = 0;
for (uint256 i = 0; i < orders.length; i++) {
bytes32 orderHash = keccak256(abi.encode(orders[i]));
if (settlementToStatus[orderHash] != SettlementStatus.FILLED)
revert OrderNotSettled();
if (orders[i].fromChain != _getChainId()) revert InvalidDestinationChain();
if (orders[i].toChain != _getChainId()) revert InvalidSourceChain();
if (orders[i].filler != filler) revert InvalidSettlementFiller();
if (orders[i].fromToken != fromToken) revert InvalidSettlementSourceToken();
uint256 fee = (orders[i].fromAmount * orders[i].feeRate) / Utils.FEE_DIVISOR;
settlementToStatus[orderHash] = SettlementStatus.FORWARDED;
fees += fee;
fromAmount += orders[i].fromAmount - fee;
orderHashes[i] = orderHash;
}
_releaseBatched(orderHashes, filler, fromAmount, fees, fromToken);
}
function batchMultiTokenSingleChainSettlements(
Order[] calldata orders,
address[] calldata fromTokens,
address filler
) external payable {
if (orders.length == 0 || fromTokens.length < 2) revert InvalidArrayLength();
bytes32[] memory orderHashes = new bytes32[](orders.length);
uint256[] memory fromAmounts = new uint256[](fromTokens.length);
uint256[] memory fees = new uint256[](fromTokens.length);
for (uint256 i = 0; i < orders.length; i++) {
bytes32 orderHash = keccak256(abi.encode(orders[i]));
if (settlementToStatus[orderHash] != SettlementStatus.FILLED)
revert OrderNotSettled();
if (orders[i].fromChain != _getChainId()) revert InvalidDestinationChain();
if (orders[i].toChain != _getChainId()) revert InvalidSourceChain();
if (orders[i].filler != filler) revert InvalidSettlementFiller();
uint256 tokenIndex = _findTokenIndex(orders[i].fromToken, fromTokens);
if (tokenIndex == type(uint256).max) revert InvalidSettlementSourceToken();
uint256 fee = (orders[i].fromAmount * orders[i].feeRate) / Utils.FEE_DIVISOR;
settlementToStatus[orderHash] = SettlementStatus.FORWARDED;
fees[tokenIndex] += fee;
fromAmounts[tokenIndex] += orders[i].fromAmount - fee;
orderHashes[i] = orderHash;
}
_releaseMultiTokenBatched(orderHashes, filler, fromAmounts, fees, fromTokens);
}
function _execute(
string calldata fromChain,
string calldata fromContractAddress,
bytes calldata payload
) internal virtual override onlyTrustedAddress(fromChain, fromContractAddress) {
(
FillType fillType,
bytes32[] memory orderHashes,
address filler,
uint256[] memory fromAmounts,
uint256[] memory processedFees,
address[] memory fromTokens
) = abi.decode(
payload,
(FillType, bytes32[], address, uint256[], uint256[], address[])
);
if (fillType == FillType.SINGLE) {
if (
fromTokens.length != 1 ||
fromAmounts.length != 1 ||
processedFees.length != 1
) revert InvalidArrayLength();
_releaseBatched(orderHashes, filler, fromAmounts[0], processedFees[0], fromTokens[0]);
} else if (fillType == FillType.MULTI) {
_releaseMultiTokenBatched(orderHashes, filler, fromAmounts, processedFees, fromTokens);
} else {
revert InvalidFillType();
}
}
function _releaseBatched(
bytes32[] memory orderHashes,
address filler,
uint256 fromAmount,
uint256 processedFees,
address fromToken
) internal nonReentrant {
if (orderHashes.length == 0) revert InvalidArrayLength();
for (uint256 i = 0; i < orderHashes.length; i++) {
bytes32 orderHash = orderHashes[i];
if (orderHashToStatus[orderHash] != OrderStatus.CREATED) revert OrderStateNotCreated();
orderHashToStatus[orderHash] = OrderStatus.SETTLED;
emit TokensReleased(orderHash);
}
tokenToCollectedFees[fromToken] += processedFees;
if (fromToken == Utils.NATIVE_TOKEN) {
payable(filler).sendValue(fromAmount);
} else {
IERC20(fromToken).safeTransfer(filler, fromAmount);
}
}
function _releaseMultiTokenBatched(
bytes32[] memory orderHashes,
address filler,
uint256[] memory fromAmounts,
uint256[] memory processedFees,
address[] memory fromTokens
) internal nonReentrant {
if (
orderHashes.length == 0 ||
fromAmounts.length != fromTokens.length ||
processedFees.length != fromTokens.length ||
fromTokens.length < 2
) revert InvalidArrayLength();
for (uint256 i = 0; i < orderHashes.length; i++) {
bytes32 orderHash = orderHashes[i];
if (orderHashToStatus[orderHash] != OrderStatus.CREATED) revert OrderStateNotCreated();
orderHashToStatus[orderHash] = OrderStatus.SETTLED;
emit TokensReleased(orderHash);
}
for (uint256 i = 0; i < fromTokens.length; i++) {
tokenToCollectedFees[fromTokens[i]] += processedFees[i];
if (fromTokens[i] == Utils.NATIVE_TOKEN) {
payable(filler).sendValue(fromAmounts[i]);
} else {
IERC20(fromTokens[i]).safeTransfer(filler, fromAmounts[i]);
}
}
}
function _hashOrderTyped(Order calldata order) private pure returns (bytes32) {
return keccak256(abi.encode(
Utils.ORDER_TYPEHASH,
order.fromAddress,
order.toAddress,
order.filler,
order.fromToken,
order.toToken,
order.expiry,
order.fromAmount,
order.fillAmount,
order.feeRate,
order.fromChain,
order.toChain,
order.postHookHash
));
}
function _findTokenIndex(
address token,
address[] calldata fromTokens
) private pure returns (uint256) {
for (uint256 i = 0; i < fromTokens.length; i++) {
if (fromTokens[i] == token) {
return i;
}
}
return type(uint256).max;
}
function _getChainId() private view returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
文件 37 的 40：StorageSlot.sol
pragma solidity ^0.8.20;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
文件 38 的 40：StringStorage.sol
pragma solidity ^0.8.0;
library StringStorage {
struct Wrapper {
string value;
}
function set(bytes32 slot, string memory value) internal {
_getStorageStruct(slot).value = value;
}
function get(bytes32 slot) internal view returns (string memory value) {
value = _getStorageStruct(slot).value;
}
function clear(bytes32 slot) internal {
delete _getStorageStruct(slot).value;
}
function _getStorageStruct(bytes32 slot) internal pure returns (Wrapper storage wrapper) {
assembly {
wrapper.slot := slot
}
}
}
文件 39 的 40：Strings.sol
pragma solidity ^0.8.20;
import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
error StringsInsufficientHexLength(uint256 value, uint256 length);
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 40 的 40：Utils.sol
pragma solidity 0.8.23;
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
library Utils {
using Address for address payable;
address internal constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
bytes32 internal constant ORDER_TYPEHASH = keccak256("Order(address fromAddress,address toAddress,address filler,address fromToken,address toToken,uint256 expiry,uint256 fromAmount,uint256 fillAmount,uint256 feeRate,uint256 fromChain,uint256 toChain,bytes32 postHookHash)");
string internal constant ORDER_WITNESS_TYPE_STRING =
"Order witness)Order(address fromAddress,address toAddress,address filler,address fromToken,address toToken,uint256 expiry,uint256 fromAmount,uint256 fillAmount,uint256 feeRate,uint256 fromChain,uint256 toChain,bytes32 postHookHash)TokenPermissions(address token,uint256 amount)";
uint256 internal constant FEE_DIVISOR = 1000000;
}
{
"compilationTarget": {
"contracts/Spoke.sol": "Spoke"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 9999
},
"remappings": [],
"viaIR": true
}[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"GasRequired","type":"error"},{"inputs":[],"name":"InvalidAddress","type":"error"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidArrayLength","type":"error"},{"inputs":[],"name":"InvalidDestinationChain","type":"error"},{"inputs":[],"name":"InvalidFillType","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidNativeAmount","type":"error"},{"inputs":[],"name":"InvalidPostHookProvided","type":"error"},{"inputs":[],"name":"InvalidSettlementFiller","type":"error"},{"inputs":[],"name":"InvalidSettlementSourceToken","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[],"name":"InvalidSourceChain","type":"error"},{"inputs":[],"name":"InvalidTotalNativeAmount","type":"error"},{"inputs":[],"name":"InvalidUserSignature","type":"error"},{"inputs":[],"name":"LengthMismatch","type":"error"},{"inputs":[],"name":"NativeTokensNotAllowed","type":"error"},{"inputs":[],"name":"NotApprovedByGateway","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"OnlyFeeCollector","type":"error"},{"inputs":[],"name":"OnlyFillerCanSettle","type":"error"},{"inputs":[],"name":"OnlyTrustedAddress","type":"error"},{"inputs":[],"name":"OrderAlreadyExists","type":"error"},{"inputs":[],"name":"OrderAlreadySettled","type":"error"},{"inputs":[],"name":"OrderExpired","type":"error"},{"inputs":[],"name":"OrderNotExpired","type":"error"},{"inputs":[],"name":"OrderNotSettled","type":"error"},{"inputs":[],"name":"OrderStateNotCreated","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"inputs":[],"name":"UnexpectedNativeToken","type":"error"},{"inputs":[],"name":"UntrustedChain","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroStringLength","type":"error"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"feeCollector","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeesCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"indexed":false,"internalType":"struct ISpoke.Order","name":"order","type":"tuple"}],"name":"OrderCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"indexed":false,"internalType":"struct ISpoke.Order","name":"order","type":"tuple"}],"name":"OrderFilled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"OrderRefunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"SettlementForwarded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IAxelarGateway","name":"gateway","type":"address"},{"indexed":true,"internalType":"contract IAxelarGasService","name":"gasService","type":"address"},{"indexed":true,"internalType":"contract IPermit2","name":"permit2","type":"address"},{"indexed":false,"internalType":"contract ISquidMulticall","name":"squidMulticall","type":"address"},{"indexed":false,"internalType":"address","name":"feeCollector","type":"address"},{"indexed":false,"internalType":"string","name":"hubChainName","type":"string"},{"indexed":false,"internalType":"string","name":"hubAddress","type":"string"}],"name":"SpokeInitialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"TokensReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"chain","type":"string"}],"name":"TrustedAddressRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"chain","type":"string"},{"indexed":false,"internalType":"string","name":"address_","type":"string"}],"name":"TrustedAddressSet","type":"event"},{"inputs":[{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"internalType":"struct ISpoke.Order[]","name":"orders","type":"tuple[]"},{"components":[{"internalType":"enum ISquidMulticall.CallType","name":"callType","type":"uint8"},{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes","name":"payload","type":"bytes"}],"internalType":"struct ISquidMulticall.Call[][]","name":"calls","type":"tuple[][]"}],"name":"batchFillOrder","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"internalType":"struct ISpoke.Order[]","name":"orders","type":"tuple[]"},{"internalType":"address[]","name":"fromTokens","type":"address[]"},{"internalType":"address","name":"filler","type":"address"}],"name":"batchMultiTokenSingleChainSettlements","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"internalType":"struct ISpoke.Order[]","name":"orders","type":"tuple[]"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"filler","type":"address"}],"name":"batchSingleChainSettlements","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"chainName","outputs":[{"internalType":"string","name":"chainName_","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"}],"name":"collectFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"internalType":"struct ISpoke.Order","name":"order","type":"tuple"}],"name":"createOrder","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"commandId","type":"bytes32"},{"internalType":"string","name":"sourceChain","type":"string"},{"internalType":"string","name":"sourceAddress","type":"string"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"execute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"commandId","type":"bytes32"},{"internalType":"string","name":"sourceChain","type":"string"},{"internalType":"string","name":"sourceAddress","type":"string"},{"internalType":"bytes","name":"payload","type":"bytes"},{"internalType":"string","name":"tokenSymbol","type":"string"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"executeWithToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeCollector","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"internalType":"struct ISpoke.Order","name":"order","type":"tuple"},{"components":[{"internalType":"enum ISquidMulticall.CallType","name":"callType","type":"uint8"},{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes","name":"payload","type":"bytes"}],"internalType":"struct ISquidMulticall.Call[]","name":"calls","type":"tuple[]"}],"name":"fillOrder","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"internalType":"struct ISpoke.Order","name":"order","type":"tuple"},{"components":[{"internalType":"enum ISquidMulticall.CallType","name":"callType","type":"uint8"},{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes","name":"payload","type":"bytes"}],"internalType":"struct ISquidMulticall.Call[]","name":"calls","type":"tuple[]"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"fillSingleChainAtomic","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"orderHashes","type":"bytes32[]"}],"name":"forwardSettlements","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"gasService","outputs":[{"internalType":"contract IAxelarGasService","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gateway","outputs":[{"internalType":"contract IAxelarGateway","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hubAddress","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hubChainName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IAxelarGateway","name":"_axelarGateway","type":"address"},{"internalType":"contract IAxelarGasService","name":"_axelarGasService","type":"address"},{"internalType":"contract IPermit2","name":"_permit2","type":"address"},{"internalType":"contract ISquidMulticall","name":"_squidMulticall","type":"address"},{"internalType":"address","name":"_feeCollector","type":"address"},{"internalType":"string","name":"_hubChainName","type":"string"},{"internalType":"string","name":"_hubAddress","type":"string"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"chain","type":"string"},{"internalType":"string","name":"address_","type":"string"}],"name":"isTrustedAddress","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"orderHashToStatus","outputs":[{"internalType":"enum ISpoke.OrderStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"permit2","outputs":[{"internalType":"contract IPermit2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"internalType":"struct ISpoke.Order","name":"order","type":"tuple"}],"name":"refundOrder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"settlementToStatus","outputs":[{"internalType":"enum ISpoke.SettlementStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"internalType":"struct ISpoke.Order","name":"order","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"sponsorOrder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"fromAddress","type":"address"},{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"address","name":"filler","type":"address"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"fillAmount","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"fromChain","type":"uint256"},{"internalType":"uint256","name":"toChain","type":"uint256"},{"internalType":"bytes32","name":"postHookHash","type":"bytes32"}],"internalType":"struct ISpoke.Order","name":"order","type":"tuple"},{"components":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct ISignatureTransfer.TokenPermissions","name":"permitted","type":"tuple"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct ISignatureTransfer.PermitTransferFrom","name":"permit","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"sponsorOrderUsingPermit2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"squidMulticall","outputs":[{"internalType":"contract ISquidMulticall","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokenToCollectedFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"chain","type":"string"}],"name":"trustedAddress","outputs":[{"internalType":"string","name":"trustedAddress_","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"chain","type":"string"}],"name":"trustedAddressHash","outputs":[{"internalType":"bytes32","name":"trustedAddressHash_","type":"bytes32"}],"stateMutability":"view","type":"function"}]
