import { Address as Address$1, ExtractAbiFunctionNames } from 'abitype';
import { Address, Hex, Abi, PublicClient, Transaction, TransactionReceipt, PrivateKeyAccount, HDOptions, HDAccount, JsonRpcAccount, WalletClient, PublicActions, EstimateContractGasParameters, WriteContractParameters, SimulateContractParameters, Transport, Chain } from 'viem';
import { Account } from 'viem/accounts';
import { Environment } from '@holographxyz/environment';
import { Network, NetworkKey } from '@holographxyz/networks';
import * as z from 'zod';

declare const _default$2: [{
    inputs: [];
    stateMutability: "nonpayable";
    type: "constructor";
}, {
    stateMutability: "payable";
    type: "fallback";
}, {
    inputs: [];
    name: "admin";
    outputs: [{
        internalType: "address";
        name: "";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "target";
        type: "address";
    }, {
        internalType: "bytes";
        name: "data";
        type: "bytes";
    }];
    name: "adminCall";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }, {
        internalType: "uint32";
        name: "fromChain";
        type: "uint32";
    }, {
        internalType: "address";
        name: "holographableContract";
        type: "address";
    }, {
        internalType: "address";
        name: "hToken";
        type: "address";
    }, {
        internalType: "address";
        name: "hTokenRecipient";
        type: "address";
    }, {
        internalType: "uint256";
        name: "hTokenValue";
        type: "uint256";
    }, {
        internalType: "bool";
        name: "doNotRevert";
        type: "bool";
    }, {
        internalType: "bytes";
        name: "bridgeInPayload";
        type: "bytes";
    }];
    name: "bridgeInRequest";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [{
        internalType: "uint32";
        name: "toChain";
        type: "uint32";
    }, {
        internalType: "address";
        name: "holographableContract";
        type: "address";
    }, {
        internalType: "uint256";
        name: "gasLimit";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "gasPrice";
        type: "uint256";
    }, {
        internalType: "bytes";
        name: "bridgeOutPayload";
        type: "bytes";
    }];
    name: "bridgeOutRequest";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [];
    name: "getAdmin";
    outputs: [{
        internalType: "address";
        name: "adminAddress";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "uint32";
        name: "toChain";
        type: "uint32";
    }, {
        internalType: "address";
        name: "holographableContract";
        type: "address";
    }, {
        internalType: "uint256";
        name: "gasLimit";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "gasPrice";
        type: "uint256";
    }, {
        internalType: "bytes";
        name: "bridgeOutPayload";
        type: "bytes";
    }];
    name: "getBridgeOutRequestPayload";
    outputs: [{
        internalType: "bytes";
        name: "samplePayload";
        type: "bytes";
    }];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [];
    name: "getFactory";
    outputs: [{
        internalType: "address";
        name: "factory";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getHolograph";
    outputs: [{
        internalType: "address";
        name: "holograph";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getJobNonce";
    outputs: [{
        internalType: "uint256";
        name: "jobNonce";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "uint32";
        name: "";
        type: "uint32";
    }, {
        internalType: "uint256";
        name: "";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "";
        type: "uint256";
    }, {
        internalType: "bytes";
        name: "";
        type: "bytes";
    }];
    name: "getMessageFee";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getOperator";
    outputs: [{
        internalType: "address";
        name: "operator";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getRegistry";
    outputs: [{
        internalType: "address";
        name: "registry";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "bytes";
        name: "initPayload";
        type: "bytes";
    }];
    name: "init";
    outputs: [{
        internalType: "bytes4";
        name: "";
        type: "bytes4";
    }];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "sender";
        type: "address";
    }, {
        internalType: "uint32";
        name: "toChain";
        type: "uint32";
    }, {
        internalType: "address";
        name: "holographableContract";
        type: "address";
    }, {
        internalType: "bytes";
        name: "bridgeOutPayload";
        type: "bytes";
    }];
    name: "revertedBridgeOutRequest";
    outputs: [{
        internalType: "string";
        name: "revertReason";
        type: "string";
    }];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "adminAddress";
        type: "address";
    }];
    name: "setAdmin";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "factory";
        type: "address";
    }];
    name: "setFactory";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "holograph";
        type: "address";
    }];
    name: "setHolograph";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "operator";
        type: "address";
    }];
    name: "setOperator";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "registry";
        type: "address";
    }];
    name: "setRegistry";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    stateMutability: "payable";
    type: "receive";
}];

declare const _default$1: [{
    inputs: [];
    stateMutability: "nonpayable";
    type: "constructor";
}, {
    anonymous: false;
    inputs: [{
        indexed: true;
        internalType: "address";
        name: "contractAddress";
        type: "address";
    }, {
        indexed: true;
        internalType: "bytes32";
        name: "hash";
        type: "bytes32";
    }];
    name: "BridgeableContractDeployed";
    type: "event";
}, {
    stateMutability: "payable";
    type: "fallback";
}, {
    inputs: [];
    name: "admin";
    outputs: [{
        internalType: "address";
        name: "";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "target";
        type: "address";
    }, {
        internalType: "bytes";
        name: "data";
        type: "bytes";
    }];
    name: "adminCall";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [{
        internalType: "uint32";
        name: "";
        type: "uint32";
    }, {
        internalType: "bytes";
        name: "payload";
        type: "bytes";
    }];
    name: "bridgeIn";
    outputs: [{
        internalType: "bytes4";
        name: "";
        type: "bytes4";
    }];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "uint32";
        name: "";
        type: "uint32";
    }, {
        internalType: "address";
        name: "";
        type: "address";
    }, {
        internalType: "bytes";
        name: "payload";
        type: "bytes";
    }];
    name: "bridgeOut";
    outputs: [{
        internalType: "bytes4";
        name: "selector";
        type: "bytes4";
    }, {
        internalType: "bytes";
        name: "data";
        type: "bytes";
    }];
    stateMutability: "pure";
    type: "function";
}, {
    inputs: [{
        components: [{
            internalType: "bytes32";
            name: "contractType";
            type: "bytes32";
        }, {
            internalType: "uint32";
            name: "chainType";
            type: "uint32";
        }, {
            internalType: "bytes32";
            name: "salt";
            type: "bytes32";
        }, {
            internalType: "bytes";
            name: "byteCode";
            type: "bytes";
        }, {
            internalType: "bytes";
            name: "initCode";
            type: "bytes";
        }];
        internalType: "struct DeploymentConfig";
        name: "config";
        type: "tuple";
    }, {
        components: [{
            internalType: "bytes32";
            name: "r";
            type: "bytes32";
        }, {
            internalType: "bytes32";
            name: "s";
            type: "bytes32";
        }, {
            internalType: "uint8";
            name: "v";
            type: "uint8";
        }];
        internalType: "struct Verification";
        name: "signature";
        type: "tuple";
    }, {
        internalType: "address";
        name: "signer";
        type: "address";
    }];
    name: "deployHolographableContract";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        components: [{
            internalType: "bytes32";
            name: "contractType";
            type: "bytes32";
        }, {
            internalType: "uint32";
            name: "chainType";
            type: "uint32";
        }, {
            internalType: "bytes32";
            name: "salt";
            type: "bytes32";
        }, {
            internalType: "bytes";
            name: "byteCode";
            type: "bytes";
        }, {
            internalType: "bytes";
            name: "initCode";
            type: "bytes";
        }];
        internalType: "struct DeploymentConfig";
        name: "config";
        type: "tuple";
    }, {
        components: [{
            internalType: "bytes32";
            name: "r";
            type: "bytes32";
        }, {
            internalType: "bytes32";
            name: "s";
            type: "bytes32";
        }, {
            internalType: "uint8";
            name: "v";
            type: "uint8";
        }];
        internalType: "struct Verification";
        name: "signature";
        type: "tuple";
    }, {
        internalType: "address";
        name: "signer";
        type: "address";
    }, {
        internalType: "bool";
        name: "deployOnCurrentChain";
        type: "bool";
    }, {
        components: [{
            internalType: "uint256";
            name: "value";
            type: "uint256";
        }, {
            internalType: "uint256";
            name: "gasLimit";
            type: "uint256";
        }, {
            internalType: "uint256";
            name: "gasPrice";
            type: "uint256";
        }, {
            internalType: "uint32";
            name: "toChain";
            type: "uint32";
        }];
        internalType: "struct BridgeSettings[]";
        name: "bridgeSettings";
        type: "tuple[]";
    }];
    name: "deployHolographableContractMultiChain";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [];
    name: "getAdmin";
    outputs: [{
        internalType: "address";
        name: "adminAddress";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getHolograph";
    outputs: [{
        internalType: "address";
        name: "holograph";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getRegistry";
    outputs: [{
        internalType: "address";
        name: "registry";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "bytes";
        name: "initPayload";
        type: "bytes";
    }];
    name: "init";
    outputs: [{
        internalType: "bytes4";
        name: "";
        type: "bytes4";
    }];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "adminAddress";
        type: "address";
    }];
    name: "setAdmin";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "holograph";
        type: "address";
    }];
    name: "setHolograph";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "registry";
        type: "address";
    }];
    name: "setRegistry";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    stateMutability: "payable";
    type: "receive";
}];

declare const _default: [{
    inputs: [];
    stateMutability: "nonpayable";
    type: "constructor";
}, {
    anonymous: false;
    inputs: [{
        indexed: false;
        internalType: "bytes32";
        name: "jobHash";
        type: "bytes32";
    }, {
        indexed: false;
        internalType: "bytes";
        name: "payload";
        type: "bytes";
    }];
    name: "AvailableOperatorJob";
    type: "event";
}, {
    anonymous: false;
    inputs: [{
        indexed: false;
        internalType: "bytes32";
        name: "messageHash";
        type: "bytes32";
    }];
    name: "CrossChainMessageSent";
    type: "event";
}, {
    anonymous: false;
    inputs: [{
        indexed: false;
        internalType: "bytes32";
        name: "jobHash";
        type: "bytes32";
    }];
    name: "FailedOperatorJob";
    type: "event";
}, {
    anonymous: false;
    inputs: [{
        indexed: false;
        internalType: "bytes32";
        name: "jobHash";
        type: "bytes32";
    }, {
        indexed: false;
        internalType: "address";
        name: "operator";
        type: "address";
    }];
    name: "FinishedOperatorJob";
    type: "event";
}, {
    stateMutability: "payable";
    type: "fallback";
}, {
    inputs: [];
    name: "admin";
    outputs: [{
        internalType: "address";
        name: "";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "target";
        type: "address";
    }, {
        internalType: "bytes";
        name: "data";
        type: "bytes";
    }];
    name: "adminCall";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [{
        internalType: "bytes32";
        name: "jobHash";
        type: "bytes32";
    }];
    stateMutability: "view";
    type: "function";
    name: "operatorJobExists";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
}, {
    inputs: [{
        internalType: "bytes32";
        name: "jobHash";
        type: "bytes32";
    }];
    stateMutability: "view";
    type: "function";
    name: "failedJobExists";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
}, {
    inputs: [{
        internalType: "address";
        name: "operator";
        type: "address";
    }, {
        internalType: "uint256";
        name: "amount";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "pod";
        type: "uint256";
    }];
    name: "bondUtilityToken";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "bytes";
        name: "bridgeInRequestPayload";
        type: "bytes";
    }];
    name: "crossChainMessage";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [{
        internalType: "bytes";
        name: "bridgeInRequestPayload";
        type: "bytes";
    }];
    name: "executeJob";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [];
    name: "getAdmin";
    outputs: [{
        internalType: "address";
        name: "adminAddress";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "operator";
        type: "address";
    }];
    name: "getBondedAmount";
    outputs: [{
        internalType: "uint256";
        name: "amount";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "operator";
        type: "address";
    }];
    name: "getBondedPod";
    outputs: [{
        internalType: "uint256";
        name: "pod";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "operator";
        type: "address";
    }];
    name: "getBondedPodIndex";
    outputs: [{
        internalType: "uint256";
        name: "index";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getBridge";
    outputs: [{
        internalType: "address";
        name: "bridge";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getHolograph";
    outputs: [{
        internalType: "address";
        name: "holograph";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getInterfaces";
    outputs: [{
        internalType: "address";
        name: "interfaces";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "bytes32";
        name: "jobHash";
        type: "bytes32";
    }];
    name: "getJobDetails";
    outputs: [{
        components: [{
            internalType: "uint8";
            name: "pod";
            type: "uint8";
        }, {
            internalType: "uint16";
            name: "blockTimes";
            type: "uint16";
        }, {
            internalType: "address";
            name: "operator";
            type: "address";
        }, {
            internalType: "uint40";
            name: "startBlock";
            type: "uint40";
        }, {
            internalType: "uint64";
            name: "startTimestamp";
            type: "uint64";
        }, {
            internalType: "uint16[5]";
            name: "fallbackOperators";
            type: "uint16[5]";
        }];
        internalType: "struct OperatorJob";
        name: "";
        type: "tuple";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "uint32";
        name: "";
        type: "uint32";
    }, {
        internalType: "uint256";
        name: "";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "";
        type: "uint256";
    }, {
        internalType: "bytes";
        name: "";
        type: "bytes";
    }];
    name: "getMessageFee";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getMessagingModule";
    outputs: [{
        internalType: "address";
        name: "messagingModule";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getMinGasPrice";
    outputs: [{
        internalType: "uint256";
        name: "minGasPrice";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "uint256";
        name: "pod";
        type: "uint256";
    }];
    name: "getPodBondAmounts";
    outputs: [{
        internalType: "uint256";
        name: "base";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "current";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "uint256";
        name: "pod";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "index";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "length";
        type: "uint256";
    }];
    name: "getPodOperators";
    outputs: [{
        internalType: "address[]";
        name: "operators";
        type: "address[]";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "uint256";
        name: "pod";
        type: "uint256";
    }];
    name: "getPodOperators";
    outputs: [{
        internalType: "address[]";
        name: "operators";
        type: "address[]";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "uint256";
        name: "pod";
        type: "uint256";
    }];
    name: "getPodOperatorsLength";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getRegistry";
    outputs: [{
        internalType: "address";
        name: "registry";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getTotalPods";
    outputs: [{
        internalType: "uint256";
        name: "totalPods";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [];
    name: "getUtilityToken";
    outputs: [{
        internalType: "address";
        name: "utilityToken";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
}, {
    inputs: [{
        internalType: "bytes";
        name: "initPayload";
        type: "bytes";
    }];
    name: "init";
    outputs: [{
        internalType: "bytes4";
        name: "";
        type: "bytes4";
    }];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "bytes";
        name: "bridgeInRequestPayload";
        type: "bytes";
    }];
    name: "jobEstimator";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "msgSender";
        type: "address";
    }, {
        internalType: "bytes";
        name: "payload";
        type: "bytes";
    }];
    name: "nonRevertingBridgeCall";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [{
        internalType: "bytes";
        name: "bridgeInRequestPayload";
        type: "bytes";
    }];
    name: "recoverJob";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [{
        internalType: "uint256";
        name: "gasLimit";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "gasPrice";
        type: "uint256";
    }, {
        internalType: "uint32";
        name: "toChain";
        type: "uint32";
    }, {
        internalType: "address";
        name: "msgSender";
        type: "address";
    }, {
        internalType: "uint256";
        name: "nonce";
        type: "uint256";
    }, {
        internalType: "address";
        name: "holographableContract";
        type: "address";
    }, {
        internalType: "bytes";
        name: "bridgeOutPayload";
        type: "bytes";
    }];
    name: "send";
    outputs: [];
    stateMutability: "payable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "adminAddress";
        type: "address";
    }];
    name: "setAdmin";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "bridge";
        type: "address";
    }];
    name: "setBridge";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "holograph";
        type: "address";
    }];
    name: "setHolograph";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "interfaces";
        type: "address";
    }];
    name: "setInterfaces";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "messagingModule";
        type: "address";
    }];
    name: "setMessagingModule";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "uint256";
        name: "minGasPrice";
        type: "uint256";
    }];
    name: "setMinGasPrice";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "registry";
        type: "address";
    }];
    name: "setRegistry";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "utilityToken";
        type: "address";
    }];
    name: "setUtilityToken";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "operator";
        type: "address";
    }, {
        internalType: "uint256";
        name: "amount";
        type: "uint256";
    }];
    name: "topupUtilityToken";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    inputs: [{
        internalType: "address";
        name: "operator";
        type: "address";
    }, {
        internalType: "address";
        name: "recipient";
        type: "address";
    }];
    name: "unbondUtilityToken";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
}, {
    stateMutability: "payable";
    type: "receive";
}];

declare const openEditionSalesConfigSchema: z.ZodObject<{
    publicSalePrice: z.ZodNumber;
    maxSalePurchasePerAddress: z.ZodNumber;
    publicSaleStart: z.ZodString;
    publicSaleEnd: z.ZodString;
    presaleStart: z.ZodOptional<z.ZodString>;
    presaleEnd: z.ZodOptional<z.ZodString>;
    presaleMerkleRoot: z.ZodDefault<z.ZodOptional<z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    publicSalePrice: number;
    publicSaleStart: string;
    publicSaleEnd: string;
    presaleMerkleRoot: string;
    maxSalePurchasePerAddress: number;
    presaleStart?: string | undefined;
    presaleEnd?: string | undefined;
}, {
    publicSalePrice: number;
    publicSaleStart: string;
    publicSaleEnd: string;
    maxSalePurchasePerAddress: number;
    presaleStart?: string | undefined;
    presaleEnd?: string | undefined;
    presaleMerkleRoot?: string | undefined;
}>;
declare const contractInfoSchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    symbol: z.ZodEffects<z.ZodString, string, string>;
    royaltiesPercentage: z.ZodDefault<z.ZodNumber>;
    salt: z.ZodEffects<z.ZodDefault<z.ZodString>, `0x${string}`, string | undefined>;
}, "strip", z.ZodTypeAny, {
    symbol: string;
    name: string;
    salt: `0x${string}`;
    royaltiesPercentage: number;
    description?: string | undefined;
}, {
    symbol: string;
    name: string;
    description?: string | undefined;
    royaltiesPercentage?: number | undefined;
    salt?: string | undefined;
}>;
declare const nftInfoSchema: z.ZodObject<{
    ipfsUrl: z.ZodString;
    ipfsImageCid: z.ZodString;
}, "strip", z.ZodTypeAny, {
    ipfsUrl: string;
    ipfsImageCid: string;
}, {
    ipfsUrl: string;
    ipfsImageCid: string;
}>;
declare const holographOpenEditionERC721InitCodeV2ParamsSchema: z.ZodObject<{
    contractType: z.ZodString;
    registryAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    initialOwner: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    fundsRecipient: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    numOfEditions: z.ZodNumber;
    royaltiesPercentage: z.ZodDefault<z.ZodNumber>;
    salesConfigArray: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBigInt]>, "many">;
    metadataRendererAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    metadataRendererInitCode: z.ZodString;
}, "strip", z.ZodTypeAny, {
    fundsRecipient: `0x${string}`;
    contractType: string;
    royaltiesPercentage: number;
    registryAddress: `0x${string}`;
    initialOwner: `0x${string}`;
    numOfEditions: number;
    salesConfigArray: (string | number | bigint)[];
    metadataRendererAddress: `0x${string}`;
    metadataRendererInitCode: string;
}, {
    fundsRecipient: string;
    contractType: string;
    registryAddress: string;
    initialOwner: string;
    numOfEditions: number;
    salesConfigArray: (string | number | bigint)[];
    metadataRendererAddress: string;
    metadataRendererInitCode: string;
    royaltiesPercentage?: number | undefined;
}>;
declare const holographOpenEditionERC721InitCodeV1ParamsSchema: z.ZodObject<{
    fundsRecipient: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    contractType: z.ZodString;
    royaltiesPercentage: z.ZodDefault<z.ZodNumber>;
    registryAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    initialOwner: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    numOfEditions: z.ZodNumber;
    salesConfigArray: z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBigInt]>, "many">;
    metadataRendererAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    metadataRendererInitCode: z.ZodString;
    erc721TransferHelper: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    marketFilterAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    enableOpenSeaRoyaltyRegistry: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    fundsRecipient: `0x${string}`;
    erc721TransferHelper: `0x${string}`;
    marketFilterAddress: `0x${string}`;
    contractType: string;
    royaltiesPercentage: number;
    registryAddress: `0x${string}`;
    initialOwner: `0x${string}`;
    numOfEditions: number;
    salesConfigArray: (string | number | bigint)[];
    metadataRendererAddress: `0x${string}`;
    metadataRendererInitCode: string;
    enableOpenSeaRoyaltyRegistry: boolean;
}, {
    fundsRecipient: string;
    erc721TransferHelper: string;
    marketFilterAddress: string;
    contractType: string;
    registryAddress: string;
    initialOwner: string;
    numOfEditions: number;
    salesConfigArray: (string | number | bigint)[];
    metadataRendererAddress: string;
    metadataRendererInitCode: string;
    royaltiesPercentage?: number | undefined;
    enableOpenSeaRoyaltyRegistry?: boolean | undefined;
}>;
declare const holographERC721InitCodeParamsSchema: z.ZodObject<{
    contractName: z.ZodString;
    contractSymbol: z.ZodEffects<z.ZodString, string, string>;
    royaltiesPercentage: z.ZodDefault<z.ZodNumber>;
    eventConfig: z.ZodString;
    skipInit: z.ZodDefault<z.ZodBoolean>;
    holographOpenEditionERC721InitCode: z.ZodString;
}, "strip", z.ZodTypeAny, {
    contractName: string;
    contractSymbol: string;
    royaltiesPercentage: number;
    eventConfig: string;
    skipInit: boolean;
    holographOpenEditionERC721InitCode: string;
}, {
    contractName: string;
    contractSymbol: string;
    eventConfig: string;
    holographOpenEditionERC721InitCode: string;
    royaltiesPercentage?: number | undefined;
    skipInit?: boolean | undefined;
}>;
declare const openEditionContractInfo: z.ZodObject<{
    symbol: z.ZodEffects<z.ZodString, string, string>;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    salt: z.ZodEffects<z.ZodDefault<z.ZodString>, `0x${string}`, string | undefined>;
    royaltiesPercentage: z.ZodDefault<z.ZodNumber>;
    ipfsUrl: z.ZodString;
    ipfsImageCid: z.ZodString;
    publicSalePrice: z.ZodNumber;
    maxSalePurchasePerAddress: z.ZodNumber;
    publicSaleStart: z.ZodString;
    publicSaleEnd: z.ZodString;
    presaleStart: z.ZodOptional<z.ZodString>;
    presaleEnd: z.ZodOptional<z.ZodString>;
    presaleMerkleRoot: z.ZodDefault<z.ZodOptional<z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    symbol: string;
    name: string;
    publicSalePrice: number;
    publicSaleStart: string;
    publicSaleEnd: string;
    presaleMerkleRoot: string;
    maxSalePurchasePerAddress: number;
    salt: `0x${string}`;
    royaltiesPercentage: number;
    ipfsUrl: string;
    ipfsImageCid: string;
    description?: string | undefined;
    presaleStart?: string | undefined;
    presaleEnd?: string | undefined;
}, {
    symbol: string;
    name: string;
    publicSalePrice: number;
    publicSaleStart: string;
    publicSaleEnd: string;
    maxSalePurchasePerAddress: number;
    ipfsUrl: string;
    ipfsImageCid: string;
    description?: string | undefined;
    salt?: string | undefined;
    royaltiesPercentage?: number | undefined;
    presaleStart?: string | undefined;
    presaleEnd?: string | undefined;
    presaleMerkleRoot?: string | undefined;
}>;
type CreateHolographERC721Contract = {
    contractInfo: {
        name: string;
        symbol: string;
        royaltiesPercentage?: number;
        salt?: string;
    };
    primaryChainId: number;
};
type HydrateHolographERC721Contract = {
    contractInfo: {
        name: string;
        symbol: string;
        royaltiesPercentage?: number;
        salt?: string;
    };
    chainId: number;
    address: Address;
    txHash?: Hex;
};
type ContractInfo = z.infer<typeof contractInfoSchema>;
type OpenEditionContractInfo = z.input<typeof openEditionContractInfo>;
type NFTInfo = z.infer<typeof nftInfoSchema>;
type OpenEditionSalesConfig = z.input<typeof openEditionSalesConfigSchema>;
type CreateHolographOpenEditionERC721Contract = {
    contractInfo: {
        name: string;
        symbol: string;
        description?: string;
        royaltiesPercentage?: number;
        salt?: string;
    };
    nftInfo: {
        ipfsUrl: string;
        ipfsImageCid: string;
    };
    primaryChainId: number;
    salesConfig: OpenEditionSalesConfig;
};
type HydrateHolographOpenEditionERC721Contract = {
    contractInfo: {
        name: string;
        symbol: string;
        description?: string;
        royaltiesPercentage?: number;
        salt?: string;
    };
    nftInfo: {
        ipfsUrl: string;
        ipfsImageCid: string;
    };
    salesConfig: OpenEditionSalesConfig;
    chainId: number;
    address: Address;
    txHash?: Hex;
};
type HolographERC721InitCodeParams = z.infer<typeof holographERC721InitCodeParamsSchema>;
type HolographOpenEditionERC721InitCodeV1Params = z.infer<typeof holographOpenEditionERC721InitCodeV1ParamsSchema>;
type HolographOpenEditionERC721InitCodeV2Params = z.infer<typeof holographOpenEditionERC721InitCodeV2ParamsSchema>;

declare class HolographERC721Contract {
    private _isHydrated;
    private _contractInfo;
    primaryChainId: number;
    account?: Address;
    chainIds?: number[];
    contractAddress?: Address;
    erc721ConfigHash?: Hex;
    predictedContractAddress?: Address;
    signature?: Signature;
    txHash?: string;
    private readonly factory;
    private readonly registry;
    constructor({ contractInfo, primaryChainId }: CreateHolographERC721Contract);
    static hydrate({ contractInfo, chainId, address, txHash }: HydrateHolographERC721Contract): HolographERC721Contract;
    get name(): string;
    get symbol(): string;
    get royaltiesPercentage(): number;
    get salt(): `0x${string}`;
    getContractInfo(): ContractInfo;
    get isHydrated(): boolean;
    setName(name: string): void;
    setSymbol(symbol: string): void;
    setRoyaltiesPercentage(royalties: number): void;
    setSalt(salt: Hex): void;
    createERC721DeploymentConfig(account: Address, chainId?: number): Promise<DeploymentConfig>;
    /**
     * @param holographWallet - The HolographWallet instance to sign the deploy.
     * @param chainId - The chainId to sign the deploy. It's optional and defaults to the primaryChainId.
     * @returns - The signature data with the config and signature to deploy the contract.
     */
    signDeploy(holographWallet: HolographWallet, chainId?: number): Promise<SignDeploy>;
    /**
     * @param signatureData - The signature data returned from signDeploy function.
     * @returns - A transaction hash.
     */
    deploy(signatureData: SignDeploy, options?: WriteContractOptions): Promise<{
        contractAddress: Address;
        txHash: Hex;
    }>;
    private _getFactoryAddress;
    private _getRegistryAddress;
    private _getPredictedContractAddress;
    private _generateInitCode;
    private _getContractPayload;
    private _estimateGasForDeployingContract;
}

declare class HolographOpenEditionERC721ContractV1 {
    protected _isHydrated: boolean;
    protected _contractInfo: ContractInfo;
    nftInfo: NFTInfo;
    salesConfig: OpenEditionSalesConfig;
    primaryChainId: number;
    account?: Address;
    chainIds?: number[];
    contractAddress?: Address;
    erc721ConfigHash?: Hex;
    signature?: Signature;
    txHash?: string;
    private factory;
    private registry;
    constructor({ contractInfo, nftInfo, primaryChainId, salesConfig }: CreateHolographOpenEditionERC721Contract);
    static hydrate({ contractInfo, nftInfo, salesConfig, chainId, address, txHash, }: HydrateHolographOpenEditionERC721Contract): HolographOpenEditionERC721ContractV1;
    get name(): string;
    get description(): string | undefined;
    get symbol(): string;
    get royaltiesPercentage(): number;
    get salt(): `0x${string}`;
    get publicSalePrice(): number;
    get maxSalePurchasePerAddress(): number;
    get publicSaleStart(): string;
    get publicSaleEnd(): string;
    get presaleStart(): string | undefined;
    get presaleEnd(): string | undefined;
    get presaleMerkleRoot(): string | undefined;
    get nftIpfsUrl(): string;
    get nftIpfsImageCid(): string;
    get isHydrated(): boolean;
    getContractInfo(): OpenEditionContractInfo;
    setName(name: string): void;
    setDescription(description: string): void;
    setSymbol(symbol: string): void;
    setRoyaltiesPercentage(royalties: number): void;
    setSalt(salt: Hex): void;
    setPublicSalePrice(publicSalePrice: number): void;
    setMaxSalePurchasePerAddress(maxSalePurchasePerAddress: number): void;
    setPublicSaleStart(publicSaleStart: string): void;
    setPublicSaleEnd(publicSaleEnd: string): void;
    setPresaleStart(presaleStart: string): void;
    setPresaleEnd(presaleEnd: string): void;
    setPresaleMerkleRoot(presaleMerkleRoot: string): void;
    setIpfsUrl(nftIpfsUrl: string): void;
    setIpfsImageCid(nftIpfsImageCid: string): void;
    /**
     * @param holographWallet - The HolographWallet instance to sign the deploy.
     * @param chainId - The chainId to sign the deploy. It's optional and defaults to the primaryChainId.
     * @returns - The signature data with the config and signature to deploy the contract contract.
     */
    signDeploy(holographWallet: HolographWallet, chainId?: number): Promise<SignDeploy>;
    /**
     * @param signatureData - The signature data returned from signDeploy function.
     * @returns - A transaction hash.
     */
    deploy(signatureData: SignDeploy, options?: WriteContractOptions): Promise<{
        contractAddress: Address;
        txHash: Hex;
    }>;
    protected _getRegistryAddress(chainId?: number): Promise<`0x${string}`>;
    protected _getMetadataRendererAddress(chainId?: number): `0x${string}`;
    protected _getOpenEditionContractType(): `0x${string}`;
    protected _getEventConfig(): `0x${string}`;
    protected _generateMetadataRendererInitCode(description: string, imageURI: string, animationURI?: string): `0x${string}`;
    protected _generateHolographOpenEditionERC721InitCode(data: HolographOpenEditionERC721InitCodeV1Params): `0x${string}`;
    protected _generateHolographERC721InitCode(data: HolographERC721InitCodeParams): `0x${string}`;
    protected _getInitialPayload(chainId?: number): Promise<{
        openEditionContractType: `0x${string}`;
        metadataRendererAddress: `0x${string}`;
        metadataRendererInitCode: `0x${string}`;
        registryAddress: `0x${string}`;
        salesConfigArray: (string | number | bigint)[];
    }>;
    protected _getOpenEditionInitCode({ account, metadataRendererAddress, metadataRendererInitCode, registryAddress, salesConfigArray, }: GetOpenEditionInitCodeParams): Hex;
    protected _getContractPayload(account: Address, chainId?: number): Promise<{
        byteCode: `0x${string}`;
        chainType: string;
        configHash: `0x${string}`;
        configHashBytes: Uint8Array;
        contractType: `0x${string}`;
        initCode: `0x${string}`;
        salt: `0x${string}`;
    }>;
    protected _estimateGasForDeployingContract(data: SignDeploy, chainId?: number): Promise<GasFee>;
}
declare class HolographOpenEditionERC721ContractV2 extends HolographOpenEditionERC721ContractV1 {
    constructor({ contractInfo, nftInfo, primaryChainId, salesConfig }: CreateHolographOpenEditionERC721Contract);
    static hydrate({ contractInfo, nftInfo, salesConfig, chainId, address, txHash, }: HydrateHolographOpenEditionERC721Contract): HolographOpenEditionERC721ContractV2;
    protected _getMetadataRendererAddress(chainId?: number): `0x${string}`;
    protected _getOpenEditionContractType(): `0x${string}`;
    protected _getEventConfig(): `0x${string}`;
    protected _generateHolographOpenEditionERC721InitCode(data: HolographOpenEditionERC721InitCodeV2Params): `0x${string}`;
    protected _getOpenEditionInitCode({ account, metadataRendererAddress, metadataRendererInitCode, registryAddress, salesConfigArray, }: GetOpenEditionInitCodeParams): Hex;
}

declare class Config {
    private holographConfig;
    private static _instance?;
    private readonly _logger;
    private readonly _environment;
    private readonly _networks;
    private readonly _networksRpc;
    private readonly _accounts?;
    private readonly _provider?;
    private constructor();
    static getInstance(holographConfig?: HolographConfig): Config;
    private setNetworks;
    get accounts(): AccountsConfig | undefined;
    get environment(): Environment;
    get networks(): Network[];
    get networksRpc(): NetworkRpc;
    get provider(): unknown;
}

type HolographByNetworksResponse = {
    [chainId: number]: any;
};

/**
 * @group Contracts
 * HolographBaseContract
 *
 * @remarks
 *
 * Base contract class for
 *
 */
declare class HolographBaseContract {
    protected _logger: HolographLogger;
    protected readonly _abi: Abi;
    private readonly _contractName;
    protected readonly _config: Config;
    /** The list of networks in which the contract was instantiated. */
    readonly networks: Network[];
    /** The record of addresses per chainId. */
    protected readonly _addresses: Record<number, Address>;
    protected readonly _providers: Providers;
    protected _walletManager?: HolographWalletManager;
    constructor(_logger: HolographLogger, _abi: Abi, _contractName: string);
    protected validateWallet: (wallet?: HolographWallet | {
        account: HolographWallet | string;
    }) => HolographWallet;
    protected _simulateContract<TAbi extends Abi>({ chainId, address, functionName, args, options, transportType, }: SimulateContractArgs<TAbi>): Promise<any>;
    protected _estimateContractGas<TAbi extends Abi>({ chainId, address, functionName, wallet, args, options, }: EstimateContractGasArgs<TAbi>): Promise<bigint>;
    protected _writeContract<TAbi extends Abi>({ chainId, address, functionName, wallet, args, options, }: WriteContractArgs<TAbi>): Promise<`0x${string}`>;
    protected _readContract<TAbi extends Abi>({ chainId, address, functionName, args }: ReadContractArgs<TAbi>): Promise<unknown>;
    protected _callContractFunction<TAbi extends Abi>({ chainId, address, functionName, wallet, args, options, }: CallContractFunctionArgs<TAbi>): Promise<any>;
    /**
     * @readonly
     * Get the Viem client for a certain network.
     * @param chainId The chain id of the network to get the result from.
     * @returns The Viem client object.
     */
    getClientByChainId(chainId: number): Promise<ViemPublicClient>;
    /**
     * @readonly
     * Get the current gas price for a certain network.
     * @param chainId The chain id of the network to get the result from.
     * @returns The gas price in wei.
     */
    getGasPrice: (chainId: number) => Promise<bigint>;
}

/**
 * @group Contracts
 * HolographBridge
 *
 * @remarks
 *
 * Bridge any holographable contracts and assets across blockchains.
 * The contract abstracts all the complexities of making bridge requests and uses a universal interface to bridge any type of holographable assets.
 *
 */
declare class BridgeContract$1 extends HolographBaseContract {
    constructor(parentLogger?: HolographLogger);
    /**
     * @readonly
     * Gets the HolographBridge contract address according to environment and chainId module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographBridge contract address in the provided network.
     */
    getAddress(chainId: number): Promise<Address>;
    private _getContractFunction;
    estimateContractFunctionGas({ chainId, functionName, wallet, args, options, }: EstimateContractFunctionGasArgs<typeof _default$2>): Promise<bigint>;
    simulateContractFunction({ chainId, functionName, args, options, }: SimulateContractFunctionArgs<typeof _default$2>): Promise<any>;
    /**
     * @readonly
     * Gets the Holograph Protocol contract.
     * Used for storing a reference to all the primary modules and variables of the protocol.
     * @param chainId The chain id of the network to get the result from.
     * @returns The Holograph Protocol contract address in the provided network.
     */
    getHolograph(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Gets the Holograph Protocol contract.
     * Used for storing a reference to all the primary modules and variables of the protocol.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph Protocol contract address per network.
     */
    getHolographByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Gets the address of the Holograph Factory module.
     * Used for deploying holographable smart contracts.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographFactory contract address in the provided network.
     */
    getFactory(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Gets the address of the Holograph Factory module.
     * Used for deploying holographable smart contracts.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographFactory contract address per network.
     */
    getFactoryByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Gets the latest job nonce.
     * You can use the job nonce as a way to calculate total amount of bridge requests that have been made.
     * @param chainId The chain id of the network to get the result from.
     * @returns The job nonce in the provided network.
     */
    getJobNonce(chainId: number): Promise<bigint>;
    /**
     * @readonly
     * Gets the latest job nonce.
     * You can use the job nonce as a way to calculate total amount of bridge requests that have been made.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The job nonce per network.
     */
    getJobNonceByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Gets the address of the Holograph Operator module.
     * All cross-chain Holograph Bridge bridges are handled by the Holograph Operator module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographOperator contract address in the provided network.
     */
    getOperator(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Gets the address of the Holograph Operator module.
     * All cross-chain Holograph Bridge bridges are handled by the Holograph Operator module.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographOperator contract address per network.
     */
    getOperatorByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Gets the Holograph Registry module.
     * This module stores a reference for all deployed holographable smart contracts.
     * @param chainId The chain id of the network to get the result from.
     * @returns The Holograph Registry contract address in the provided network.
     */
    getRegistry(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Gets the Holograph Registry module.
     * This module stores a reference for all deployed holographable smart contracts.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph Registry contract address per network.
     */
    getRegistryByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Gets the fees associated with sending specific payload.
     * It will provide exact costs on protocol and message side, combine the two to get total.
     * @param chainId The chain id of the network to send the transaction.
     * @param toChain The Holograph chain id of destination chain for payload.
     * @param gasLimit The amount of gas to provide for executing payload on destination chain.
     * @param gasPrice The maximum amount to pay for gas price, can be set to 0 and will be chose automatically.
     * @param crossChainPayload The entire packet being sent cross-chain.
     * @returns An array composed with [hlfFee, msgFee, dstGasPrice]:
     * hlgFee: The amount (in wei) of native gas token that will cost for finalizing job on destination chain.
     * msgFee: The amount (in wei) of native gas token that will cost for sending message to destination chain.
     * dstGasPrice: The amount (in wei) that destination message maximum gas price will be.
     */
    getMessageFee(chainId: number, toChain: number, gasLimit: bigint, gasPrice: bigint, crossChainPayload: Hex): Promise<[bigint, bigint, bigint]>;
    /**
     * Gets the payload created by the bridgeOutRequest function.
     * @param chainId The chain id of the network to send the transaction.
     * @param toChain The Holograph chain id where the bridge is being sent to.
     * @param holographableContract The address of the contract for which the bridge request is being made.
     * @param gasLimit The maximum amount of gas to spend for executing the bridge on destination chain.
     * @param gasPrice The maximum amount of gas price (in destination chain native gas token) to pay on destination chain.
     * @param bridgeOutPayload The actual abi encoded bytes of the data that the holographable contract bridgeOut function will receive.
     * @returns samplePayload The bytes made up of the bridgeOutRequest payload.
     */
    getBridgeOutRequestPayload(chainId: number, toChain: number, holographableContract: Address, gasLimit: bigint, gasPrice: bigint, bridgeOutPayload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Protocol module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param holograph The address of the Holograph Protocol smart contract to use.
     * @returns A transaction hash.
     */
    setHolograph(chainId: number, holograph: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Factory module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param factory The address of the Holograph Factory smart contract to use.
     * @returns A transaction hash.
     */
    setFactory(chainId: number, factory: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Operator module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param operator The address of the Holograph Operator smart contract to use.
     * @returns A transaction hash.
     */
    setOperator(chainId: number, operator: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Registry module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param registry The address of the Holograph Registry smart contract to use.
     * @returns A transaction hash.
     */
    setRegistry(chainId: number, registry: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Receives a bridge from another chain.
     * This function can only be called by the Holograph Operator module.
     * @param chainId The chain id of the network to send the transaction.
     * @param nonce The job nonce of the bridge request.
     * @param fromChain The Holograph chain id where the brigeOutRequest was created.
     * @param holographableContract The address of the destination contract that the bridgeInRequest is targeted for.
     * @param hToken The address of the hToken contract that wrapped the origin chain native gas token.
     * @param hTokenRecipient The address of recipient for the hToken reward.
     * @param hTokenValue The exact amount of hToken reward in wei.
     * @param doNotRevert The boolean used to specify if the call should revert.
     * @param bridgeInPayload The actual abi encoded bytes of the data that the holographable contract bridgeIn function will receive.
     * @returns A transaction hash.
     */
    bridgeInRequest(chainId: number, nonce: bigint, fromChain: number, holographableContract: Address, hToken: Address, hTokenRecipient: Address, hTokenValue: bigint, doNotRevert: boolean, bridgeInPayload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Creates a bridge request for a destination chain.
     * This function works for deploying contracts and bridging supported holographable assets across chains.
     * @param chainId The chain id of the network to send the transaction.
     * @param toChain The Holograph chain id where the bridge is being sent to.
     * @param holographableContract The address of the contract for which the bridge request is being made.
     * @param gasLimit The maximum amount of gas to spend for executing the bridge on destination chain.
     * @param gasPrice The maximum amount of gas price (in destination chain native gas token) to pay on destination chain.
     * @param bridgeOutPayload The actual abi encoded bytes of the data that the holographable contract bridgeOut function will receive.
     * @returns A transaction hash.
     */
    bridgeOutRequest(chainId: number, toChain: number, holographableContract: Address, gasLimit: bigint, gasPrice: bigint, bridgeOutPayload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * This function will always revert.
     * Used by getBridgeOutRequestPayload function. It is purposefully inverted to always revert on a successful call.
     * If this function does not revert and returns a string, it is the actual revert reason.
     * @param chainId The chain id of the network to send the transaction.
     * @param sender The address of actual sender that is planning to make a bridgeOutRequest call.
     * @param toChain The Holograph chain id of destination chain.
     * @param holographableContract The address of the contract for which the bridge request is being made.
     * @param bridgeOutPayload The actual abi encoded bytes of the data that the holographable contract bridgeOut function will receive.
     * @returns revertReason A revert reason string.
     */
    revertedBridgeOutRequest(chainId: number, sender: Address, toChain: number, holographableContract: Address, bridgeOutPayload: Hex, wallet?: {
        account: string | HolographWallet;
    }): Promise<any>;
}

declare const ABIs: ({
    inputs: [];
    stateMutability: "nonpayable";
    type: "constructor";
} | {
    anonymous: false;
    inputs: [{
        indexed: true;
        internalType: "address";
        name: "source";
        type: "address";
    }, {
        indexed: false;
        internalType: "uint256";
        name: "amount";
        type: "uint256";
    }];
    name: "FundsReceived";
    type: "event";
} | {
    stateMutability: "payable";
    type: "fallback";
} | {
    inputs: [{
        internalType: "address";
        name: "";
        type: "address";
    }, {
        internalType: "uint256";
        name: "_tokenId";
        type: "uint256";
    }];
    name: "afterBurn";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "uint32";
        name: "";
        type: "uint32";
    }, {
        internalType: "address";
        name: "";
        type: "address";
    }, {
        internalType: "address";
        name: "";
        type: "address";
    }, {
        internalType: "uint256";
        name: "_tokenId";
        type: "uint256";
    }, {
        internalType: "bytes";
        name: "_data";
        type: "bytes";
    }];
    name: "bridgeIn";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "uint32";
        name: "";
        type: "uint32";
    }, {
        internalType: "address";
        name: "";
        type: "address";
    }, {
        internalType: "address";
        name: "";
        type: "address";
    }, {
        internalType: "uint256";
        name: "_tokenId";
        type: "uint256";
    }];
    name: "bridgeOut";
    outputs: [{
        internalType: "bytes";
        name: "_data";
        type: "bytes";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "uint224";
        name: "tokenId";
        type: "uint224";
    }, {
        internalType: "enum TokenUriType";
        name: "uriType";
        type: "uint8";
    }, {
        internalType: "string";
        name: "tokenUri";
        type: "string";
    }];
    name: "cxipMint";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "bytes";
        name: "initPayload";
        type: "bytes";
    }];
    name: "init";
    outputs: [{
        internalType: "bytes4";
        name: "";
        type: "bytes4";
    }];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "wallet";
        type: "address";
    }];
    name: "isOwner";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "isOwner";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "owner";
    outputs: [{
        internalType: "address";
        name: "";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "bytes4";
        name: "";
        type: "bytes4";
    }];
    name: "supportsInterface";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
    stateMutability: "pure";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "_tokenId";
        type: "uint256";
    }];
    name: "tokenURI";
    outputs: [{
        internalType: "string";
        name: "";
        type: "string";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "withdraw";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    stateMutability: "payable";
    type: "receive";
} | {
    anonymous: false;
    inputs: [{
        indexed: true;
        internalType: "address";
        name: "_owner";
        type: "address";
    }, {
        indexed: true;
        internalType: "address";
        name: "_approved";
        type: "address";
    }, {
        indexed: true;
        internalType: "uint256";
        name: "_tokenId";
        type: "uint256";
    }];
    name: "Approval";
    type: "event";
} | {
    anonymous: false;
    inputs: [{
        indexed: true;
        internalType: "address";
        name: "_owner";
        type: "address";
    }, {
        indexed: true;
        internalType: "address";
        name: "_operator";
        type: "address";
    }, {
        indexed: false;
        internalType: "bool";
        name: "_approved";
        type: "bool";
    }];
    name: "ApprovalForAll";
    type: "event";
} | {
    anonymous: false;
    inputs: [{
        indexed: true;
        internalType: "address";
        name: "previousOwner";
        type: "address";
    }, {
        indexed: true;
        internalType: "address";
        name: "newOwner";
        type: "address";
    }];
    name: "OwnershipTransferred";
    type: "event";
} | {
    anonymous: false;
    inputs: [{
        indexed: true;
        internalType: "address";
        name: "_from";
        type: "address";
    }, {
        indexed: true;
        internalType: "address";
        name: "_to";
        type: "address";
    }, {
        indexed: true;
        internalType: "uint256";
        name: "_tokenId";
        type: "uint256";
    }];
    name: "Transfer";
    type: "event";
} | {
    inputs: [];
    name: "admin";
    outputs: [{
        internalType: "address";
        name: "";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "target";
        type: "address";
    }, {
        internalType: "bytes";
        name: "data";
        type: "bytes";
    }];
    name: "adminCall";
    outputs: [];
    stateMutability: "payable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "approve";
    outputs: [];
    stateMutability: "payable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "wallet";
        type: "address";
    }];
    name: "balanceOf";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "uint32";
        name: "fromChain";
        type: "uint32";
    }, {
        internalType: "bytes";
        name: "payload";
        type: "bytes";
    }];
    name: "bridgeIn";
    outputs: [{
        internalType: "bytes4";
        name: "";
        type: "bytes4";
    }];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "uint32";
        name: "toChain";
        type: "uint32";
    }, {
        internalType: "address";
        name: "sender";
        type: "address";
    }, {
        internalType: "bytes";
        name: "payload";
        type: "bytes";
    }];
    name: "bridgeOut";
    outputs: [{
        internalType: "bytes4";
        name: "selector";
        type: "bytes4";
    }, {
        internalType: "bytes";
        name: "data";
        type: "bytes";
    }];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "burn";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "burned";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "contractURI";
    outputs: [{
        internalType: "string";
        name: "";
        type: "string";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "decimals";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "pure";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "exists";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "getAdmin";
    outputs: [{
        internalType: "address";
        name: "adminAddress";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "getApproved";
    outputs: [{
        internalType: "address";
        name: "";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "getOwner";
    outputs: [{
        internalType: "address";
        name: "ownerAddress";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "wallet";
        type: "address";
    }, {
        internalType: "address";
        name: "operator";
        type: "address";
    }];
    name: "isApprovedForAll";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "name";
    outputs: [{
        internalType: "string";
        name: "";
        type: "string";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "_operator";
        type: "address";
    }, {
        internalType: "address";
        name: "_from";
        type: "address";
    }, {
        internalType: "uint256";
        name: "_tokenId";
        type: "uint256";
    }, {
        internalType: "bytes";
        name: "_data";
        type: "bytes";
    }];
    name: "onERC721Received";
    outputs: [{
        internalType: "bytes4";
        name: "";
        type: "bytes4";
    }];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "target";
        type: "address";
    }, {
        internalType: "bytes";
        name: "data";
        type: "bytes";
    }];
    name: "ownerCall";
    outputs: [];
    stateMutability: "payable";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "ownerOf";
    outputs: [{
        internalType: "address";
        name: "";
        type: "address";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "from";
        type: "address";
    }, {
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "safeTransferFrom";
    outputs: [];
    stateMutability: "payable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "from";
        type: "address";
    }, {
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }, {
        internalType: "bytes";
        name: "data";
        type: "bytes";
    }];
    name: "safeTransferFrom";
    outputs: [];
    stateMutability: "payable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "adminAddress";
        type: "address";
    }];
    name: "setAdmin";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "bool";
        name: "approved";
        type: "bool";
    }];
    name: "setApprovalForAll";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "ownerAddress";
        type: "address";
    }];
    name: "setOwner";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "sourceBurn";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [];
    name: "sourceGetChainPrepend";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint224";
        name: "tokenId";
        type: "uint224";
    }];
    name: "sourceMint";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "address[]";
        name: "wallets";
        type: "address[]";
    }, {
        internalType: "uint224[]";
        name: "tokenIds";
        type: "uint224[]";
    }];
    name: "sourceMintBatch";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint224[]";
        name: "tokenIds";
        type: "uint224[]";
    }];
    name: "sourceMintBatch";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint224";
        name: "startingTokenId";
        type: "uint224";
    }, {
        internalType: "uint256";
        name: "length";
        type: "uint256";
    }];
    name: "sourceMintBatchIncremental";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "sourceTransfer";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
} | {
    inputs: [{
        internalType: "bytes4";
        name: "interfaceId";
        type: "bytes4";
    }];
    name: "supportsInterface";
    outputs: [{
        internalType: "bool";
        name: "";
        type: "bool";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "symbol";
    outputs: [{
        internalType: "string";
        name: "";
        type: "string";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "index";
        type: "uint256";
    }];
    name: "tokenByIndex";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "wallet";
        type: "address";
    }, {
        internalType: "uint256";
        name: "index";
        type: "uint256";
    }];
    name: "tokenOfOwnerByIndex";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "tokenURI";
    outputs: [{
        internalType: "string";
        name: "";
        type: "string";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "uint256";
        name: "index";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "length";
        type: "uint256";
    }];
    name: "tokens";
    outputs: [{
        internalType: "uint256[]";
        name: "tokenIds";
        type: "uint256[]";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "wallet";
        type: "address";
    }];
    name: "tokensOfOwner";
    outputs: [{
        internalType: "uint256[]";
        name: "";
        type: "uint256[]";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "wallet";
        type: "address";
    }, {
        internalType: "uint256";
        name: "index";
        type: "uint256";
    }, {
        internalType: "uint256";
        name: "length";
        type: "uint256";
    }];
    name: "tokensOfOwner";
    outputs: [{
        internalType: "uint256[]";
        name: "tokenIds";
        type: "uint256[]";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [];
    name: "totalSupply";
    outputs: [{
        internalType: "uint256";
        name: "";
        type: "uint256";
    }];
    stateMutability: "view";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "transfer";
    outputs: [];
    stateMutability: "payable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "from";
        type: "address";
    }, {
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }];
    name: "transferFrom";
    outputs: [];
    stateMutability: "payable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "from";
        type: "address";
    }, {
        internalType: "address";
        name: "to";
        type: "address";
    }, {
        internalType: "uint256";
        name: "tokenId";
        type: "uint256";
    }, {
        internalType: "bytes";
        name: "data";
        type: "bytes";
    }];
    name: "transferFrom";
    outputs: [];
    stateMutability: "payable";
    type: "function";
} | {
    inputs: [{
        internalType: "address";
        name: "newOwner";
        type: "address";
    }];
    name: "transferOwnership";
    outputs: [];
    stateMutability: "nonpayable";
    type: "function";
})[];
/**
 * @group Contracts
 * CxipERC721
 *
 * @remarks
 *
 * CXIP ERC-721 Contract that is bridgeable via Holograph.
 * Used for minting and managing Holograph Bridgeable ERC721 NFTs.
 *
 */
declare class CxipERC721Contract extends HolographBaseContract {
    private contractAddress;
    constructor(contractAddress: Address$1, parentLogger?: HolographLogger);
    private _getContractFunction;
    estimateContractFunctionGas({ chainId, functionName, wallet, args, }: EstimateContractFunctionGasArgs<typeof ABIs>): Promise<bigint>;
    /**
     * @readonly
     * Check if the NFT exists through its token id.
     * @param chainId  The chain id of the network to get the result from.
     * @returns A boolean indicating if the NFT exists.
     */
    exists(chainId: number, tokenId: string): Promise<boolean>;
    /**
     * @readonly
     * Get the owner of the NFT.
     * @param chainId  The chain id of the network to get the result from.
     * @returns The owner address of the NFT.
     */
    ownerOf(chainId: number, tokenId: string): Promise<Address$1>;
    /**
     * @readonly
     * Get's the URI of the token.
     * @param chainId  The chain id of the network to get the result from.
     * @returns The URI.
     */
    tokenURI(chainId: number, tokenId: string): Promise<string>;
    /**
     * Mint a holographable NFT.
     * @param chainId  The chain id of the network to send the transaction.
     * @param tokenId The token id of the NFT.
     * @param uriType The type of the URI.
     * @param tokenUri The URI of the token.
     * @param wallet Holograph wallet instance, optional param.
     * @param options The override options for the transaction.
     * @returns A transaction hash.
     */
    cxipMint(chainId: number, tokenId: number | bigint, uriType: number, tokenUri: string, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
}

/**
 * @group Contracts
 * HolographFactory
 *
 * @remarks
 *
 * Deploy holographable contracts.
 * The contract provides methods that allow for the creation of Holograph Protocol compliant smart contracts, that are capable of minting holographable assets.
 *
 */
declare class FactoryContract extends HolographBaseContract {
    constructor(parentLogger?: HolographLogger);
    /**
     * @readonly
     * Get the HolographFactory contract address according to environment and chainId module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographFactory contract address in the provided network.
     */
    getAddress(chainId: number): Promise<Address$1>;
    private _getContractFunction;
    estimateContractFunctionGas({ chainId, functionName, wallet, args, options, }: EstimateContractFunctionGasArgs<typeof _default$1>): Promise<bigint>;
    /**
     * @readonly
     * Get the Holograph Protocol contract.
     * Used for storing a reference to all the primary modules and variables of the protocol.
     * @param chainId The chain id of the network to get the result from.
     * @returns The Holograph Protocol contract address in the provided network.
     */
    getHolograph(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the Holograph Protocol contract.
     * Used for storing a reference to all the primary modules and variables of the protocol.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph Protocol contract address per network.
     */
    getHolographByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the Holograph Registry module.
     * This module stores a reference for all deployed holographable smart contracts.
     * @param chainId The chain id of the network to get the result from.
     * @returns The Holograph Registry contract address in the provided network.
     */
    getRegistry(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the Holograph Registry module.
     * This module stores a reference for all deployed holographable smart contracts.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph Registry contract address per network.
     */
    getRegistryByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Updates the Holograph Protocol module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param holograph The address of the Holograph Protocol smart contract to use.
     * @returns A transaction hash.
     */
    setHolograph(chainId: number, holograph: Address$1, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Registry module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param registry The address of the Holograph Registry smart contract to use.
     * @returns A transaction hash.
     */
    setRegistry(chainId: number, registry: Address$1, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Deploy a holographable smart contract.
     * Using this function allows to deploy smart contracts that have the same address across all EVM chains.
     * @param chainId The chain id of the network to send the transaction.
     * @param config The contract deployment configurations.
     * @param signature The signature which was created by the wallet that created the original payload.
     * @param signer The address of wallet that created the payload.
     * @param wallet Holograph wallet instance, optional param.
     * @param options The override options for the transaction.
     * @returns A transaction hash.
     */
    deployHolographableContract(chainId: number, config: DeploymentConfig, signature: Signature, signer: Address$1, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Updates the Holograph Registry module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param config The contract deployment configurations.
     * @param signature The signature which was created by the wallet that created the original payload.
     * @param signer The address of wallet that created the payload.
     * @param deployOnCurrentChain Whether to deploy the contract on the current chain.
     * @param bridgeSettings The BridgeSettings[] struct for each chain to deploy the contract on.
     * @returns A transaction hash.
     */
    deployHolographableContractMultiChain(chainId: number, config: DeploymentConfig, signature: Signature, signer: Address$1, deployOnCurrentChain?: boolean, bridgeSettings?: BridgeSettings[], wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Deploy holographable contract via bridge request.
     * This function directly forwards the calldata to the deployHolographableContract function.
     * It is used to allow for Holograph Bridge to make cross-chain deployments.
     * @param chainId The chain id of the network to send the transaction.
     * @param fromChain The chain id of the network to get the result from.
     * @param payload The calldata to be used in the deployHolographableContract function.
     * @returns The function selector of the deployHolographableContract function.
     */
    bridgeIn(chainId: number, fromChain: number, payload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Deploy holographable contract via bridge request.
     * This function directly returns the calldata.
     * It is used to allow for Holograph Bridge to make cross-chain deployments.
     * @param chainId The chain id of the network to send the transaction.
     * @param toChain The destination chain id.
     * @param sender The address of person making the request.
     * @param payload The payload of the request.
     * @returns An array with the bridgeOut function selector and the provided payload
     */
    bridgeOut(chainId: number, toChain: number, sender: Address$1, payload: Hex): Promise<[string, string]>;
}

/**
 * @group Contracts
 * Holograph
 *
 * @remarks
 *
 * Holograph is the primary entry point for all users and developers. A single, universal address across all blockchains will enable developers an easy way to interact with the protocol’s features. Holograph keeps references for all current Registry, Factory, and Bridge implementations. Furthermore, it allows for single interface management of the underlying protocol.
 *
 * Holograph provides a reference to the name and ID of all supported blockchains. Additionally, it:
 *  - enables custom contract logic that is chain-dependent
 *  - frees developers from having to query and monitor the blockchain
 *
 */
declare class HolographContract extends HolographBaseContract {
    constructor(parentLogger?: HolographLogger);
    /**
     * @readonly
     * Get the Holograph contract address according to environment and chainId module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The Holograph contract address in the provided network.
     */
    getAddress(chainId?: number | string): Address$1;
    private _getContractFunction;
    /**
     * @readonly
     * Get the address of the Holograph Bridge module.
     * Used for bridging holographable assets cross-chain.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographBridge contract address in the provided network.
     */
    getBridge(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the address of the Holograph Bridge module.
     * Used for bridging holographable assets cross-chain.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographBridge contract address per network.
     */
    getBridgeByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the chain ID that the Protocol was deployed on.
     * Useful for checking if/when a hard fork occurs.
     * @param chainId The chain id of the network to get the result from.
     * @returns The chainId in the provided network.
     */
    getChainId(chainId: number): Promise<bigint>;
    /**
     * @readonly
     * Get the chain ID that the Protocol was deployed on.
     * Useful for checking if/when a hard fork occurs.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The chainIds per network.
     */
    getChainIdByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the address of the Holograph Factory module.
     * Used for deploying holographable smart contracts.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographFactory contract address in the provided network.
     */
    getFactory(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the address of the Holograph Factory module.
     * Used for deploying holographable smart contracts.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographFactory contract address per network.
     */
    getFactoryByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get The Holograph chain id.
     * Holograph uses an internal chain id mapping.
     * @param chainId The chain id of the network to get the result from.
     * @returns The Holograph chainID in the provided network.
     */
    getHolographChainId(chainId: number): Promise<number>;
    /**
     * @readonly
     * Get The Holograph chain id.
     * Holograph uses an internal chain id mapping.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph chainId per network.
     */
    getHolographChainIdByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the address of the Holograph Interfaces module.
     * Holograph uses this contract to store data that needs to be accessed by a large portion of the modules.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographInterfaces contract address in the provided network.
     */
    getInterfaces(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the address of the Holograph Interfaces module.
     * Holograph uses this contract to store data that needs to be accessed by a large portion of the modules.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographInterfaces contract address per network.
     */
    getInterfacesByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the address of the Holograph Operator module.
     * All cross-chain Holograph Bridge bridges are handled by the Holograph Operator module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographOperator contract address in the provided network.
     */
    getOperator(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the address of the Holograph Operator module.
     * All cross-chain Holograph Bridge bridges are handled by the Holograph Operator module.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographOperator contract address per network.
     */
    getOperatorByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the Holograph Registry module.
     * This module stores a reference for all deployed holographable smart contracts.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographRegistry contract address in the provided network.
     */
    getRegistry(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the Holograph Registry module.
     * This module stores a reference for all deployed holographable smart contracts.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographRegistry contract address per network.
     */
    getRegistryByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the Holograph Treasury module.
     * All of the Holograph Protocol assets are stored and managed by this module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographTreasury contract address in the provided network.
     */
    getTreasury(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the Holograph Treasury module.
     * All of the Holograph Protocol assets are stored and managed by this module.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographTreasury contract address per network.
     */
    getTreasuryByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the Holograph Utility Token address.
     * This is the official utility token of the Holograph Protocol.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HToken contract address in the provided network.
     */
    getUtilityToken(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the Holograph Utility Token address.
     * This is the official utility token of the Holograph Protocol.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HToken contract address per network.
     */
    getUtilityTokenByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
}

/**
 * @group Contracts
 * OpenEditionERC721
 *
 */
declare class OpenEditionERC721Contract extends HolographBaseContract {
    private contractAddress;
    private abis;
    constructor(contractAddress: Address$1, version?: HolographVersion, parentLogger?: HolographLogger);
    private _getContractFunction;
    estimateContractFunctionGas({ chainId, functionName, wallet, args, options, }: EstimateContractFunctionGasArgs<typeof this.abis>): Promise<bigint>;
    /**
     * @readonly
     * Convert contract's USD mint price into native token price.
     * @param chainId  The chain id of the network to get the result from.
     * @returns The native price of the NFT.
     */
    getNativePrice(chainId: number): Promise<bigint>;
    /**
     * @readonly
     * Get the holograph fee in wei.
     * @param chainId  The chain id of the network to get the result from.
     * @param quantity The quantity of NFTs to purchase.
     * @returns The holograph fee in wei.
     */
    getHolographFeeWei(chainId: number, quantity: number): Promise<bigint>;
    /**
     * @readonly
     * Check if the NFT exists through its token id.
     * @param chainId  The chain id of the network to get the result from.
     * @param tokenId ID of token.
     * @returns A boolean indicating if the NFT exists.
     */
    exists(chainId: number, tokenId: string): Promise<boolean>;
    /**
     * @readonly
     * Get the owner of the NFT.
     * @param chainId  The chain id of the network to get the result from.
     * @param tokenId ID of token.
     * @returns The owner address of the NFT.
     */
    ownerOf(chainId: number, tokenId: string): Promise<Address$1>;
    /**
     * @readonly
     * Token URI Getter
     * @param chainId  The chain id of the network to get the result from.
     * @param tokenId ID of token to get URI for.
     * @returns The token URI.
     */
    tokenURI(chainId: number, tokenId: string): Promise<string>;
    /**
     * Purchase a holographable open edition NFT.
     * @param chainId  The chain id of the network to send the transaction.
     * @param quantity The quantity of NFTs to purchase.
     * @param wallet Holograph wallet instance, optional param.
     * @param options The override options for the transaction.
     * @returns A transaction hash.
     */
    purchase(chainId: number, quantity: number, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
}

/**
 * @group Contracts
 * HolographInterfaces
 *
 * @remarks
 *
 * Provides access to universal Holograph Protocol variables.
 * The contract stores a reference of all supported: chains, interfaces, functions, etc.
 *
 */
declare class InterfacesContract extends HolographBaseContract {
    constructor(parentLogger?: HolographLogger);
    /**
     * @readonly
     * Get the HolographInterfaces contract address according to environment and chainId module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographInterfaces contract address in the provided network.
     */
    getAddress(chainId: number): Promise<Address>;
    private _getContractFunction;
    /**
     * @readonly
     * Get a base64 encoded contract URI JSON string.
     * Used to dynamically generate contract JSON payload.
     * @param chainId The chain id of the network to get the result from.
     * @param name the name of the smart contract.
     * @param imageURL string pointing to the primary contract image, can be: https, ipfs, or ar (arweave).
     * @param externalLink url to website/page related to smart contract.
     * @param bps basis points used for specifying royalties percentage.
     * @param contractAddress address of the smart contract.
     * @returns a base64 encoded json string representing the smart contract.
     */
    contractURI(chainId: number, name: string, imageURL: string, externalLink: string, bps: number, contractAddress: Address): Promise<string>;
    /**
     * @readonly
     * Get a base64 encoded contract URI JSON string.
     * Used to dynamically generate contract JSON payload.
     * @param name the name of the smart contract.
     * @param imageURL string pointing to the primary contract image, can be: https, ipfs, or ar (arweave).
     * @param externalLink url to website/page related to smart contract.
     * @param bps basis points used for specifying royalties percentage.
     * @param contractAddress address of the smart contract.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns a base64 encoded json string representing the smart contract per network.
     */
    contractURIByNetworks(name: string, imageURL: string, externalLink: string, bps: number, contractAddress: Address, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the prepend string to use for tokenURI.
     * Provides the prepend to use with TokenUriType URI.
     * @param chainId The chain id of the network to get the result from.
     * @param uriType The TokenUriType to get the prepend from.
     * @returns The prepend string
     *
     * @example
     * ```ts
     * ...
     * const prepend = await interfaceContract.getUriPrepend(80001, TokenUriType.IPFS)
     * console.log('The prepend string for IPFS token URIs is ', prepend)
     * // expected value: The prepend string for IPFS token URIs is ipfs://
     * ```
     */
    getUriPrepend(chainId: number, uriType: TokenUriType): Promise<string>;
    /**
     * @readonly
     * Get the prepend string to use for tokenURI.
     * Provides the prepend to use with TokenUriType URI.
     * @param uriType
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns X per network.
     */
    getUriPrependByNetworks(uriType: TokenUriType, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Updates the prepend string for a TokenUriType.
     * @param chainId The chain id of the network to send the transaction.
     * @param uriType The TokenUriType to set for.
     * @param prepend The prepend string.
     * @param wallet A
     * @returns A transaction hash.
     */
    updateUriPrepend(chainId: number, uriType: TokenUriType, prepend: string, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the prepends strings for an array of TokenUriTypes.
     * @param chainId The chain id of the network to send the transaction.
     * @param uriType Array of TokenUriType to set for.
     * @param prepend Array of prepends.
     * @returns A transaction hash.
     */
    updateUriPrepends(chainId: number, uriTypes: TokenUriType[], prepends: string[], wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @readonly
     * It's used to convert between the different types of chainIds.
     * @param chainId The chain id of the network to get the result from.
     * @param fromChainType The chain type of the source network.
     * @param fromChainId The actual chain ID value of the source network.
     * @param toChainType The chain type of the desired network.
     * @returns The Holograph chainId in the provided network.
     */
    getChainId(chainId: number, fromChainType: ChainIdType, fromChainId: bigint, toChainType: ChainIdType): Promise<bigint>;
    /**
     * @readonly
     * It's used to convert between the different types of chainIds.
     * @param fromChainType The chain type of the source network.
     * @param fromChainId The actual chain ID value of the source network.
     * @param toChainType The chain type of the desired network.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The chainIds per network.
     */
    getChainIdByNetworks(fromChainType: ChainIdType, fromChainId: bigint, toChainType: ChainIdType, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Updates the helper structure to identify if a contract supports a particular interface.
     * @param chainId The chain id of the network to send the transaction.
     * @param fromChainType The chain type of the source network.
     * @param fromChainId The actual chain ID value of the source network.
     * @param toChainType The chain type of the destine network.
     * @param toChainId The actual chain ID value of the destine network.
     * @returns A transaction hash.
     */
    updateChainIdMap(chainId: number, fromChainType: ChainIdType, fromChainId: bigint, toChainType: ChainIdType, toChainId: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the helper structure to identify if a contract supports a particular interface.
     * @param chainId The chain id of the network to send the transaction.
     * @param fromChainTypes The chain type of the source networks.
     * @param fromChainIds The actual chain ID values of the source networks.
     * @param toChainTypes The chain type of the destine networks.
     * @param toChainIds The actual chain ID values of the destine networks.
     * @returns A transaction hash.
     */
    updateChainIdMaps(chainId: number, fromChainTypes: ChainIdType[], fromChainIds: bigint[], toChainTypes: ChainIdType[], toChainIds: bigint[], wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @readonly
     * Helper to identify if a contract supports a particular interface.
     * @param chainId The chain id of the network to get the result from.
     * @param interfaceType The InterfaceType.
     * @param interfaceId The interface identifier, as specified in ERC-165.
     * @returns `true` if the contract implements `interfaceID` and `interfaceID` is not 0xffffffff, `false` otherwise.
     */
    supportsInterface(chainId: number, interfaceType: InterfaceType, interfaceId: Hex): Promise<boolean>;
    /**
     * @readonly
     * Helper to identify if a contract supports a particular interface by networks.
     * @param interfaceType The InterfaceType.
     * @param interfaceId The interface identifier, as specified in ERC-165.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns `true` if the contract implements `interfaceID` and `interfaceID` is not 0xffffffff, `false` otherwise per network.
     */
    supportsInterfaceByNetworks(interfaceType: InterfaceType, interfaceId: Hex, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Updates the helper structure to identify if a contract supports a particular interface.
     * @param chainId The chain id of the network to send the transaction.
     * @param interfaceType The InterfaceType.
     * @param interfaceId The interface identifier, as specified in ERC-165.
     * @param supported `true` if it's supported, `false` otherwise.
     * @returns A transaction hash.
     */
    updateInterface(chainId: number, interfaceType: InterfaceType, interfaceId: Hex, supported: boolean, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the helper structure to identify if a contract supports a particular interface.
     * @param chainId The chain id of the network to send the transaction.
     * @param interfaceType The InterfaceType.
     * @param interfaceIds An array of interface identifiers, as specified in ERC-165.
     * @param supported `true` if it's supported, `false` otherwise.
     * @returns A transaction hash.
     */
    updateInterfaces(chainId: number, interfaceType: InterfaceType, interfaceIds: Hex[], supported: boolean, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
}

/**
 * @group Contracts
 * LayerZeroModule
 *
 * @remarks
 *
 * Holograph module for enabling LayerZero cross-chain messaging.
 * This contract abstracts all of the LayerZero specific logic into an isolated module.
 *
 */
declare class LayerZeroModuleContract extends HolographBaseContract {
    private defaultChaiIds;
    constructor(parentLogger?: HolographLogger);
    /**
     * @readonly
     * Get the LayerZeroModule contract address according to environment and chainId module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The LayerZeroModule contract address in the provided network.
     */
    getAddress(chainId?: number | string): Address;
    private _getContractFunction;
    /**
     * @readonly
     * Get the default or chain-specific GasParameters.
     * @param chainId The chain id of the network to get the result from.
     * @param holographChainId the Holograph ChainId to get gas parameters for, set to 0 for default.
     * @returns The gas parameters object.
     */
    getGasParameters(chainId: number, holographChainId: number): Promise<GasParameters>;
    /**
     * @readonly
     * Get the default or chain-specific GasParameters.
     * Allows to properly calculate the L1 security fee for Optimism bridge transactions.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @param holographChainId the Holograph ChainId to get gas parameters for, set to 0 for default
     * @returns The gas parameters per network.
     */
    getGasParametersByNetworks(chainIds: number[] | undefined, holographChainId: number): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the address of the Optimism Gas Price Oracle module.
     * Allows to properly calculate the L1 security fee for Optimism bridge transactions.
     * @param chainId The chain id of the network to get the result from.
     * @returns The Optimism gas price oracle contract address.
     */
    getOptimismGasPriceOracle(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Get the address of the Optimism Gas Price Oracle module.
     * Allows to properly calculate the L1 security fee for Optimism bridge transactions.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Optimism gas price oracle contract address per network.
     */
    getOptimismGasPriceOracleByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the address of the approved LayerZero Endpoint.
     * All lzReceive function calls allow only requests from this address.
     * @param chainId The chain id of the network to get the result from.
     * @returns The LayerZero endpoint/address.
     */
    getLZEndpoint(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Get the address of the approved LayerZero Endpoint.
     * All lzReceive function calls allow only requests from this address.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The LayerZero endpoint/address per network.
     */
    getLZEndpointByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the address of the Holograph Bridge module.
     * Used for bridging holographable assets cross-chain.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographBridge contract address in the provided network.
     */
    getBridge(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Get the Holograph Bridge contract address by network.
     * Used for bridging holographable assets cross-chain.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the Holograph Bridge contract address per network.
     */
    getBridgeByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the address of the Holograph Interfaces module.
     * Holograph uses this contract to store data that needs to be accessed by a large portion of the modules.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographInterfaces contract address in the provided network.
     */
    getInterfaces(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Get the address of the Holograph Interfaces module.
     * Holograph uses this contract to store data that needs to be accessed by a large portion of the modules.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph Interfaces contract address per network.
     */
    getInterfacesByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the address of the Holograph Operator module.
     * All cross-chain Holograph Bridge bridges are handled by the Holograph Operator module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographOperator contract address in the provided network.
     */
    getOperator(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Get the Holograph Operator module by network.
     * All cross-chain Holograph Bridge bridges are handled by the Holograph Operator module.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph Operator contract address per network.
     */
    getOperatorByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the fees associated with sending specific payload.
     * It will provide exact costs on protocol and message side, combine the two to get total.
     * @param chainId The chain id of the network to send the transaction.
     * @param toChain The Holograph chain id of destination chain for payload.
     * @param gasLimit The amount of gas to provide for executing payload on destination chain.
     * @param gasPrice The maximum amount to pay for gas price, can be set to 0 and will be chose automatically.
     * @param crossChainPayload The entire packet being sent cross-chain.
     * @returns stringifiedFeesArray The compound fees [hlfFee, msgFee, dstGasPrice]:
     * hlgFee: The amount (in wei) of native gas token that will cost for finalizing job on destination chain.
     * msgFee: The amount (in wei) of native gas token that will cost for sending message to destination chain.
     * dstGasPrice: The amount (in wei) that destination message maximum gas price will be.
     */
    getMessageFee(chainId: number, toChain: number, gasLimit: bigint, gasPrice: bigint, crossChainPayload: Hex): Promise<[bigint, bigint, bigint]>;
    /**
     * @readonly
     * @param chainId The chain id of the network to send the transaction.
     * @param toChain The Holograph chain id of destination chain for payload.
     * @param gasLimit The amount of gas to provide for executing payload on destination chain.
     * @param gasPrice The maximum amount to pay for gas price, can be set to 0 and will be chose automatically.
     * @param crossChainPayload The entire packet being sent cross-chain.
     * @returns The HLG fee.
     */
    getHlgFee(chainId: number, toChain: number, gasLimit: bigint, gasPrice: bigint, crossChainPayload: Hex): Promise<bigint>;
    /**
     * Updates the prepends strings for an array of TokenUriTypes.
     * @param chainId The chain id of the network to send the transaction.
     * @param gasLimit The amount of gas to provide for executing payload on destination chain.
     * @param gasPrice The maximum amount to pay for gas price, can be set to 0 and will be chose automatically.
     * @param toChain The Holograph chain id of destination chain for payload.
     * @param msgSender The address of who is sending the message.
     * @param msgValue The amount in wei to send the message to the destination chain.
     * @param crossChainPayload The entire packet being sent cross-chain.
     * @returns A transaction hash.
     */
    send(chainId: number, gasLimit: bigint, gasPrice: bigint, toChain: number, msgSender: Address, msgValue: bigint, crossChainPayload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Interfaces module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param interfaces The address of the Holograph Interfaces smart contract to use.
     * @returns A transaction hash.
     */
    setInterfaces(chainId: number, interfaces: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Operator module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param operator The address of the Holograph Operator smart contract to use.
     * @returns A transaction hash.
     */
    setOperator(chainId: number, operator: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the approved LayerZero Endpoint address.
     * @param chainId The chain id of the network to send the transaction.
     * @param lZEndpoint address of the LayerZero Endpoint to use.
     * @returns A transaction hash.
     */
    setLZEndpoint(chainId: number, lZEndpoint: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Optimism Gas Price Oracle module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param optimismGasPriceOracle address of the Optimism Gas Price Oracle smart contract to use
     * @returns A transaction hash.
     */
    setOptimismGasPriceOracle(chainId: number, optimismGasPriceOracle: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the default or chain-specific GasParameters.
     * @param chainId The chain id of the network to send the transaction.
     * @param holographChainId The Holograph chain id to set gas parameters for, set to 0 for default.
     * @param gasParameters The struct of all the gas parameters to set.
     * @returns A transaction hash.
     */
    setGasParameters(chainId: number, holographChainId: number, gasParameters: GasParameters, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
}

/**
 * @group Contracts
 * HolographOperator
 *
 * @remarks
 *
 * The Operator holds and manages the protocol operator.
 *
 */
declare class OperatorContract extends HolographBaseContract {
    constructor(parentLogger?: HolographLogger);
    /**
     * @readonly
     * Get the HolographOperator contract address according to environment and chainId module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographOperator contract address in the provided network.
     */
    getAddress(chainId: number): Promise<Address>;
    private _getContractFunction;
    estimateContractFunctionGas({ chainId, functionName, wallet, args, options, }: EstimateContractFunctionGasArgs<typeof _default>): Promise<bigint>;
    simulateContractFunction({ chainId, functionName, args, options, transportType, }: SimulateContractFunctionArgs<typeof _default>): Promise<any>;
    /**
     * @readonly
     * Get the details for an available operator job.
     * @param chainId The chain id of the network to get the result from.
     * @param jobHash keccak256 hash of the job.
     * @returns true if the job exists, false otherwise.
     */
    operatorJobExists(chainId: number, jobHash: Hex): Promise<boolean>;
    /**
     * @readonly
     * Get the details for an available operator job per network.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @param jobHash keccak256 hash of the job.
     * @returns true if the job exists, and false otherwise per network.
     */
    operatorJobExistsByNetworks(chainIds: number[], jobHash: Hex): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Checks if a failed job exists.
     * @param chainId The chain id of the network to get the result from.
     * @param jobHash keccak256 hash of the job.
     * @returns true if the job exists, false otherwise.
     */
    failedJobExists(chainId: number, jobHash: Hex): Promise<boolean>;
    /**
     * @readonly
     * Checks if a failed job exists per network.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @param jobHash keccak256 hash of the job.
     * @returns true if the job exists, and false otherwise per network.
     */
    failedJobExistsByNetworks(chainIds: number[], jobHash: Hex): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the details for an available operator job.
     * @param chainId The chain id of the network to get the result from.
     * @param jobHash keccak256 hash of the job.
     * @returns an OperatorJob struct with details about a specific job.
     */
    getJobDetails(chainId: number, jobHash: Address): Promise<OperatorJob>;
    /**
     * @readonly
     * Get number of pods available.
     * @param chainId The chain id of the network to get the result from.
     * @returns number of pods that have been opened via bonding.
     */
    getTotalPods(chainId: number): Promise<bigint>;
    /**
     * @readonly
     * Get total number of operators in a pod.
     * @param chainId The chain id of the network to get the result from.
     * @param pod the pod to query.
     * @returns total operators in a pod.
     */
    getPodOperatorsLength(chainId: number, pod: bigint | number): Promise<bigint>;
    /**
     * @readonly
     * Get list of operators in a pod.
     * @param chainId The chain id of the network to get the result from.
     * @param pod the pod to query.
     * @returns operators array list of operators in a pod.
     */
    getPodOperators(chainId: number, pod: bigint | number): Promise<Address[]>;
    /**
     * @readonly
     * Get paginated list of operators in a pod.
     * @param chainId The chain id of the network to get the result from.
     * @param pod the pod to query.
     * @param index the array index to start from.
     * @param length the length of result set to be (will be shorter if reached end of array).
     * @returns operators a paginated array of operators.
     */
    getPaginatedPodOperators(chainId: number, pod: bigint | number, index: number, length: number): Promise<Address[]>;
    /**
     * @readonly
     * Check the base and current price for bonding to a particular pod.
     * @param chainId The chain id of the network to get the result from.
     * @param pod the pod to get bonding amounts for.
     * @returns base the base bond amount required for a pod.
     * @returns current the current bond amount required for a pod.
     */
    getPodBondAmounts(chainId: number, pod: bigint | number): Promise<[bigint, bigint]>;
    /**
     * @readonly
     * Get an operator's currently bonded amount.
     * @param chainId The chain id of the network to get the result from.
     * @param operator address of operator to check.
     * @returns amount total number of utility token bonded.
     */
    getBondedAmount(chainId: number, operator: Address): Promise<bigint>;
    /**
     * @readonly
     * Get an operator's currently bonded pod.
     * @param chainId The chain id of the network to get the result from.
     * @param operator address of operator to check.
     * @returns pod number that operator is bonded on, returns zero if not bonded or selected for job.
     */
    getBondedPod(chainId: number, operator: Address): Promise<bigint>;
    /**
     * @readonly
     * Get an operator's currently bonded pod index.
     * @param chainId The chain id of the network to get the result from.
     * @param operator address of operator to check.
     * @returns index currently bonded pod's operator index, returns zero if not in pod or moved out for active job.
     */
    getBondedPodIndex(chainId: number, operator: Address): Promise<bigint>;
    /**
     * @readonly
     * Get the Minimum Gas Price.
     * @param chainId The chain id of the network to get the result from.
     * @returns The minimum value required to execute a job without it being marked as under priced.
     */
    getMinGasPrice(chainId: number): Promise<bigint>;
    /**
     * @readonly
     * Get the address of the Holograph Message Module
     * @param chainId The chain id of the network to get the result from.
     * @returns The Message Module address to which all cross-chain message requests will be forwarded.
     */
    getMessagingModule(chainId: number): Promise<any>;
    /**
     * @readonly
     * Get the Holograph Protocol contract address by network.
     * This contract stores a reference to all the primary modules and variables of the protocol.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the Holograph contract address per network.
     */
    getHolographByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the Holograph Bridge contract address by network.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the Holograph Bridge contract address per network.
     */
    getBridgeByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the Holograph Registry module by network.
     * This module stores a reference for all deployed holographable smart contracts.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph Registry contract address per network.
     */
    getRegistryByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the address of the Holograph Messaging Module by network.
     * All cross-chain message requests will get forwarded to this address.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph Messaging Module contract address per network.
     */
    getMessagingModuleByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the Holograph Utility Token address by network.
     * This is the official utility token of the Holograph Protocol.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The Holograph Utility Token contract address per network.
     */
    getUtilityTokenByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Get the fees associated with sending specific payload.
     * It will provide exact costs on protocol and message side, combine the two to get total.
     * @param chainId The chain id of the network to send the transaction.
     * @param toChain The Holograph chain id of destination chain for payload.
     * @param gasLimit The amount of gas to provide for executing payload on destination chain.
     * @param gasPrice The maximum amount to pay for gas price, can be set to 0 and will be chose automatically.
     * @param crossChainPayload The entire packet being sent cross-chain.
     * @returns stringifiedFeesArray The compound fees [hlfFee, msgFee, dstGasPrice]:
     * hlgFee: The amount (in wei) of native gas token that will cost for finalizing job on destination chain.
     * msgFee: The amount (in wei) of native gas token that will cost for sending message to destination chain.
     * dstGasPrice: The amount (in wei) that destination message maximum gas price will be.
     */
    getMessageFee(chainId: number, toChain: number, gasLimit: bigint, gasPrice: bigint, crossChainPayload: Hex): Promise<[bigint, bigint, bigint]>;
    /**
     * Sends cross chain bridge request message.
     * This function is restricted to only be callable by Holograph Bridge.
     * @param chainId The chain id of the network to send the transaction.
     * @param gasLimit The maximum amount of gas to spend for executing the bridge on destination chain.
     * @param gasPrice The maximum amount of gas price (in destination chain native gas token) to pay on destination chain.
     * @param toChain The  Holograph Chain ID where the bridge is being sent to.
     * @param nonce The incremented number used to ensure job hashes are unique.
     * @param holographableContract The address of the contract for which the bridge request is being made.
     * @param bridgeOutPayload The bytes made up of the bridgeOutRequest payload.
     * @returns A transaction hash.
     */
    send(chainId: number, gasLimit: bigint, gasPrice: bigint, toChain: number, nonce: bigint, holographableContract: Address, bridgeOutPayload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Recovers a failed job. If a job fails, it can be manually recovered.
     * @param chainId The chain id of the network to send the transaction.
     * @param bridgeInRequestPayload The entire cross chain message payload.
     * @returns A transaction hash.
     */
    recoverJob(chainId: number, bridgeInRequestPayload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Executes an available operator job.
     * When making this call, if operating criteria is not met, the call will revert.
     * @param chainId The chain id of the network to send the transaction.
     * @param bridgeInRequestPayload The entire cross chain message payload.
     * @returns A transaction hash.
     */
    executeJob(chainId: number, bridgeInRequestPayload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Purposefully made to be external so that Operator can call it during executeJob function.
     * @param chainId The chain id of the network to send the transaction.
     * @param msgSender The address of who is sending the message.
     * @param payload The entire cross chain message payload.
     * @returns A transaction hash.
     */
    nonRevertingBridgeCall(chainId: number, msgSender: Address, payload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Receives a cross-chain message.
     * This function is restricted for use by Holograph Messaging Module only.
     * @param chainId The chain id of the network to send the transaction.
     * @param bridgeInRequestPayload The entire cross chain message payload.
     * @returns A transaction.
     */
    crossChainMessage(chainId: number, bridgeInRequestPayload: Hex, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Calculates the amount of gas needed to execute a bridgeInRequest.
     * Use this function to estimate the amount of gas that will be used by the bridgeInRequest function.
     * Set a specific gas limit when making this call, subtract return value, to get total gas used.
     * @param chainId The chain id of the network to send the transaction.
     * @param bridgeInRequestPayload The abi encoded bytes making up the bridgeInRequest payload.
     * @returns The gas amount remaining after the static call is returned.
     */
    jobEstimator(chainId: number, bridgeInRequestPayload: Hex): Promise<bigint>;
    /**
     * Topup a bonded operator with more utility tokens.
     * Useful function if an operator got slashed and wants to add a safety buffer to not get unbonded.
     * This function will not work if operator has currently been selected for a job.
     * @param chainId The chain id of the network to send the transaction.
     * @param operator The address of operator to topup.
     * @param amount The utility token amount to add.
     * @returns A transaction hash.
     */
    topupUtilityToken(chainId: number, operator: Address, amount: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Bonds utility tokens and become an operator.
     * An operator can only bond to one pod at a time, per network.
     * @param chainId The chain id of the network to send the transaction.
     * @param operator The address of operator to bond (can be an ownable smart contract).
     * @param amount The utility token amount to bond (can be greater than minimum).
     * @param pod The number of pod to bond to (can be for one that does not exist yet).
     * @returns A transaction hash.
     */
    bondUtilityToken(chainId: number, operator: Address, amount: bigint, pod: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * Unbonds HLG utility tokens and stop being an operator.
     * A bonded operator selected for a job cannot unbond until they complete the job, or are slashed.
     * @param chainId The chain id of the network to send the transaction.
     * @param operator The address of operator to unbond.
     * @param recipient The address where to send the bonded tokens.
     * @returns A transaction hash.
     */
    unbondUtilityToken(chainId: number, operator: Address, recipient: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Bridge module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param bridge The address of the Holograph Bridge smart contract to use.
     * @returns A transaction hash.
     */
    setBridge(chainId: number, bridge: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Protocol contract address.
     * @param chainId The chain id of the network to send the transaction.
     * @param holograph The address of the Holograph Protocol smart contract to use.
     * @returns A transaction.
     */
    setHolograph(chainId: number, holograph: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Interfaces module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param interfaces The address of the Holograph Interfaces smart contract to use.
     * @returns A transaction.
     */
    setInterfaces(chainId: number, interfaces: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Messaging Module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param messagingModule The address of the LayerZero Endpoint to use.
     * @returns A transaction.
     */
    setMessagingModule(chainId: number, messagingModule: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Registry module address.
     * @param chainId The chain id of the network to send the transaction.
     * @param registry The address of the Holograph Registry smart contract to use.
     * @returns A transaction.
     */
    setRegistry(chainId: number, registry: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Holograph Utility Token address.
     * @param chainId The chain id of the network to send the transaction.
     * @param utilityToken The address of the Holograph Utility Token smart contract to use.
     * @returns A transaction hash.
     */
    setUtilityToken(chainId: number, utilityToken: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Updates the Minimum Gas Price.
     * @param chainId The chain id of the network to send the transaction.
     * @param minGasPrice The amount to set for minimum gas price.
     * @returns A transaction hash.
     */
    setMinGasPrice(chainId: number, minGasPrice: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
}

/**
 * @group Contracts
 * OVMGasPriceOracle
 *
 * @remarks
 *
 * This contract exposes the current L2 gas price, a measure of how congested the network
 * currently is. This measure is used by the Sequencer to determine what fee to charge for
 * transactions. When the system is more congested, the L2 gas price will increase and fees
 * will also increase as a result.
 *
 * All public variables are set while generating the initial L2 state. The
 * constructor doesn't run in practice as the L2 state generation script uses
 * the deployed bytecode instead of running the initcode.
 *
 */
declare class OVMGasPriceOracleContract extends HolographBaseContract {
    constructor(parentLogger?: HolographLogger);
    /**
     * @readonly
     * Get the OVM_GasPriceOracle contract address according to environment and chainId module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The OVM_GasPriceOracle contract address in the provided network.
     */
    getAddress(chainId: number): Address;
    private _getContractFunction;
    /**
     * @readonly
     * Computes the L1 portion of the fee based on the size of the RLP encoded tx and the current l1BaseFee.
     * @param chainId The chain id of the network to get the result from.
     * @param data Unsigned RLP encoded tx, 6 elements.
     * @returns The L1 fee that should be paid for the tx.
     */
    getL1Fee(chainId: number, data: Hex): Promise<bigint>;
    /**
     * @readonly
     * Computes the L1 portion of the fee based on the size of the RLP encoded tx and the current l1BaseFee.
     * @param chainIds The list of network chainIds to get the results from.
     * @param data Unsigned RLP encoded tx, 6 elements.
     * @returns The L1 fee that should be paid for the tx  per network.
     */
    getL1FeeByNetworks(chainIds: number[], data: Hex): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Computes the amount of L1 gas used for a transaction
     * The overhead represents the per batch gas overhead of posting both transaction and state roots to L1 given larger batch sizes.
     * 4 gas for 0 byte
     * https://github.com/ethereum/go-ethereum/blob/9ada4a2e2c415e6b0b51c50e901336872e028872/params/protocol_params.go#L33
     * 16 gas for non zero byte
     * https://github.com/ethereum/go-ethereum/blob/9ada4a2e2c415e6b0b51c50e901336872e028872/params/protocol_params.go#L87
     * This will need to be updated if calldata gas prices change
     * Account for the transaction being unsigned
     * Padding is added to account for lack of signature on transaction
     * 1 byte for RLP V prefix
     * 1 byte for V
     * 1 byte for RLP R prefix
     * 32 bytes for R
     * 1 byte for RLP S prefix
     * 32 bytes for S
     * Total: 68 bytes of padding
     * @param chainId The chain id of the network to get the result from.
     * @param data Unsigned RLP encoded tx, 6 elements
     * @returns The amount of L1 gas used for a transaction.
     */
    getL1GasUsed(chainId: number, data: Hex): Promise<bigint>;
    /**
     * @readonly
     * Computes the amount of L1 gas used for a transaction.
     * @param chainIds The list of network chainIds to get the results from.
     * @param data Unsigned RLP encoded tx, 6 elements.
     * @returns The amount of L1 gas used for a transaction per network.
     */
    getL1GasUsedByNetworks(chainIds: number[], data: Hex): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Allows the owner to modify the L2 gas price.
     * @param chainId The chain id of the network to send the transaction.
     * @param gasPrice The new L2 gas price.
     * @returns A transaction hash.
     */
    setGasPrice(chainId: number, gasPrice: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Allows the owner to modify the L1 base fee.
     * @param chainId The chain id of the network to send the transaction.
     * @param baseFee The new L1 base fee.
     * @returns A transaction hash.
     */
    setL1BaseFee(chainId: number, baseFee: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Allows the owner to modify the overhead.
     * @param chainId The chain id of the network to send the transaction.
     * @param overhead The new overhead.
     * @returns A transaction hash.
     */
    setOverhead(chainId: number, overhead: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Allows the owner to modify the scalar.
     * @param chainId The chain id of the network to send the transaction.
     * @param scalar The new scalar.
     * @returns A transaction hash.
     */
    setScalar(chainId: number, scalar: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Allows the owner to modify the decimals.
     * @param chainId The chain id of the network to send the transaction.
     * @param decimals The new decimals.
     * @returns A transaction hash.
     */
    setDecimals(chainId: number, decimals: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
}

/**
 * @group Contracts
 * HolographRegistry
 *
 * @remarks
 *
 * Registry is a central on-chain location where all Holograph data is stored. Registry keeps a record of all currently supported standards. New standards can be introduced and enabled as well. Any properly deployed Holographed contracts are also stored as reference. This allows for a definitive way to identify whether a smart contract is secure and properly Holographed. Verifying entities will be able to identify a Holographed contract to ensure the highest level of security and standards.
 *
 */
declare class RegistryContract extends HolographBaseContract {
    constructor(parentLogger?: HolographLogger);
    /**
     * @readonly
     * Get the HolographRegistry contract address according to environment and chainId module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographRegistry contract address in the provided network.
     */
    getAddress(chainId: number): Promise<Address$1>;
    private _getContractFunction;
    /**
     * @readonly
     * Checks if the contract it's aligned with the Holograph standard.
     * @param chainId The chain id of the network to get the result from.
     * @param contractAddress The contract address.
     * @returns true if it's holographed, and false otherwise.
     */
    isHolographedContract(chainId: number, contractAddress: Address$1): Promise<boolean>;
    /**
     * @readonly
     * Checks if the contract it's aligned with the Holograph standard by network.
     * @param contractAddress The contract address.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns true if it's holographed, and false otherwise per network.
     */
    isHolographedContractByNetworks(contractAddress: Address$1, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Checks if the hash is deployed.
     * @param chainId The chain id of the network to get the result from.
     * @param hash The hash obtained by hashing all the necessary configuration parameters and converting them into a salt variable.
     * @returns true if it's deployed, and false otherwise.
     */
    isHolographedHashDeployed(chainId: number, hash: Address$1): Promise<boolean>;
    /**
     * @readonly
     * Checks if the hash is deployed per network.
     * @param hash The hash obtained by hashing all the necessary configuration parameters and converting them into a salt variable.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns true if it's deployed, and false otherwise per network.
     */
    isHolographedHashDeployedByNetworks(hash: Address$1, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Returns the contract address for a contract type.
     * @param chainId The chain id of the network to get the result from.
     * @param contractType The contract type bytes32.
     * @returns the contract address for the provided contract type.
     */
    getContractTypeAddress(chainId: number, contractType: Hex): Promise<Address$1>;
    /**
     * @readonly
     * Returns the contract address for a contract type per network.
     * @param contractType The contract type bytes32.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the contract address for the provided contract type per network.
     */
    getContractTypeAddressByNetworks(contractType: Hex, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Sets the contract address for a contract type.
     * @param chainId The chainId of the network to send the transaction to.
     * @param contractType The contract type bytes32.
     * @param contractAddress The contract address for the provided contract type.
     * @returns A transaction hash
     */
    setContractTypeAddress(chainId: number, contractType: Hex, contractAddress: Address$1, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @readonly
     * Get the Holograph Protocol contract.
     * This contract stores a reference to all the primary modules and variables of the protocol.
     * @param chainId The chain id of the network to get the result from.
     * @returns the holograph contract address.
     */
    getHolograph(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the Holograph Protocol contract.
     * This contract stores a reference to all the primary modules and variables of the protocol.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the holograph contract address per network.
     */
    getHolographByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Sets the Holograph module contract address.
     * @param chainId The chainId of the network to send the transaction to.
     * @param address The Holograph module contract address.
     * @returns A transaction hash.
     */
    setHolograph(chainId: number, address: Address$1, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @readonly
     * Returns the hToken address for a given chain id.
     * @param chainId The chain id of the network to get the result from.
     * @param hTokenChainId The mapped chain id to get the htoken address
     * @returns The hToken address for a given chain id
     */
    getHToken(chainId: number, hTokenChainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the HToken address per network.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @param hTokenChainId The mapped chain id to get the htoken address
     * @returns the hToken contract address per network.
     */
    getHTokenByNetworks(chainIds: number[], hTokenChainId: number): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Sets the hToken address for a specific chain id.
     * @param chainId The chainId of the network to send the transaction to.
     * @param hTokenChainId the hToken address chain id.
     * @param hToken The hToken contract address.
     * @returns A transaction hash.
     */
    setHToken(chainId: number, hTokenChainId: number, hToken: Address$1, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<any>;
    /**
     * @readonly
     * Get the Holograph Utility Token address.
     * This is the official utility token of the Holograph Protocol
     * @param chainId The chain id of the network to get the result from.
     * @returns the Holograph Utility Token contract address.
     */
    getUtilityToken(chainId: number): Promise<Address$1>;
    /**
     * @readonly
     * Get the Holograph Utility Token address per network.
     * This is the official utility token of the Holograph Protocol.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the Holograph Utility Token contract address per network.
     */
    getUtilityTokenByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Update the Holograph Utility Token address
     * @param chainId The chainId of the network to send the transaction to.
     * @param utilityToken The address of the Holograph Utility Token smart contract to use
     * @returns A transaction hash.
     */
    setUtilityToken(chainId: number, utilityToken: Address$1, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @readonly
     * Get set length list, starting from index, for all holographable contracts
     * @param chainId The chainId of the network to get the result from
     * @param index The index to start enumeration from
     * @param length The length of returned results
     * @returns contracts address[] Returns a set length array of holographable contracts deployed in the chainId
     */
    getHolographableContracts(chainId: number, index: bigint, length: bigint): Promise<Address$1[]>;
    /**
     * @readonly
     * Get set length list, starting from index, for all holographable contracts
     * @param index The index to start enumeration from
     * @param length The length of returned results
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default is the networks defined in the config
     * @returns contracts address[] Returns a set length array of holographable contracts deployed per chainId
     */
    getHolographableContractsByNetworks(index: bigint, length: bigint, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Returns the address for a holographed hash.
     * @param chainId The chain id of the network to get the result from.
     * @param hash The hash obtained by hashing all the necessary configuration parameters and converting them into a salt variable.
     * @returns a contract address for the provided hash.
     */
    getHolographedHashAddress(chainId: number, hash: Address$1): Promise<Address$1>;
    /**
     * @readonly
     * Returns the address for a holographed hash per network.
     * @param hash The hash obtained by hashing all the necessary configuration parameters and converting them into a salt variable.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the contract address for the provided hash per network.
     */
    getHolographedHashAddressContractsByNetworks(hash: Address$1, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Allows Holograph Factory to register a deployed contract, referenced with deployment hash
     * @param chainId The chainId of the network to send the transaction to.
     * @param hash The hash obtained by hashing all the necessary configuration parameters and converting them into a salt variable.
     * @param contractAddress the contract address for the provided hash.
     * @returns A transaction hash.
     */
    setHolographedHashAddress(chainId: number, hash: Hex, contractAddress: Address$1, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<any>;
    /**
     * @readonly
     * Get total number of deployed holographable contracts.
     * @param chainId The chain id of the network to get the result from.
     * @returns the number of deployed holographable contracts.
     */
    getHolographableContractsLength(chainId: number): Promise<bigint>;
    /**
     * @readonly
     * Get total number of deployed holographable contracts per network.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the number of deployed holographable contracts per network.
     */
    getHolographableContractsLengthByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Allows to reference a deployed smart contract, and use it's code as reference inside of Holographers.
     * @param chainId The chain id of the network to get the result from.
     * @param contractAddress the contract address.
     * @returns the bytes32 contract type.
     */
    referenceContractTypeAddress(chainId: number, contractAddress: Address$1): Promise<Hex>;
    /**
     * @readonly
     * Allows to reference a deployed smart contract, and use it's code as reference inside of Holographers.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @param contractAddress the contract address.
     * @returns the bytes32 contract type per network.
     */
    referenceContractTypeAddressByNetworks(contractAddress: Address$1, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @readonly
     * Returns the reserved contract address for a contract type.
     * @param chainId The chain id of the network to get the result from.
     * @param contractType The bytes32 for the contract type.
     * @returns the reserved contract address.
     */
    getReservedContractTypeAddress(chainId: number, contractType: Hex): Promise<Address$1>;
    /**
     * @readonly
     * Returns the reserved contract address for a contract type per network.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @param contractType The bytes32 for the contract type.
     * @returns the reserved contract address per network.
     */
    getReservedContractTypeAddressByNetworks(contractType: Hex, chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Allows admin to update or toggle reserved types.
     * @param chainId The chainId of the network to send the transaction to.
     * @param hashes The bytes32 for the contract typeS.
     * @param reserved A boolean.
     * @returns A transaction hash.
     */
    setReservedContractTypeAddress(chainId: number, hash: Hex, reserved: boolean, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Allows admin to update or toggle multiple reserved types.
     * @param chainId The chainId of the network to send the transaction to.
     * @param hashes A bytes32 array for the contract typeS.
     * @param reserved A boolean array.
     * @returns A transaction hash.
     */
    setReservedContractTypeAddresses(chainId: number, hashes: Hex[], reserved: boolean[], wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
}

/**
 * @group Contracts
 * HolographTreasury
 *
 * @remarks
 *
 * The Treasury holds and manages the protocol treasury.
 *
 */
declare class TreasuryContract extends HolographBaseContract {
    constructor(parentLogger?: HolographLogger);
    /**
     * @readonly
     * Get the HolographTreasury contract address according to environment and chainId module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographTreasury contract address in the provided network.
     */
    getAddress(chainId: number): Promise<Address>;
    private _getContractFunction;
    /**
     * @readonly
     * Get the HolographBridge contract address according to the chainId.
     * @param chainId The chain id of the network to get the result from.
     * @returns The address of the HolographBridge module
     */
    getBridge(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Get the HolographBridge contract address by network.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the HolographBridge contract address per network.
     */
    getBridgeByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Update the Holograph Bridge module address.
     * @param chainId The chainId of the network to send the transaction to.
     * @param bridge address of the Holograph Bridge smart contract to use.
     * @return A transaction hash.
     */
    setBridge(chainId: number, bridge: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @readonly
     * Get the Holograph Protocol contract.
     * This contract stores a reference to all the primary modules and variables of the protocol.
     * @param chainId The chain id of the network to get the result from.
     * @returns the holograph contract address.
     */
    getHolograph(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Get the Holograph Protocol contract.
     * This contract stores a reference to all the primary modules and variables of the protocol.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns the holograph contract address per network.
     */
    getHolographByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Update the Holograph Protocol contract address.
     * @param chainId The chainId of the network to send the transaction to.
     * @param holograph address of the Holograph Protocol smart contract to use.
     * @return A transaction hash.
     */
    setHolograph(chainId: number, holograph: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @readonly
     * Get the address of the Holograph Operator module.
     * All cross-chain Holograph Bridge bridges are handled by the Holograph Operator module.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographOperator contract address in the provided network.
     */
    getOperator(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Get the address of the Holograph Operator module.
     * All cross-chain Holograph Bridge bridges are handled by the Holograph Operator module.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographOperator contract address per network.
     */
    getOperatorByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Update the Holograph Operator contract address.
     * @param chainId The chainId of the network to send the transaction to.
     * @param operator address of the Holograph Operator smart contract to use.
     * @return A transaction hash.
     */
    setOperator(chainId: number, operator: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @readonly
     * Get the Holograph Registry module.
     * This module stores a reference for all deployed holographable smart contracts.
     * @param chainId The chain id of the network to get the result from.
     * @returns The HolographRegistry contract address in the provided network.
     */
    getRegistry(chainId: number): Promise<Address>;
    /**
     * @readonly
     * Get the Holograph Registry module.
     * This module stores a reference for all deployed holographable smart contracts.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The HolographRegistry contract address per network.
     */
    getRegistryByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Update the Holograph Registry contract address.
     * @param chainId The chainId of the network to send the transaction to.
     * @param operator address of the Holograph Registry smart contract to use.
     * @return A transaction hash.
     */
    setRegistry(chainId: number, registry: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Withdraws native tokens from the contract.
     * @param chainId The chainId of the network to send the transaction to.
     * @return A transaction hash.
     */
    withdraw(chainId: number, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @onlyAdmin
     * Withdraws native tokens from the contract to a specified address.
     * @param chainId The chainId of the network to send the transaction to.
     * @param recipient The address to send the withdrawn funds to.
     * @return A transaction hash.
     */
    withdrawTo(chainId: number, recipient: Address, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
    /**
     * @readonly
     * Get the Holograph Mint Fee.
     * This fee is charged to mint holographable assets.
     * @param chainId The chainId of the network to get the result from.
     * @returns The mint fee.
     */
    getHolographMintFee(chainId: number): Promise<bigint>;
    /**
     * @readonly
     * Get the Holograph Mint Fee by network.
     * This fee is charged to mint holographable assets.
     * @param chainIds The list of network chainIds to get the results from, if nothing is provided the default are the networks defined in the config.
     * @returns The mint fee per network.
     */
    getHolographMintFeeByNetworks(chainIds?: number[]): Promise<HolographByNetworksResponse>;
    /**
     * @onlyAdmin
     * Update the Holograph Mint Fee.
     * @param fee new fee to charge for minting holographable assets.
     * @param chainId The chainId of the network to send the transaction to.
     * @returns a transaction hash.
     */
    setHolographMintFee(chainId: number, fee: bigint, wallet?: {
        account: string | HolographWallet;
    }, options?: WriteContractOptions): Promise<Hex>;
}

type CreateNFT = {
    contract: HolographERC721Contract;
    ipfsMetadataCid: string;
    version?: HolographVersion;
};
type CreateOpenEditionNFT = {
    contract: HolographOpenEditionERC721ContractV1 | HolographOpenEditionERC721ContractV2;
    version?: HolographVersion;
};

declare class NFT {
    contract: HolographERC721Contract;
    isMinted: boolean;
    txHash?: string;
    ipfsMetadataCid?: string;
    private _tokenId?;
    private cxipERC721;
    constructor({ contract, ipfsMetadataCid }: CreateNFT);
    setIpfsMetadataCid(ipfsMetadataCid: string): void;
    get tokenId(): string;
    getParsedTokenId(): {
        decimal: string;
        hex: `0x${string}`;
        part: {
            chainId: string;
            tokenNumber: string;
        };
    };
    mint({ chainId, wallet }: MintConfig, options?: WriteContractOptions): Promise<{
        tokenId: `0x${string}`;
        txHash: `0x${string}`;
    }>;
    estimateGasForMintingNFT({ chainId, wallet }: MintConfig): Promise<{
        gasPrice: bigint;
        gasLimit: bigint;
        gas: bigint;
    }>;
    tokenIdExists(tokenId: string, chainId: number): Promise<boolean>;
    getOwner(tokenId: string, chainId: number): Promise<`0x${string}`>;
    isOwner(account: Address, tokenId: string, chainId: number): Promise<boolean>;
}

declare class OpenEditionNFT {
    contract: HolographOpenEditionERC721ContractV1 | HolographOpenEditionERC721ContractV2;
    isMinted: boolean;
    txHash?: string;
    protected _tokenId?: string;
    private holographOpenEditionERC721;
    constructor({ contract, version }: CreateOpenEditionNFT);
    get tokenId(): string | undefined;
    getParsedTokenId(): {
        decimal: string;
        hex: `0x${string}`;
        part: {
            chainId: string;
            tokenNumber: string;
        };
    };
    purchase({ chainId, quantity, wallet }: MintConfig, options?: WriteContractOptions): Promise<{
        tokenId: `0x${string}`;
        txHash: `0x${string}`;
    }>;
    mint(...args: Parameters<OpenEditionNFT['purchase']>): Promise<{
        tokenId: `0x${string}`;
        txHash: `0x${string}`;
    }>;
    estimateGasForPurchasingNFT({ chainId, quantity: quantity_, wallet }: MintConfig): Promise<{
        gasPrice: bigint;
        gasLimit: bigint;
        gas: bigint;
        protocolFee: bigint;
        total: bigint;
    }>;
    estimateGasForMintingNFT(...args: Parameters<OpenEditionNFT['estimateGasForPurchasingNFT']>): Promise<{
        gasPrice: bigint;
        gasLimit: bigint;
        gas: bigint;
        protocolFee: bigint;
        total: bigint;
    }>;
    tokenIdExists(tokenId: string, chainId: number): Promise<boolean>;
    getOwner(tokenId: string, chainId: number): Promise<`0x${string}`>;
    isOwner(account: Address, tokenId: string, chainId: number): Promise<boolean>;
}

declare class HolographProtocol {
    private readonly contractAddress?;
    static readonly targetEvents: Record<string, EventInfo>;
    private readonly logger;
    private readonly protocolConfig;
    private holographContract;
    private registryContract;
    private treasuryContract;
    private interfacesContract;
    private operatorContract;
    private layerZeroModuleContract;
    private factoryContract;
    private ovmGasPriceOracleContract;
    private bridgeContract;
    private cxipERC721Contract;
    private openEditionERC721Contract;
    private readonly _providers;
    constructor(protocolConfig?: Config, contractAddress?: `0x${string}` | undefined);
    get holograph(): HolographContract;
    get registry(): RegistryContract;
    get treasury(): TreasuryContract;
    get interfaces(): InterfacesContract;
    get operator(): OperatorContract;
    get layerZeroModule(): LayerZeroModuleContract;
    get factory(): FactoryContract;
    get ovmGasPriceOracle(): OVMGasPriceOracleContract;
    get bridge(): BridgeContract$1;
    get cxipERC721(): CxipERC721Contract;
    get openEditionERC721(): OpenEditionERC721Contract;
    hydrateContractFromAddress(hydrateContractInput: {
        chainId: number;
        address: Address$1;
        type: ContractType;
    }): Promise<HolographERC721Contract | HolographOpenEditionERC721ContractV1 | HolographOpenEditionERC721ContractV2>;
    hydrateNFT(hydrateNftInput: {
        chainId: number;
        contractAddress: Address$1;
        tokenId: string;
        type: ContractType;
    }): Promise<NFT | OpenEditionNFT>;
}

declare class Providers {
    private readonly logger;
    private readonly _clientProvider?;
    private readonly _providers;
    private readonly _networks;
    constructor();
    get providers(): Record<number, PublicClient>;
    getClientProviderByChainId(chainId: number, transportType?: TransportType): PublicClient | undefined;
    byChainId(chainId: number, transportType?: TransportType): PublicClient;
    getTransaction(chainId: number, hash: Hex): Promise<Transaction>;
    getTransactionReceipt(chainId: number, hash: Hex): Promise<TransactionReceipt>;
    getLatestBlockTimestamp(chainId: number): Promise<bigint>;
}

declare enum HolographErrorCode {
    HOLO_SDK_10000 = "HOLO_SDK_10000",
    HOLO_SDK_10001 = "HOLO_SDK_10001",
    HOLO_SDK_10002 = "HOLO_SDK_10002",
    HOLO_SDK_10003 = "HOLO_SDK_10003",
    HOLO_SDK_10004 = "HOLO_SDK_10004",
    HOLO_SDK_10005 = "HOLO_SDK_10005",
    HOLO_SDK_10006 = "HOLO_SDK_10006",
    HOLO_SDK_10007 = "HOLO_SDK_10007",
    HOLO_SDK_10008 = "HOLO_SDK_10008",
    HOLO_SDK_10009 = "HOLO_SDK_10009",
    HOLO_SDK_10010 = "HOLO_SDK_10010",
    HOLO_SDK_10011 = "HOLO_SDK_10011",
    HOLO_SDK_10012 = "HOLO_SDK_10012",
    HOLO_SDK_10013 = "HOLO_SDK_10013",
    HOLO_SDK_10014 = "HOLO_SDK_10014",
    HOLO_SDK_10015 = "HOLO_SDK_10015",
    HOLO_SDK_10016 = "HOLO_SDK_10016",
    HOLO_SDK_10017 = "HOLO_SDK_10017",
    HOLO_SDK_10018 = "HOLO_SDK_10018",
    HOLO_SDK_10019 = "HOLO_SDK_10019"
}
interface HolographErrorParams {
    name: string;
    description?: string;
    options?: {
        cause: Error;
    };
    message: string;
    code: HolographErrorCode;
    triggerFunction?: string;
}
declare abstract class HolographError extends Error {
    readonly name: string;
    readonly description?: string;
    readonly code: HolographErrorCode;
    readonly triggerFunction?: string;
    constructor(holographErrorParams: HolographErrorParams);
}

declare class HolographLogger {
    protected context: HolographLoggerContext;
    private constructor();
    generateLogPrefix(message: string): string;
    info(message: string, ...args: any[]): void;
    error(message: string, ...args: any[]): void;
    debug(message: string, ...args: any[]): void;
    log(message: string, ...args: any[]): void;
    trace(message: string, ...args: any[]): void;
    warn(message: string, ...args: any[]): void;
    logHolographError(error: HolographError): void;
    static createLogger(input: HolographLoggerContext): HolographLogger;
    static maybeAddTraceId(logger: HolographLogger): HolographLogger;
    addContext(context: HolographLoggerContext): HolographLogger;
}

/**
 * HolographAccountFactory
 *
 * @remarks
 *
 * Creates HolographAccounts.
 * A HolographAccount is a wrapper for an Externally Owned Account (EOA).
 * An account is a fundamental unit of state within the Ethereum blockchain.
 * It has a unique address, a balance of ether (ETH), and can send transactions.
 */
declare class HolographAccountFactory {
    static createAccountUsingPrivateKey(privateKey: Hex): PrivateKeyAccount;
    static createAccountUsingMnemonic(mnemonic: string, options?: HDOptions): HDAccount;
    /**
     * Create account using a provider from a browser extension wallet (e.g. Metamask).
     * https://eips.ethereum.org/EIPS/eip-1193
     * @param eip1193Provider A JavaScript Ethereum Provider API that follows the EIP-1193.
     *
     * @example
     * ```ts
     * await createAccountUsingEip1193Provider(window.ethereum)
     * ```
     */
    static createAccountUsingEip1193Provider(eip1193Provider: unknown): Promise<JsonRpcAccount>;
}
/**
 * HolographWallet
 *
 * @remarks
 *
 * Manages a HolographAccount, allowing users to interact with their account into the through the configured networks.
 *
 */
declare class HolographWallet {
    private readonly _logger;
    private _account;
    private _multiChainWalletClient;
    private _networks?;
    private _provider?;
    constructor({ account, networks, provider }: HolographWalletArgs);
    get account(): HolographAccount;
    getClient(): WalletClient & PublicActions;
    onChain(chainId: number): WalletClient & PublicActions;
    isBalanceSufficientForTx(chainId: number, gasPrice: bigint, gasLimit: bigint, value?: bigint): Promise<boolean>;
}
/**
 * HolographWalletManager
 *
 * @remarks
 *
 * Manages a set of HolographWallets.
 *
 */
declare class HolographWalletManager {
    private readonly protocolConfig;
    private readonly _logger;
    private readonly _networks;
    private _wallets;
    private _addressToAccountName;
    constructor(protocolConfig: Config);
    get allWallets(): {
        [accountName: string]: HolographWallet;
    };
    getWallet(account?: (string & keyof typeof this._wallets) | Address): HolographWallet;
    getAccountNameToAddressMap(): {
        [accountName: string]: Address;
    };
    addAccount(accountName: string, account: HolographAccount): HolographWallet;
    updateAccount(account: HolographAccount, accountName: 'default'): HolographWallet;
}

type AtLeastOne<T, U = {
    [K in keyof T]: Pick<T, K>;
}> = Partial<T> & U[keyof U];
interface CreateHolographLogger {
    serviceName: string;
    className: string;
    functionName: string;
    traceId: string;
}
type HolographLoggerContext = AtLeastOne<CreateHolographLogger>;
type BridgeInArgs = {
    readonly from: Address;
    readonly to: Address;
    readonly amount_or_tokenId: bigint | Hex;
    readonly data: Hex;
};
type BridgeInRequestArgs = {
    nonce: bigint;
    fromChain: number;
    holographableContract: Address;
    hToken: Address;
    hTokenRecipient: Address;
    hTokenFeeValue: bigint;
    doNotRevert: boolean;
    bridgeInPayload: BridgeInArgs | Hex;
};
type DecodedExecuteJobInput = {
    functionSelector: Hex;
    bridgeInRequestArgs: BridgeInRequestArgs;
    gasLimit: bigint;
    gasPrice: bigint;
};
/**
 * Enum designed to mirror the equivalent Solidity enum.
 * Reference: https://github.com/holographxyz/holograph-protocol/blob/develop/contracts/struct/DeploymentConfig.sol
 */
type DeploymentConfig = {
    readonly contractType: Hex;
    readonly chainType: string | number;
    readonly salt: Hex;
    readonly byteCode: Hex;
    readonly initCode: Hex;
};
type Signature = {
    readonly r: Hex;
    s: Hex;
    v: Hex | number;
};
type DeploymentConfigSettings = {
    readonly config: DeploymentConfig;
    readonly signature: Signature;
    readonly signer: Address;
};
type ERC721Config = {
    erc721Hash: Hex;
    erc721Config: DeploymentConfig;
    erc721ConfigHash: Hex;
    erc721ConfigHashBytes: Uint8Array;
    erc721FutureAddress: Hex;
};
type SignDeploy = {
    readonly account: Address;
    readonly config: DeploymentConfig;
    readonly signature: Signature;
    readonly chainId?: number;
    wallet?: {
        account: string | HolographWallet;
    };
};
type BridgeSettings = {
    readonly value: bigint;
    readonly gasLimit: bigint;
    readonly gasPrice: bigint;
    readonly toChain: number;
};
type DecodedEvent = {
    logIndex: string;
    values: any[];
};
type AccountsConfig = {
    default: HolographAccount;
    [accountName: string]: HolographAccount;
};
type NetworkRpc = {
    [key in NetworkKey]?: string;
};
type HolographConfig = {
    accounts?: AccountsConfig;
    environment?: Environment;
    logLevel?: string;
    networks?: NetworkRpc;
    provider?: unknown;
};
type HolographAccount = Account;
type HolographWalletArgs = {
    account: HolographAccount;
} & Pick<HolographConfig, 'networks' | 'provider'>;
type EventInfo = {
    readonly topic: string;
    readonly signature: string;
    readonly name: string;
};
type GasParameters = {
    msgBaseGas: bigint;
    msgGasPerByte: bigint;
    jobBaseGas: bigint;
    jobGasPerByte: bigint;
    minGasPrice: bigint;
    maxGasLimit: bigint;
};
declare enum HolographEventName {
    TransferERC721 = "TransferERC721",
    HolographableContractEvent = "HolographableContractEvent",
    BridgeableContractDeployed = "BridgeableContractDeployed",
    CrossChainMessageSent = "CrossChainMessageSent",
    AvailableOperatorJob = "AvailableOperatorJob",
    FinishedOperatorJob = "FinishedOperatorJob",
    LzPacket = "LzPacket"
}
/**
 * Enum designed to mirror the equivalent Solidity enum.
 * Reference: https://github.com/holographxyz/holograph-protocol/blob/develop/contracts/enum/ChainIdType.sol
 */
declare enum ChainIdType {
    UNDEFINED = 0,
    EVM = 1,
    HOLOGRAPH = 2,
    LAYERZERO = 3,
    HYPERLANE = 4
}
/**
 * Enum designed to mirror the equivalent Solidity enum.
 * Reference: https://github.com/holographxyz/holograph-protocol/blob/develop/contracts/enum/InterfaceType.sol
 */
declare enum InterfaceType {
    UNDEFINED = 0,
    ERC20 = 1,
    ERC721 = 2,
    ERC1155 = 3,
    ROYALTIES = 4,
    GENERIC = 5
}
/**
 * Enum designed to mirror the equivalent Solidity enum.
 * Reference: https://github.com/holographxyz/holograph-protocol/blob/develop/contracts/enum/TokenUriType.sol
 */
declare enum TokenUriType {
    UNDEFINED = 0,
    IPFS = 1,
    HTTPS = 2,
    ARWEAVE = 3
}
/**
 * Type designed to mirror the equivalent Solidity type.
 * Reference: https://github.com/holographxyz/holograph-protocol/blob/develop/src/struct/OperatorJob.sol
 */
type OperatorJob = {
    pod: number;
    blockTimes: number;
    operator: Address;
    startBlock: number;
    startTimestamp: bigint;
    fallbackOperators: [number, number, number, number, number];
};
declare enum HolographVersion {
    V1 = "V1",
    V2 = "V2"
}
type GasSettings = {
    gasPrice?: bigint;
    gasLimit?: bigint;
};
type GasFee = {
    gasPrice: bigint;
    gasLimit: bigint;
    gas: bigint;
};
type EstimateBridgeOutResult = {
    gasSource: {
        chainId: number;
        gasPrice: bigint;
        gasLimit: bigint;
    };
    gasDestination: {
        chainId: number;
        gasPrice: bigint;
        gasLimit: bigint;
    };
    value: bigint;
    unsignedTx: Hex;
};
type BridgeContractInput = {
    sourceChainId: number;
    contractAddress: Address;
    erc721DeploymentConfig: DeploymentConfig;
    wallet: HolographWallet;
    gasSettings?: GasSettings;
};
type BridgeNFTInput = {
    sourceChainId: number;
    destinationChainId: number;
    contractAddress: Address;
    tokenId: Hex;
    wallet: HolographWallet;
    from?: Address;
    to?: Address;
    gasSettings?: GasSettings;
};
type BridgeERC20Input = {
    sourceChainId: number;
    destinationChainId: number;
    contractAddress: Address;
    amount: bigint;
    wallet: HolographWallet;
    from?: Address;
    to?: Address;
    gasSettings?: GasSettings;
};
type ReadContractArgs<TAbi extends Abi> = {
    chainId: number;
    address: Address;
    functionName: ExtractAbiFunctionNames<TAbi>;
    args?: any[];
};
type WriteContractArgs<TAbi extends Abi> = ReadContractArgs<TAbi> & {
    wallet?: {
        account: string | HolographWallet;
    };
    options?: WriteContractOptions;
};
type EstimateContractGasArgs<TAbi extends Abi> = ReadContractArgs<TAbi> & {
    wallet?: {
        account: string | HolographWallet;
    };
    options?: EstimateContractGasOptions;
};
type SimulateContractArgs<TAbi extends Abi> = ReadContractArgs<TAbi> & {
    options?: SimulateContractOptions;
    transportType?: TransportType;
};
type GetContractFunctionArgs<TAbi extends Abi> = {
    chainId: number;
    functionName: ExtractAbiFunctionNames<TAbi>;
    wallet?: {
        account: string | HolographWallet;
    };
    args?: any[];
    options?: WriteContractOptions;
};
type CallContractFunctionArgs<TAbi extends Abi> = GetContractFunctionArgs<TAbi> & {
    address: Address;
    options?: WriteContractOptions;
};
type EstimateContractFunctionGasArgs<TAbi extends Abi> = GetContractFunctionArgs<TAbi> & {
    options?: EstimateContractGasOptions;
};
type SimulateContractFunctionArgs<TAbi extends Abi> = Omit<GetContractFunctionArgs<TAbi>, 'wallet'> & {
    options?: SimulateContractOptions;
    transportType?: TransportType;
};
type EstimateContractGasOptions = Partial<Omit<EstimateContractGasParameters, 'abi' | 'address' | 'args' | 'functionName'>>;
type WriteContractOptions = Partial<Omit<WriteContractParameters, 'abi' | 'address' | 'args' | 'client' | 'functionName'>>;
type SimulateContractOptions = Partial<Omit<SimulateContractParameters, 'abi' | 'address' | 'args' | 'functionName'>>;
type GetOpenEditionInitCodeParams = {
    account: Address;
    registryAddress: Address;
    metadataRendererAddress: Address;
    metadataRendererInitCode: Hex;
    salesConfigArray: Array<string | number | bigint>;
};
type MintConfig = {
    chainId: number;
    quantity?: number;
    wallet?: {
        account: string | HolographWallet;
    };
};
type ViemPublicClient = PublicClient<Transport, Chain | undefined>;
declare enum ContractType {
    CxipERC721 = "CxipERC721",
    HolographOpenEditionERC721V1 = "HolographOpenEditionERC721V1",
    HolographOpenEditionERC721V2 = "HolographOpenEditionERC721V2",
    CustomERC721 = "CustomERC721",
    CountdownERC721 = "CountdownERC721"
}
type TransportType = 'custom' | 'http';

declare class BridgeAsset {
    private gasSettings?;
    protected readonly _logger: HolographLogger;
    private readonly _providers;
    private readonly _bridge;
    private readonly _operator;
    constructor(gasSettings?: GasSettings | undefined, _logger?: HolographLogger);
    static createUnsignedBridgeOutTx(holographChainId: number, holographableContract: Address, gasLimit: bigint, gasPrice: bigint, bridgeOutPayload: Hex): `0x${string}`;
    protected _createBridgeOutPayload(chainId: number, holographChainId: number, contractAddress: Address, gasLimit: bigint, gasPrice: bigint, bridgeOutPayload: Hex): Promise<Hex>;
    protected _getMessageFee(chainId: number, holographChainId: number, gasLimit: bigint, gasPrice: bigint, bridgeOutPayload: Hex): Promise<bigint[]>;
    protected _getValue(chainId: number, holographToChainId: number, destinationGasLimit: bigint, destinationGasPrice: bigint, bridgeRequestPayload: Hex): Promise<bigint>;
    protected _estimateBridgeOutDestinationGas(chainId: number, destinationChainId: number, contractAddress: Address, bridgeOutPayload: Hex): Promise<{
        destinationGasPrice: bigint;
        destinationGasLimit: bigint;
    }>;
    protected _prepareBridgeOutRequest(chainId: number, destinationChainId: number, contractAddress: Address, bridgeOutPayload: Hex): Promise<EstimateBridgeOutResult>;
    protected _bridgeOut(chainId: number, destinationChainId: number, contractAddress: Address, bridgeOutPayload: Hex, wallet: HolographWallet, options?: GasSettings): Promise<Transaction>;
}

declare class BridgeContract extends BridgeAsset {
    private readonly _bridgeContractInput;
    private _initCode;
    constructor(_bridgeContractInput: BridgeContractInput);
    get sourceChainId(): number;
    get contractAddress(): `0x${string}`;
    get erc721DeploymentConfig(): DeploymentConfig;
    get account(): HolographAccount;
    static createInitCode(chainId: number, erc721DeploymentConfig: DeploymentConfig, wallet: HolographWallet): Promise<Hex>;
    getInitCode(): Promise<`0x${string}`>;
    bridgeOut(destinationChainId: number): Promise<Transaction>;
}

declare class BridgeERC20 extends BridgeAsset {
    private readonly _bridgeERC20Input;
    private _initCode;
    constructor(_bridgeERC20Input: BridgeERC20Input);
    get contractAddress(): `0x${string}`;
    get amount(): bigint;
    get from(): `0x${string}`;
    get to(): `0x${string}`;
    get destinationChainId(): number;
    get sourceChainId(): number;
    static createInitCode(from: Address, to: Address, amount: bigint): Promise<Hex>;
    getInitCode(): Promise<`0x${string}`>;
    bridgeOut(walletOverride?: HolographWallet, destinationChainId?: number): Promise<Transaction>;
}

declare class BridgeNFT extends BridgeAsset {
    private readonly _bridgeNFTInput;
    private _initCode;
    constructor(_bridgeNFTInput: BridgeNFTInput);
    get contractAddress(): `0x${string}`;
    get tokenId(): `0x${string}`;
    get from(): `0x${string}`;
    get to(): `0x${string}`;
    get destinationChainId(): number;
    get sourceChainId(): number;
    static createInitCode(from: Address, to: Address, tokenId: Hex): Promise<Hex>;
    getInitCode(): Promise<`0x${string}`>;
    bridgeOut(walletOverride?: HolographWallet, destinationChainId?: number): Promise<Transaction>;
}

declare function decodeEvent(receipt: TransactionReceipt, holographEventName: HolographEventName, target?: Address): DecodedEvent[];
declare function decodeERC721TransferEvent(receipt: TransactionReceipt, target?: Address): DecodedEvent[];
declare function decodeCrossChainMessageSentEvent(receipt: TransactionReceipt, target?: Address): DecodedEvent[];
declare function decodeAvailableOperatorJobEvent(receipt: TransactionReceipt, target?: Address): DecodedEvent[];
declare function decodeBridgeableContractDeployedEvent(receipt: TransactionReceipt, target?: Address): DecodedEvent[];
declare function decodeLzPacketEvent(receipt: TransactionReceipt, messagingModuleAddress: Address, target?: Address): DecodedEvent[];
declare function decodeBridgeInArgs(input: Hex, isErc721?: boolean): BridgeInArgs;
declare function decodeBridgeInRequestArgs(encodedBridgeInRequestArgs: Hex, isErc721?: boolean): BridgeInRequestArgs;
declare function decodeExecuteJobInput(bridgeInRequestPayload: Hex, isErc721?: boolean): DecodedExecuteJobInput;
declare function decodeDeploymentConfigInput(input: Hex): DeploymentConfigSettings;
declare function decodeDeploymentConfig(input: Hex): DeploymentConfigSettings;
declare function queryTokenIdFromReceipt(receipt: TransactionReceipt, address: Address): string | undefined;

export { BridgeContract, BridgeERC20, type BridgeInArgs, type BridgeInRequestArgs, BridgeNFT, Config, ContractType, CxipERC721Contract, type DecodedExecuteJobInput, type DeploymentConfig, type ERC721Config, FactoryContract, HolographAccountFactory, HolographBaseContract, type HolographConfig, HolographContract, HolographERC721Contract, HolographOpenEditionERC721ContractV1, HolographOpenEditionERC721ContractV2, HolographProtocol, HolographVersion, HolographWallet, InterfacesContract, LayerZeroModuleContract, NFT, OVMGasPriceOracleContract, OpenEditionERC721Contract, OpenEditionNFT, OperatorContract, type OperatorJob, Providers, RegistryContract, type SignDeploy, type Signature, TreasuryContract, decodeAvailableOperatorJobEvent, decodeBridgeInArgs, decodeBridgeInRequestArgs, decodeBridgeableContractDeployedEvent, decodeCrossChainMessageSentEvent, decodeDeploymentConfig, decodeDeploymentConfigInput, decodeERC721TransferEvent, decodeEvent, decodeExecuteJobInput, decodeLzPacketEvent, queryTokenIdFromReceipt };