refactor(experimental): the default transaction confirmation strategy (#1687)

# Summary

This PR installs the conventional web3.js transaction confirmation strategy implementations. People who don't wish to customize them can create a confirmer according to the defaults, and can use it to confirm transactions.

# Test Plan

```
cd packages/library
pnpm test:unit:browser
pnpm test:unit:node
```

Also, this integration test! ([link](https://gist.github.com/steveluscher/9244301b2f7fa3a1bd04308bfb0f0855))

```js
const {
    createSolanaRpc,
    createSolanaRpcSubscriptions,
    createDefaultRpcTransport,
    createDefaultRpcSubscriptionsTransport,
    createDefaultTransactionConfirmer,
    generateKeyPair,
    getAddressFromPublicKey,
} = require('@solana/web3.js');
const { lamports } = require('@solana/rpc-core');

function synthesizeTransactionFromAirdrop(publicKey, signature) {
    return {
        feePayer: publicKey,
        lifetimeConstraint: {
            lastValidBlockHeight: 18446744073709551615n,
        },
        signatures: {
            [publicKey]: signature,
        },
    }
}

const COMMITMENT_LEVEL = 'finalized';
const LAMPORTS_TO_REQUEST = lamports(10000000n)

// Configure your RPC.
const rpc = createSolanaRpc({ transport: createDefaultRpcTransport({ url: 'http://127.0.0.1:8899' }) });
const rpcSubscriptions = createSolanaRpcSubscriptions({
    transport: createDefaultRpcSubscriptionsTransport({ url: 'ws://127.0.0.1:8900' }),
});

// Create a reusable transaction confirmer.
const confirmTransaction = createDefaultTransactionConfirmer({ rpc, rpcSubscriptions });

// Create an account.
console.log('Creating an account');
const keypair = await generateKeyPair();
const address = await getAddressFromPublicKey(keypair.publicKey);
console.log('Created an account with address', address)

// Request an airdrop.
console.log('Requesting an airdrop of', LAMPORTS_TO_REQUEST, 'lamports')
const signature = await rpc.requestAirdrop(address, LAMPORTS_TO_REQUEST).send();
console.log('Airdrop has signature', signature)

// Confirm transaction.
console.log('Confirming transaction with signature', signature, 'at', COMMITMENT_LEVEL, 'commitment');
await confirmTransaction({
    abortSignal: new AbortController().signal,
    commitment: COMMITMENT_LEVEL,
    transaction: synthesizeTransactionFromAirdrop(address, signature),
});
console.log('Confirmed!');

// Double check balance.
console.log('Getting balance of', address)
const {value} = await rpc.getBalance(address, {commitment: COMMITMENT_LEVEL}).send()
console.log('Balance is now', value);
```

Author: steveluscher

packages/library/src/transaction-confirmation.ts

@@ -1,4 +1,10 @@
 import type { Commitment } from '@solana/rpc-core';
+import type { GetAccountInfoApi } from '@solana/rpc-core/dist/types/rpc-methods/getAccountInfo';
+import type { GetSignatureStatusesApi } from '@solana/rpc-core/dist/types/rpc-methods/getSignatureStatuses';
+import type { AccountNotificationsApi } from '@solana/rpc-core/dist/types/rpc-subscriptions/account-notifications';
+import type { SignatureNotificationsApi } from '@solana/rpc-core/dist/types/rpc-subscriptions/signature-notifications';
+import type { SlotNotificationsApi } from '@solana/rpc-core/dist/types/rpc-subscriptions/slot-notifications';
+import type { Rpc, RpcSubscriptions } from '@solana/rpc-transport/dist/types/json-rpc-types';
 import {
     getSignatureFromTransaction,
     IDurableNonceTransaction,
@@ -18,6 +24,16 @@ interface BaseConfig {
     transaction: ITransactionWithFeePayer & ITransactionWithSignatures;
 }
 
+interface DefaultDurableNonceTransactionConfirmerConfig {
+    rpc: Rpc<GetSignatureStatusesApi & GetAccountInfoApi>;
+    rpcSubscriptions: RpcSubscriptions<AccountNotificationsApi & SignatureNotificationsApi>;
+}
+
+interface DefaultTransactionConfirmerConfig {
+    rpc: Rpc<GetSignatureStatusesApi>;
+    rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi>;
+}
+
 interface WaitForTransactionWithBlockhashLifetimeConfirmationConfig extends BaseConfig {
     getBlockHeightExceedencePromise: ReturnType<typeof createBlockHeightExceedencePromiseFactory>;
     transaction: ITransactionWithFeePayer & ITransactionWithSignatures & ITransactionWithBlockhashLifetime;
@@ -58,6 +74,43 @@ async function raceStrategies<TConfig extends BaseConfig>(
     }
 }
 
+export function createDefaultDurableNonceTransactionConfirmer({
+    rpc,
+    rpcSubscriptions,
+}: DefaultDurableNonceTransactionConfirmerConfig) {
+    const getNonceInvalidationPromise = createNonceInvalidationPromiseFactory(rpc, rpcSubscriptions);
+    const getSignatureConfirmationPromise = createSignatureConfirmationPromiseFactory(rpc, rpcSubscriptions);
+    return async function confirmTransaction(
+        config: Omit<
+            Parameters<typeof waitForDurableNonceTransactionConfirmation>[0],
+            'getNonceInvalidationPromise' | 'getSignatureConfirmationPromise'
+        >
+    ) {
+        await waitForDurableNonceTransactionConfirmation({
+            ...config,
+            getNonceInvalidationPromise,
+            getSignatureConfirmationPromise,
+        });
+    };
+}
+
+export function createDefaultTransactionConfirmer({ rpc, rpcSubscriptions }: DefaultTransactionConfirmerConfig) {
+    const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory(rpcSubscriptions);
+    const getSignatureConfirmationPromise = createSignatureConfirmationPromiseFactory(rpc, rpcSubscriptions);
+    return async function confirmTransaction(
+        config: Omit<
+            Parameters<typeof waitForTransactionConfirmation>[0],
+            'getBlockHeightExceedencePromise' | 'getSignatureConfirmationPromise'
+        >
+    ) {
+        await waitForTransactionConfirmation({
+            ...config,
+            getBlockHeightExceedencePromise,
+            getSignatureConfirmationPromise,
+        });
+    };
+}
+
 export async function waitForDurableNonceTransactionConfirmation(
     config: WaitForDurableNonceTransactionConfirmationConfig
 ): Promise<void> {