@argonprotocol/testing 1.4.3-dev.43df9563 → 1.4.3-dev.4544e954

package/lib/index.d.cts

@@ -1,6 +1,29 @@
-import { KeyringPair, ArgonClient } from '@argonprotocol/mainchain';
+import * as _argonprotocol_mainchain from '@argonprotocol/mainchain';
+import { KeyringPair, ArgonClient, EthereumReceipt, EthereumBeaconHeaderDetailsResponse, EthereumBeaconBlockResponse, EvmContracts, IArgonQueryable } from '@argonprotocol/mainchain';
 import { Client } from 'pg';
-import Client$1 from 'bitcoin-core';
+import * as viem from 'viem';
+import { Hex, createWalletClient, defineChain, Address, ContractFunctionArgs } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import * as _polkadot_types_codec from '@polkadot/types-codec';
+
+interface ITeardownable {
+    teardown(): Promise<void>;
+}
+declare const SKIP_E2E: boolean;
+declare function getProxy(): Promise<string>;
+declare function projectRoot(): string;
+declare function runTestScript(relativePath: string): Promise<string>;
+declare function getDockerPortMapping(containerName: string, port: number): Promise<string | undefined>;
+declare function teardown(): Promise<void>;
+declare function cleanHostForDocker(host: string, replacer?: string): string;
+declare function addTeardown(teardownable: ITeardownable): void;
+declare function runOnTeardown(teardown: () => Promise<void>): void;
+declare function closeOnTeardown<T extends {
+    close(): Promise<void>;
+}>(closeable: T): T;
+declare function disconnectOnTeardown<T extends {
+    disconnect(): Promise<void>;
+}>(closeable: T): T;
 
 declare class TestNotary implements ITeardownable {
     #private;
@@ -36,7 +59,7 @@ declare class TestMainchain implements ITeardownable {
     bitcoinPort?: number;
     get address(): string;
     constructor(binPath?: string);
-    getBitcoinClient(): Client$1;
+    getBitcoinClient(): BitcoinRpcClient;
     /**
      * Launch and return the localhost url. NOTE: this url will not work cross-docker. You need to use the containerAddress property
      * @param options
@@ -54,6 +77,48 @@ declare class TestMainchain implements ITeardownable {
     teardown(): Promise<void>;
     private startBitcoin;
 }
+declare class BitcoinRpcClient {
+    #private;
+    constructor(rpcUrl: string, username: string, password: string);
+    command<TMethod extends BitcoinRpcMethod>(method: TMethod, ...params: Parameters<BitcoinRpcMethods[TMethod]>): Promise<ReturnType<BitcoinRpcMethods[TMethod]>>;
+    command<TResult = unknown>(method: string, ...params: unknown[]): Promise<TResult>;
+}
+type BitcoinRpcMethod = keyof BitcoinRpcMethods;
+type BitcoinRpcMethods = {
+    createwallet(walletName: string): unknown;
+    loadwallet(walletName: string): unknown;
+    getnewaddress(): string;
+    generatetoaddress(blockCount: number, address: string): unknown;
+    getbalances(): unknown;
+    walletcreatefundedpsbt(inputs: unknown[], outputs: Record<string, number>, locktime: number, options: BitcoinWalletCreateFundedPsbtOptions): BitcoinFundedPsbtResult;
+    walletprocesspsbt(psbt: string): BitcoinProcessedPsbtResult;
+    decodepsbt(psbt: string): BitcoinDecodedPsbtResult;
+    finalizepsbt(psbt: string): BitcoinFinalizedPsbtResult;
+    sendrawtransaction(transactionHex: string): string;
+    getrawtransaction(txid: string, verbose: true): BitcoinRawTransactionResult;
+    gettransaction(txid: string): unknown;
+};
+type BitcoinWalletCreateFundedPsbtOptions = {
+    lockUnspents?: boolean;
+    feeRate?: number;
+};
+type BitcoinFundedPsbtResult = {
+    psbt: string;
+};
+type BitcoinProcessedPsbtResult = {
+    psbt: string;
+    complete: boolean;
+};
+type BitcoinDecodedPsbtResult = {
+    inputs?: unknown[];
+};
+type BitcoinFinalizedPsbtResult = {
+    hex: string;
+    txid?: string;
+};
+type BitcoinRawTransactionResult = {
+    txid: string;
+};
 
 declare class TestBitcoinCli {
     /**
@@ -78,6 +143,51 @@ declare class TestOracle implements ITeardownable {
     teardown(): Promise<void>;
 }
 
+interface EthereumEndpoints {
+    executionRpcUrl: string;
+    beaconApiUrl: string;
+    chainId: string;
+}
+interface EthereumMintingGatewayFixture {
+    argonTokenAddress: Hex;
+    argonotTokenAddress: Hex;
+    gatewayAddress: Hex;
+}
+interface EthereumPrefundedAccount {
+    balance: string;
+}
+type EthereumConsensusClient = 'lighthouse' | 'lodestar';
+type EthereumBeaconPreset = 'mainnet' | 'minimal';
+declare class TestEthereum implements ITeardownable {
+    #private;
+    readonly enclaveName: string;
+    readonly kurtosisBin: string;
+    readonly packageRef: string;
+    executionRpcUrl?: string;
+    beaconApiUrl?: string;
+    chainId?: string;
+    constructor(enclaveName?: string, kurtosisBin?: string, packageRef?: string);
+    static isInstalled(kurtosisBin?: string): boolean;
+    launch(options?: {
+        consensusClient?: EthereumConsensusClient;
+        preset?: EthereumBeaconPreset;
+        secondsPerSlot?: number;
+        waitForFinalization?: boolean;
+        prefundedAccounts?: Record<string, EthereumPrefundedAccount>;
+    }): Promise<EthereumEndpoints>;
+    callExecution<TResult>(method: string, params?: unknown[]): Promise<TResult>;
+    getBeacon<TResult>(path: string): Promise<TResult>;
+    deployMintingGatewayFixture(options: {
+        deployerPrivateKey: Hex;
+        adminSafe?: Hex;
+        guardianSafe?: Hex;
+        initialMicrogonsPerArgonot?: bigint;
+        seedArgonRecipient?: Hex;
+        seedArgonAmountBaseUnits?: bigint;
+    }): Promise<EthereumMintingGatewayFixture>;
+    teardown(): Promise<void>;
+}
+
 declare function startNetwork(testName: string, options?: {
     shouldLog: boolean;
     dockerEnv?: Record<string, string>;
@@ -86,30 +196,234 @@ declare function startNetwork(testName: string, options?: {
     notaryUrl: string;
 }>;
 
-interface ITeardownable {
-    teardown(): Promise<void>;
+declare function signGatewayPermit(args: {
+    account: ReturnType<typeof privateKeyToAccount>;
+    chainId: number;
+    tokenAddress: Hex;
+    gatewayAddress: Hex;
+    owner: Hex;
+    value: bigint;
+    nonce: bigint;
+    deadline: bigint;
+}): Promise<{
+    v: number;
+    r: `0x${string}`;
+    s: `0x${string}`;
+}>;
+declare function waitForFinalizedBeaconExecutionAtOrAbove(ethereum: TestEthereum, minimumExecutionBlockNumber: bigint, options?: {
+    minimumFinalizedSlot?: bigint;
+}): Promise<{
+    header: EthereumBeaconHeaderDetailsResponse;
+    block: EthereumBeaconBlockResponse;
+}>;
+declare function mineLaterExecutionAnchorReceipt(walletClient: Pick<ReturnType<typeof createWalletClient>, 'sendTransaction'>, chain: ReturnType<typeof defineChain>, ethereum: TestEthereum, account: ReturnType<typeof privateKeyToAccount>, minimumBlockNumber: bigint): Promise<viem.TransactionReceipt>;
+declare function waitForExecutionReceipt(ethereum: TestEthereum, transactionHash: Hex): Promise<EthereumReceipt>;
+declare function syncEthereumVerifierUntilAnchorCovers(mainchainClient: ArgonClient, relayer: KeyringPair, beaconApiUrl: string, minimumExecutionBlockNumber: bigint): Promise<void>;
+declare function toArgonKeccakSignature(signature: Hex): Hex;
+declare function toEvmRecoverableSignature(signature: Hex): Hex;
+
+type ApplyGatewayUpdatesArgs = ContractFunctionArgs<typeof EvmContracts.mintingGatewayAbi, 'nonpayable', 'applyGatewayUpdates'>;
+type MintingGatewayCouncilSnapshot = ApplyGatewayUpdatesArgs[0];
+type MintingGatewayGatewayUpdate = ApplyGatewayUpdatesArgs[1][number];
+type EthereumGatewayUpdateBatch = {
+    destinationChain: 'Ethereum';
+    chainId: bigint;
+    gatewayAddress: Address;
+    currentCouncilHash: Hex;
+    currentCouncil: MintingGatewayCouncilSnapshot;
+    argonApprovalsNonce: bigint;
+    argonApprovalsHash: Hex;
+    paused: boolean;
+    pendingClearOutQueueNonces: bigint[];
+    firstQueueNonce?: bigint;
+    lastQueueNonce?: bigint;
+    updates: MintingGatewayGatewayUpdate[];
+};
+declare function getReadyEthereumGatewayUpdates(client: IArgonQueryable, gatewayClient: {
+    readContract: (...args: any[]) => Promise<unknown>;
+}, options?: {
+    destinationChain?: 'Ethereum';
+    maxQueueEntries?: number;
+}): Promise<EthereumGatewayUpdateBatch>;
+
+type DeployerAccount = ReturnType<typeof privateKeyToAccount>;
+type EthereumChain = ReturnType<typeof defineChain>;
+type EthereumPublicClient = {
+    getBalance: (args: {
+        address: Hex;
+    }) => Promise<bigint>;
+    getBlock: (...args: any[]) => Promise<any>;
+    getBlockNumber: () => Promise<bigint>;
+    readContract: (...args: any[]) => Promise<unknown>;
+    waitForTransactionReceipt: (args: {
+        hash: Hex;
+    }) => Promise<{
+        status: string;
+        blockNumber: bigint;
+    }>;
+};
+type EthereumWalletClient = {
+    sendTransaction: (...args: any[]) => Promise<Hex>;
+    writeContract: (...args: any[]) => Promise<Hex>;
+};
+type GatewayDeployment = Awaited<ReturnType<TestEthereum['deployMintingGatewayFixture']>>;
+type RuntimeSetupMode = {
+    kind: 'inbound-only';
+} | {
+    kind: 'outbound';
+    activationPricing: {
+        activationGasCost: bigint | number;
+        signatureGasCost: bigint | number;
+        estimatedWeiPerGas: bigint | number;
+        estimatedMicrogonsPerEth: bigint | number;
+    };
+    minimumMintingAuthorityValue?: bigint;
+};
+declare class EthereumProofE2eHarness {
+    readonly ethereum: TestEthereum;
+    readonly endpoints: Awaited<ReturnType<TestEthereum['launch']>>;
+    readonly mainchain: TestMainchain;
+    readonly sudoSigner: KeyringPair;
+    readonly deployer: DeployerAccount;
+    readonly chain: EthereumChain;
+    readonly publicClient: EthereumPublicClient;
+    readonly walletClient: EthereumWalletClient;
+    readonly mainchainClient: ArgonClient;
+    readonly proofRelayer: KeyringPair;
+    private constructor();
+    static launch(args: {
+        testAccount: {
+            address: Hex;
+            balance: string;
+            privateKey: Hex;
+        };
+        proofRelayerUri: string;
+    }): Promise<EthereumProofE2eHarness>;
+    submit(tx: unknown, signer: KeyringPair): Promise<_argonprotocol_mainchain.TxResult>;
+    sudoSubmit(tx: unknown): Promise<_argonprotocol_mainchain.TxResult>;
+    syncVerifierThrough(minimumExecutionBlockNumber: bigint): Promise<void>;
+    proveGatewayActivity(gatewayAddress: Hex, throughExecutionBlockNumber: bigint): Promise<{
+        payload: _argonprotocol_mainchain.EthereumGatewayActivityProofPayload;
+        result: _argonprotocol_mainchain.TxResult;
+    }>;
+    configureEthereumRuntime(gateway: TestMintingGateway, mode: RuntimeSetupMode): Promise<{
+        result: _argonprotocol_mainchain.TxResult;
+    }>;
+    fundBurnAccount(amount: bigint): Promise<_argonprotocol_mainchain.TxResult>;
+    fundProofRelayer(amount?: bigint): Promise<_argonprotocol_mainchain.TxResult>;
+    forceSetBalance(address: string, amount: bigint): Promise<_argonprotocol_mainchain.TxResult>;
+    forceSetOwnership(address: string, amount: bigint): Promise<_argonprotocol_mainchain.TxResult>;
+    waitForExecutionFinalizedAfter(minimumExecutionBlockNumber: bigint): Promise<viem.TransactionReceipt>;
 }
-declare const SKIP_E2E: boolean;
-declare function getProxy(): Promise<string>;
+declare class TestMintingGateway {
+    readonly harness: EthereumProofE2eHarness;
+    readonly deployment: GatewayDeployment;
+    private constructor();
+    static deploy(harness: EthereumProofE2eHarness, options: Parameters<TestEthereum['deployMintingGatewayFixture']>[0]): Promise<TestMintingGateway>;
+    get gatewayAddress(): `0x${string}`;
+    get argonTokenAddress(): `0x${string}`;
+    get argonotTokenAddress(): `0x${string}`;
+    startTransferToArgon(args: {
+        account: DeployerAccount;
+        amountRuntimeUnits: bigint;
+        recipientArgonAddress: Hex;
+    }): Promise<viem.TransactionReceipt>;
+    forceUpdateActiveCouncil(replacementCouncil: {
+        signers: Hex[];
+        weights: bigint[];
+    }, nextMicrogonsPerArgonot: bigint): Promise<{
+        status: string;
+        blockNumber: bigint;
+    }>;
+    relayReadyApprovals(batch: Awaited<ReturnType<typeof getReadyEthereumGatewayUpdates>>, operatorAddress: string): Promise<{
+        status: string;
+        blockNumber: bigint;
+    }>;
+    argonApprovalsNonce(): Promise<bigint>;
+    globalIssuanceCouncil(): Promise<[Hex[], bigint[], Hex]>;
+    authorityCollateral(signingKey: Hex): Promise<[bigint, bigint]>;
+    finalizeTransferOut(args: {
+        transferRequest: {
+            argonAccountId: Hex;
+            argonTransferNonce: bigint;
+            chainId: bigint;
+            microgonsPerArgonot: bigint;
+            recipient: Hex;
+            validUntilBlock: bigint;
+            token: Hex;
+            amount: bigint;
+            mintingAuthorityTip: bigint;
+        };
+        collateralizationSignature: Hex;
+        micronotCollateral: bigint;
+    }): Promise<{
+        status: string;
+        blockNumber: bigint;
+    }>;
+    isFinalizedTransferOut(transferRequest: Parameters<typeof EvmContracts.hashMintingGatewayTransferOutOfArgonRequest>[0]): Promise<boolean>;
+    argonBalance(address: Hex): Promise<bigint>;
+    fundExecutionAccount(address: Hex, value: bigint): Promise<{
+        status: string;
+        blockNumber: bigint;
+    }>;
+}
+declare class TestMintingAuthorityActor {
+    readonly harness: EthereumProofE2eHarness;
+    readonly operator: KeyringPair;
+    readonly councilSigner: DeployerAccount;
+    readonly authoritySigner: DeployerAccount;
+    private gateway?;
+    constructor(harness: EthereumProofE2eHarness, args: {
+        operatorUri: string;
+        councilPrivateKey: Hex;
+        authorityPrivateKey: Hex;
+    });
+    attachGateway(gateway: TestMintingGateway): void;
+    prepareOperator(args: {
+        freeBalance: bigint;
+        ownershipBalance: bigint;
+        committedArgonots: bigint;
+        bitcoinXpub: string;
+    }): Promise<void>;
+    registerCouncilSigner(): Promise<_argonprotocol_mainchain.TxResult>;
+    forceSingleMemberCouncil(): Promise<{
+        activeCouncilHash: `0x${string}`;
+        activeCouncil: _argonprotocol_mainchain.PalletCrosschainTransferGlobalIssuanceCouncil;
+        currentCouncil: {
+            signers: `0x${string}`[];
+            weights: bigint[];
+        };
+    }>;
+    registerMintingAuthority(micronotCollateral: bigint): Promise<_argonprotocol_mainchain.TxResult>;
+    approveActivationQueueEntry(queueNonce?: bigint): Promise<{
+        approvalQueueEntry: _polkadot_types_codec.Option<_argonprotocol_mainchain.PalletCrosschainTransferCouncilApprovalQueueEntry>;
+        councilApprovalSignature: `0x${string}`;
+        batch: EthereumGatewayUpdateBatch;
+    }>;
+    collateralizeFirstPendingTransferOut(): Promise<{
+        pendingRequest: _argonprotocol_mainchain.PalletCrosschainTransferTransferOutPendingCollateralizationRequest;
+        transferId: `0x${string}`;
+        transferRequest: {
+            argonAccountId: `0x${string}`;
+            argonTransferNonce: bigint;
+            chainId: bigint;
+            microgonsPerArgonot: bigint;
+            recipient: `0x${string}`;
+            validUntilBlock: bigint;
+            token: `0x${string}`;
+            amount: bigint;
+            mintingAuthorityTip: bigint;
+        };
+        micronotCollateral: bigint;
+        collateralizationSignature: `0x${string}`;
+        result: _argonprotocol_mainchain.TxResult;
+    }>;
+    private registrationMessage;
+    private requireGateway;
+}
+
 declare function stringifyExt(obj: any): any;
-declare function projectRoot(): string;
-/**
- * Run a script from the project "scripts" folder
- * @param relativePath
- */
-declare function runTestScript(relativePath: string): Promise<string>;
-declare function getDockerPortMapping(containerName: string, port: number): Promise<string | undefined>;
-declare function teardown(): Promise<void>;
-declare function cleanHostForDocker(host: string, replacer?: string): string;
-declare function addTeardown(teardownable: ITeardownable): void;
-declare function runOnTeardown(teardown: () => Promise<void>): void;
-declare function closeOnTeardown<T extends {
-    close(): Promise<void>;
-}>(closeable: T): T;
-declare function disconnectOnTeardown<T extends {
-    disconnect(): Promise<void>;
-}>(closeable: T): T;
 declare function sudo(): KeyringPair;
 declare function activateNotary(sudo: KeyringPair, client: ArgonClient, notary: TestNotary): Promise<void>;
 
-export { type ITeardownable, SKIP_E2E, TestBitcoinCli, TestMainchain, TestNotary, TestOracle, activateNotary, addTeardown, cleanHostForDocker, closeOnTeardown, disconnectOnTeardown, getDockerPortMapping, getProxy, projectRoot, runOnTeardown, runTestScript, startNetwork, stringifyExt, sudo, teardown };
+export { type EthereumGatewayUpdateBatch, EthereumProofE2eHarness, type ITeardownable, SKIP_E2E, TestBitcoinCli, TestEthereum, TestMainchain, TestMintingAuthorityActor, TestMintingGateway, TestNotary, TestOracle, activateNotary, addTeardown, cleanHostForDocker, closeOnTeardown, disconnectOnTeardown, getDockerPortMapping, getProxy, getReadyEthereumGatewayUpdates, mineLaterExecutionAnchorReceipt, projectRoot, runOnTeardown, runTestScript, signGatewayPermit, startNetwork, stringifyExt, sudo, syncEthereumVerifierUntilAnchorCovers, teardown, toArgonKeccakSignature, toEvmRecoverableSignature, waitForExecutionReceipt, waitForFinalizedBeaconExecutionAtOrAbove };