@across-protocol/sdk 4.3.125 → 4.3.126-alpha.0

package/dist/esm/src/arch/svm/utils.js

@@ -1,4 +1,3 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { MessageTransmitterClient, SpokePool__factory, SvmSpokeClient } from "@across-protocol/contracts";
 import { BN, BorshEventCoder } from "@coral-xyz/anchor";
 import { address, appendTransactionMessageInstruction, createTransactionMessage, getAddressEncoder, getBase64EncodedWireTransaction, getProgramDerivedAddress, getU32Encoder, getU64Encoder, isAddress, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from "@solana/kit";
@@ -12,34 +11,20 @@ import { SVMEventNames, } from "./types";
 /**
  * Basic void TransactionSigner type
  */
-export var SolanaVoidSigner = function (simulationAddress) {
+export const SolanaVoidSigner = (simulationAddress) => {
     return {
         address: address(simulationAddress),
-        signAndSendTransactions: function () { return __awaiter(void 0, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.resolve([])];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        }); },
+        signAndSendTransactions: async () => {
+            return await Promise.resolve([]);
+        },
     };
 };
 /**
  * Helper to determine if the current RPC network is devnet.
  */
-export function isDevnet(rpc) {
-    return __awaiter(this, void 0, void 0, function () {
-        var genesisHash;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, rpc.getGenesisHash().send()];
-                case 1:
-                    genesisHash = _a.sent();
-                    return [2 /*return*/, genesisHash === "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG"];
-            }
-        });
-    });
+export async function isDevnet(rpc) {
+    const genesisHash = await rpc.getGenesisHash().send();
+    return genesisHash === "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
 }
 /**
  * Small utility to convert an Address to a Solana Kit branded type.
@@ -53,75 +38,36 @@ export function toAddress(address) {
  * @param opts An object containing a specific slot number, or a Solana commitment, defaulting to "confirmed".
  * @returns An object containing the slot number and the relevant timestamp for the block.
  */
-export function getNearestSlotTime(provider_1) {
-    return __awaiter(this, arguments, void 0, function (provider, opts, logger) {
-        var timestamp, slot, _a, maxRetries;
-        if (opts === void 0) { opts = { commitment: "confirmed" }; }
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!("slot" in opts)) return [3 /*break*/, 1];
-                    _a = opts.slot;
-                    return [3 /*break*/, 3];
-                case 1: return [4 /*yield*/, getSlot(provider, opts.commitment, logger)];
-                case 2:
-                    _a = _b.sent();
-                    _b.label = 3;
-                case 3:
-                    slot = _a;
-                    maxRetries = undefined;
-                    _b.label = 4;
-                case 4: return [4 /*yield*/, getTimestampForSlot(provider, slot, maxRetries, logger)];
-                case 5:
-                    timestamp = _b.sent();
-                    _b.label = 6;
-                case 6:
-                    if (!isDefined(timestamp) && --slot) return [3 /*break*/, 4];
-                    _b.label = 7;
-                case 7:
-                    assert(isDefined(timestamp), "Unable to resolve block time for SVM slot ".concat(slot));
-                    return [2 /*return*/, { slot: slot, timestamp: timestamp }];
-            }
-        });
-    });
+export async function getNearestSlotTime(provider, opts = { commitment: "confirmed" }, logger) {
+    let timestamp;
+    let slot = "slot" in opts ? opts.slot : await getSlot(provider, opts.commitment, logger);
+    const maxRetries = undefined; // Inherit defaults
+    do {
+        timestamp = await getTimestampForSlot(provider, slot, maxRetries, logger);
+    } while (!isDefined(timestamp) && --slot);
+    assert(isDefined(timestamp), `Unable to resolve block time for SVM slot ${slot}`);
+    return { slot, timestamp };
 }
 /**
  * Resolve the latest finalized slot, and then work backwards to find the nearest slot containing a block.
  * In most cases the first-resolved slot should also have a block. Avoid making arbitrary decisions about
  * how many slots to rotate through.
  */
-export function getLatestFinalizedSlotWithBlock(provider_1, logger_1, maxSlot_1) {
-    return __awaiter(this, arguments, void 0, function (provider, logger, maxSlot, maxLookback) {
-        var opts, finalizedSlot, endSlot, slot, block;
-        if (maxLookback === void 0) { maxLookback = 1000; }
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    opts = { maxSupportedTransactionVersion: 0, transactionDetails: "none", rewards: false };
-                    return [4 /*yield*/, getNearestSlotTime(provider, { commitment: "finalized" }, logger)];
-                case 1:
-                    finalizedSlot = (_a.sent()).slot;
-                    endSlot = biMin(maxSlot, finalizedSlot);
-                    slot = endSlot;
-                    _a.label = 2;
-                case 2: return [4 /*yield*/, provider.getBlock(slot, opts).send()];
-                case 3:
-                    block = _a.sent();
-                    if (isDefined(block) && [block.blockHeight, block.blockTime].every(isDefined)) {
-                        return [3 /*break*/, 5];
-                    }
-                    _a.label = 4;
-                case 4:
-                    if (--maxLookback > 0 && --slot > 0) return [3 /*break*/, 2];
-                    _a.label = 5;
-                case 5:
-                    if (maxLookback === 0) {
-                        throw new Error("Unable to find Solana block between slots [".concat(slot, ", ").concat(endSlot, "]"));
-                    }
-                    return [2 /*return*/, Number(slot)];
-            }
-        });
-    });
+export async function getLatestFinalizedSlotWithBlock(provider, logger, maxSlot, maxLookback = 1000) {
+    const opts = { maxSupportedTransactionVersion: 0, transactionDetails: "none", rewards: false };
+    const { slot: finalizedSlot } = await getNearestSlotTime(provider, { commitment: "finalized" }, logger);
+    const endSlot = biMin(maxSlot, finalizedSlot);
+    let slot = endSlot;
+    do {
+        const block = await provider.getBlock(slot, opts).send();
+        if (isDefined(block) && [block.blockHeight, block.blockTime].every(isDefined)) {
+            break;
+        }
+    } while (--maxLookback > 0 && --slot > 0);
+    if (maxLookback === 0) {
+        throw new Error(`Unable to find Solana block between slots [${slot}, ${endSlot}]`);
+    }
+    return Number(slot);
 }
 /**
  * Parses event data from a transaction.
@@ -137,7 +83,7 @@ export function parseEventData(eventData) {
         return new Uint8Array(eventData);
     }
     if (typeof eventData === "object") {
-        var stringTag = Object.prototype.toString.call(eventData);
+        const stringTag = Object.prototype.toString.call(eventData);
         if (stringTag.includes("PublicKey")) {
             return address(eventData.toString());
         }
@@ -145,10 +91,7 @@ export function parseEventData(eventData) {
             return BigInt(eventData.toString());
         }
         // Convert each key from snake_case to camelCase and process the value recursively.
-        return Object.fromEntries(Object.entries(eventData).map(function (_a) {
-            var key = _a[0], value = _a[1];
-            return [snakeToCamel(key), parseEventData(value)];
-        }));
+        return Object.fromEntries(Object.entries(eventData).map(([key, value]) => [snakeToCamel(key), parseEventData(value)]));
     }
     return eventData;
 }
@@ -156,9 +99,9 @@ export function parseEventData(eventData) {
  * Decodes a raw event according to a supplied IDL.
  */
 export function decodeEvent(idl, rawEvent) {
-    var event = new BorshEventCoder(idl).decode(rawEvent);
+    const event = new BorshEventCoder(idl).decode(rawEvent);
     if (!event)
-        throw new Error("Malformed rawEvent for IDL ".concat(idl.address, ": ").concat(rawEvent));
+        throw new Error(`Malformed rawEvent for IDL ${idl.address}: ${rawEvent}`);
     return {
         name: event.name,
         data: parseEventData(event.data),
@@ -168,29 +111,28 @@ export function decodeEvent(idl, rawEvent) {
  * Converts a snake_case string to camelCase.
  */
 function snakeToCamel(s) {
-    return s.replace(/(_\w)/g, function (match) { return match[1].toUpperCase(); });
+    return s.replace(/(_\w)/g, (match) => match[1].toUpperCase());
 }
 /**
  * Gets the event name from a raw name.
  */
 export function getEventName(rawName) {
-    if (Object.values(SVMEventNames).some(function (name) { return rawName.includes(name); }))
+    if (Object.values(SVMEventNames).some((name) => rawName.includes(name)))
         return rawName;
-    throw new Error("Unknown event name: ".concat(rawName));
+    throw new Error(`Unknown event name: ${rawName}`);
 }
 /**
  * Unwraps any data structure and converts Address types to strings and Uint8Array to hex or BigInt.
  * Recursively processes nested objects and arrays.
  */
-export function unwrapEventData(data, uint8ArrayKeysAsBigInt, currentKey) {
-    if (uint8ArrayKeysAsBigInt === void 0) { uint8ArrayKeysAsBigInt = ["depositId", "outputAmount", "inputAmount"]; }
+export function unwrapEventData(data, uint8ArrayKeysAsBigInt = ["depositId", "outputAmount", "inputAmount"], currentKey) {
     // Handle null/undefined
     if (data == null) {
         return data;
     }
     // Handle BigInt
     if (typeof data === "bigint") {
-        var bigIntKeysAsNumber = ["originChainId", "destinationChainId", "repaymentChainId", "chainId"];
+        const bigIntKeysAsNumber = ["originChainId", "destinationChainId", "repaymentChainId", "chainId"];
         if (currentKey && bigIntKeysAsNumber.includes(currentKey)) {
             return Number(data);
         }
@@ -198,8 +140,8 @@ export function unwrapEventData(data, uint8ArrayKeysAsBigInt, currentKey) {
     }
     // Handle Uint8Array and byte arrays
     if (data instanceof Uint8Array || isUint8Array(data)) {
-        var bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-        var hex = ethers.utils.hexlify(bytes);
+        const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+        const hex = ethers.utils.hexlify(bytes);
         if (currentKey && uint8ArrayKeysAsBigInt.includes(currentKey)) {
             return BigNumber.from(hex);
         }
@@ -207,7 +149,7 @@ export function unwrapEventData(data, uint8ArrayKeysAsBigInt, currentKey) {
     }
     // Handle regular arrays (non-byte arrays)
     if (Array.isArray(data)) {
-        return data.map(function (item) { return unwrapEventData(item, uint8ArrayKeysAsBigInt); });
+        return data.map((item) => unwrapEventData(item, uint8ArrayKeysAsBigInt));
     }
     // Handle strings (potential addresses)
     if (typeof data === "string" && isAddress(data)) {
@@ -218,7 +160,7 @@ export function unwrapEventData(data, uint8ArrayKeysAsBigInt, currentKey) {
         // Special case: if an object is in the context of the fillType key, then
         // parse out the fillType from the object
         if (currentKey === "fillType") {
-            var fillType = Object.keys(data)[0];
+            const fillType = Object.keys(data)[0];
             switch (fillType) {
                 case "FastFill":
                     return FillType.FastFill;
@@ -227,20 +169,17 @@ export function unwrapEventData(data, uint8ArrayKeysAsBigInt, currentKey) {
                 case "SlowFill":
                     return FillType.SlowFill;
                 default:
-                    throw new Error("Unknown fill type: ".concat(fillType));
+                    throw new Error(`Unknown fill type: ${fillType}`);
             }
         }
         // Special case: if an object is empty, return 0x
         if (Object.keys(data).length === 0) {
             return "0x";
         }
-        return Object.fromEntries(Object.entries(data).map(function (_a) {
-            var key = _a[0], value = _a[1];
-            return [
-                key,
-                unwrapEventData(value, uint8ArrayKeysAsBigInt, key),
-            ];
-        }));
+        return Object.fromEntries(Object.entries(data).map(([key, value]) => [
+            key,
+            unwrapEventData(value, uint8ArrayKeysAsBigInt, key),
+        ]));
     }
     // Return primitives as is
     return data;
@@ -250,24 +189,14 @@ export function unwrapEventData(data, uint8ArrayKeysAsBigInt, currentKey) {
  * @param programId The SpokePool program ID.
  * @returns The PDA for the State account.
  */
-export function getStatePda(programId) {
-    return __awaiter(this, void 0, void 0, function () {
-        var intEncoder, seed, statePda;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    intEncoder = getU64Encoder();
-                    seed = intEncoder.encode(0);
-                    return [4 /*yield*/, getProgramDerivedAddress({
-                            programAddress: programId,
-                            seeds: ["state", seed],
-                        })];
-                case 1:
-                    statePda = (_a.sent())[0];
-                    return [2 /*return*/, statePda];
-            }
-        });
+export async function getStatePda(programId) {
+    const intEncoder = getU64Encoder();
+    const seed = intEncoder.encode(0);
+    const [statePda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: ["state", seed],
     });
+    return statePda;
 }
 /**
  * Returns the fill status PDA for the given relay data.
@@ -276,26 +205,15 @@ export function getStatePda(programId) {
  * @param destinationChainId The destination chain ID.
  * @returns The PDA for the fill status.
  */
-export function getFillStatusPda(programId, relayData, destinationChainId) {
-    return __awaiter(this, void 0, void 0, function () {
-        var messageHash, relayDataHash, uint8RelayDataHash, fillStatusPda;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    messageHash = (_a = relayData.messageHash) !== null && _a !== void 0 ? _a : getMessageHash(relayData.message);
-                    relayDataHash = getRelayDataHash(__assign(__assign({}, relayData), { messageHash: messageHash }), destinationChainId);
-                    uint8RelayDataHash = new Uint8Array(Buffer.from(relayDataHash.slice(2), "hex"));
-                    return [4 /*yield*/, getProgramDerivedAddress({
-                            programAddress: programId,
-                            seeds: ["fills", uint8RelayDataHash],
-                        })];
-                case 1:
-                    fillStatusPda = (_b.sent())[0];
-                    return [2 /*return*/, fillStatusPda];
-            }
-        });
+export async function getFillStatusPda(programId, relayData, destinationChainId) {
+    const messageHash = relayData.messageHash ?? getMessageHash(relayData.message);
+    const relayDataHash = getRelayDataHash({ ...relayData, messageHash }, destinationChainId);
+    const uint8RelayDataHash = new Uint8Array(Buffer.from(relayDataHash.slice(2), "hex"));
+    const [fillStatusPda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: ["fills", uint8RelayDataHash],
     });
+    return fillStatusPda;
 }
 /**
  * Returns the PDA for a route account on SVM Spoke.
@@ -304,95 +222,55 @@ export function getFillStatusPda(programId, relayData, destinationChainId) {
  * @param routeChainId The route chain ID.
  * @returns The PDA for the route account.
  */
-export function getRoutePda(originToken, seed, routeChainId) {
-    return __awaiter(this, void 0, void 0, function () {
-        var intEncoder, addressEncoder, pda;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    intEncoder = getU64Encoder();
-                    addressEncoder = getAddressEncoder();
-                    return [4 /*yield*/, getProgramDerivedAddress({
-                            programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
-                            seeds: ["route", addressEncoder.encode(originToken), intEncoder.encode(seed), intEncoder.encode(routeChainId)],
-                        })];
-                case 1:
-                    pda = (_a.sent())[0];
-                    return [2 /*return*/, pda];
-            }
-        });
+export async function getRoutePda(originToken, seed, routeChainId) {
+    const intEncoder = getU64Encoder();
+    const addressEncoder = getAddressEncoder();
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+        seeds: ["route", addressEncoder.encode(originToken), intEncoder.encode(seed), intEncoder.encode(routeChainId)],
     });
+    return pda;
 }
 /**
  * Returns the PDA for the SVM Spoke's transfer liability account.
  * @param programId the address of the spoke pool.
  * @param originToken the address of the corresponding token.
  */
-export function getTransferLiabilityPda(programId, originToken) {
-    return __awaiter(this, void 0, void 0, function () {
-        var addressEncoder, pda;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    addressEncoder = getAddressEncoder();
-                    return [4 /*yield*/, getProgramDerivedAddress({
-                            programAddress: programId,
-                            seeds: ["transfer_liability", addressEncoder.encode(originToken)],
-                        })];
-                case 1:
-                    pda = (_a.sent())[0];
-                    return [2 /*return*/, pda];
-            }
-        });
+export async function getTransferLiabilityPda(programId, originToken) {
+    const addressEncoder = getAddressEncoder();
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: ["transfer_liability", addressEncoder.encode(originToken)],
     });
+    return pda;
 }
 /**
  * Returns the PDA for the SVM Spoke's root bundle account.
  * @param programId the address of the spoke pool.
  * @param rootBundleId the associated root bundle ID.
  */
-export function getRootBundlePda(programId, rootBundleId) {
-    return __awaiter(this, void 0, void 0, function () {
-        var seedEncoder, seed, intEncoder, pda;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    seedEncoder = getU64Encoder();
-                    seed = seedEncoder.encode(0);
-                    intEncoder = getU32Encoder();
-                    return [4 /*yield*/, getProgramDerivedAddress({
-                            programAddress: programId,
-                            seeds: ["root_bundle", seed, intEncoder.encode(rootBundleId)],
-                        })];
-                case 1:
-                    pda = (_a.sent())[0];
-                    return [2 /*return*/, pda];
-            }
-        });
+export async function getRootBundlePda(programId, rootBundleId) {
+    const seedEncoder = getU64Encoder();
+    const seed = seedEncoder.encode(0); // Default seed.
+    const intEncoder = getU32Encoder();
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: ["root_bundle", seed, intEncoder.encode(rootBundleId)],
     });
+    return pda;
 }
 /**
  * Returns the PDA for the SVM Spoke's instruction params account.
  * @param programId the address of the spoke pool.
  * @param signer the signer of the authenticated call.
  */
-export function getInstructionParamsPda(programId, signer) {
-    return __awaiter(this, void 0, void 0, function () {
-        var addressEncoder, pda;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    addressEncoder = getAddressEncoder();
-                    return [4 /*yield*/, getProgramDerivedAddress({
-                            programAddress: programId,
-                            seeds: ["instruction_params", addressEncoder.encode(signer)],
-                        })];
-                case 1:
-                    pda = (_a.sent())[0];
-                    return [2 /*return*/, pda];
-            }
-        });
+export async function getInstructionParamsPda(programId, signer) {
+    const addressEncoder = getAddressEncoder();
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: ["instruction_params", addressEncoder.encode(signer)],
     });
+    return pda;
 }
 /**
  * Returns the PDA for an individual's claim account.
@@ -400,89 +278,54 @@ export function getInstructionParamsPda(programId, signer) {
  * @param mint the address of the token.
  * @param tokenOwner the address of the signer which owns the claim account.
  */
-export function getClaimAccountPda(programId, mint, tokenOwner) {
-    return __awaiter(this, void 0, void 0, function () {
-        var addressEncoder, pda;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    addressEncoder = getAddressEncoder();
-                    return [4 /*yield*/, getProgramDerivedAddress({
-                            programAddress: programId,
-                            seeds: ["claim_account", addressEncoder.encode(mint), addressEncoder.encode(tokenOwner)],
-                        })];
-                case 1:
-                    pda = (_a.sent())[0];
-                    return [2 /*return*/, pda];
-            }
-        });
+export async function getClaimAccountPda(programId, mint, tokenOwner) {
+    const addressEncoder = getAddressEncoder();
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: ["claim_account", addressEncoder.encode(mint), addressEncoder.encode(tokenOwner)],
     });
+    return pda;
 }
 /**
  * Returns the PDA for the Event Authority.
  * @returns The PDA for the Event Authority.
  */
-export function getEventAuthority(programId) {
-    return __awaiter(this, void 0, void 0, function () {
-        var eventAuthority;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getProgramDerivedAddress({
-                        programAddress: programId,
-                        seeds: ["__event_authority"],
-                    })];
-                case 1:
-                    eventAuthority = (_a.sent())[0];
-                    return [2 /*return*/, eventAuthority];
-            }
-        });
+export async function getEventAuthority(programId) {
+    const [eventAuthority] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: ["__event_authority"],
     });
+    return eventAuthority;
 }
 /**
  * Returns the PDA for the handler signer.
  * @param programId The multicall handler program ID.
  * @returns The PDA for the State account.
  */
-export function getHandlerSignerPda(programId) {
-    return __awaiter(this, void 0, void 0, function () {
-        var handlerSignerPda;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getProgramDerivedAddress({
-                        programAddress: programId,
-                        seeds: ["handler_signer"],
-                    })];
-                case 1:
-                    handlerSignerPda = (_a.sent())[0];
-                    return [2 /*return*/, handlerSignerPda];
-            }
-        });
+export async function getHandlerSignerPda(programId) {
+    const [handlerSignerPda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: ["handler_signer"],
     });
+    return handlerSignerPda;
 }
 /**
  * Returns the PDA for the Self Authority.
  * @returns The PDA for the Self Authority.
  */
-export var getSelfAuthority = function () { return __awaiter(void 0, void 0, void 0, function () {
-    var selfAuthority;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, getProgramDerivedAddress({
-                    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
-                    seeds: ["self_authority"],
-                })];
-            case 1:
-                selfAuthority = (_a.sent())[0];
-                return [2 /*return*/, selfAuthority];
-        }
+export const getSelfAuthority = async () => {
+    const [selfAuthority] = await getProgramDerivedAddress({
+        programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+        seeds: ["self_authority"],
     });
-}); };
+    return selfAuthority;
+};
 /**
  * Returns a random SVM address.
  */
 export function getRandomSvmAddress() {
-    var bytes = ethers.utils.randomBytes(32);
-    var base58Address = bs58.encode(bytes);
+    const bytes = ethers.utils.randomBytes(32);
+    const base58Address = bs58.encode(bytes);
     return address(base58Address);
 }
 /**
@@ -491,24 +334,10 @@ export function getRandomSvmAddress() {
  * @param signer - The signer of the transaction.
  * @returns The default transaction.
  */
-export var createDefaultTransaction = function (rpcClient, signer, latestBlockhash) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                if (!isDefined(latestBlockhash)) return [3 /*break*/, 1];
-                _a = latestBlockhash;
-                return [3 /*break*/, 3];
-            case 1: return [4 /*yield*/, rpcClient.getLatestBlockhash().send()];
-            case 2:
-                _a = (_b.sent()).value;
-                _b.label = 3;
-            case 3:
-                latestBlockhash = _a;
-                return [2 /*return*/, pipe(createTransactionMessage({ version: 0 }), function (tx) { return setTransactionMessageFeePayerSigner(signer, tx); }, function (tx) { return setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx); })];
-        }
-    });
-}); };
+export const createDefaultTransaction = async (rpcClient, signer, latestBlockhash) => {
+    latestBlockhash = isDefined(latestBlockhash) ? latestBlockhash : (await rpcClient.getLatestBlockhash().send()).value;
+    return pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayerSigner(signer, tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx));
+};
 /**
  * Simulates a transaction and decodes the result using a parser function.
  * @param solanaClient - The Solana client.
@@ -517,34 +346,18 @@ export var createDefaultTransaction = function (rpcClient, signer, latestBlockha
  * @param parser - The parser function to decode the result.
  * @returns The decoded result.
  */
-export var simulateAndDecode = function (solanaClient, ix, signer, parser, latestBlockhash) { return __awaiter(void 0, void 0, void 0, function () {
-    var simulationTx, _a, _b, simulationResult, _c, _d, _e;
-    var _f;
-    return __generator(this, function (_g) {
-        switch (_g.label) {
-            case 0:
-                _a = appendTransactionMessageInstruction;
-                _b = [ix];
-                return [4 /*yield*/, createDefaultTransaction(solanaClient, signer, latestBlockhash)];
-            case 1:
-                simulationTx = _a.apply(void 0, _b.concat([_g.sent()]));
-                _d = (_c = solanaClient)
-                    .simulateTransaction;
-                _e = getBase64EncodedWireTransaction;
-                return [4 /*yield*/, signTransactionMessageWithSigners(simulationTx)];
-            case 2: return [4 /*yield*/, _d.apply(_c, [_e.apply(void 0, [_g.sent()]), {
-                        encoding: "base64",
-                    }])
-                    .send()];
-            case 3:
-                simulationResult = _g.sent();
-                if (!((_f = simulationResult.value.returnData) === null || _f === void 0 ? void 0 : _f.data[0])) {
-                    throw new Error("svm::simulateAndDecode: simulateTransaction failed. No return data.");
-                }
-                return [2 /*return*/, parser(Buffer.from(simulationResult.value.returnData.data[0], "base64"))];
-        }
-    });
-}); };
+export const simulateAndDecode = async (solanaClient, ix, signer, parser, latestBlockhash) => {
+    const simulationTx = appendTransactionMessageInstruction(ix, await createDefaultTransaction(solanaClient, signer, latestBlockhash));
+    const simulationResult = await solanaClient
+        .simulateTransaction(getBase64EncodedWireTransaction(await signTransactionMessageWithSigners(simulationTx)), {
+        encoding: "base64",
+    })
+        .send();
+    if (!simulationResult.value.returnData?.data[0]) {
+        throw new Error("svm::simulateAndDecode: simulateTransaction failed. No return data.");
+    }
+    return parser(Buffer.from(simulationResult.value.returnData.data[0], "base64"));
+};
 /**
  * Converts a common `RelayData` type to an SvmSpokeClient.RelayData` type. This is useful for when we need
  * to interface directly with the SvmSpoke.
@@ -575,34 +388,24 @@ export function toSvmRelayData(relayData) {
  * @param sourceDomain The source domain.
  * @returns The PDA for the CCTP nonce.
  */
-export var getCCTPNoncePda = function (solanaClient, signer, nonce, sourceDomain, latestBlockhash) { return __awaiter(void 0, void 0, void 0, function () {
-    var messageTransmitterPda, getNonceIx, parserFunction;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, getProgramDerivedAddress({
-                    programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
-                    seeds: ["message_transmitter"],
-                })];
-            case 1:
-                messageTransmitterPda = (_a.sent())[0];
-                return [4 /*yield*/, MessageTransmitterClient.getGetNoncePdaInstruction({
-                        messageTransmitter: messageTransmitterPda,
-                        nonce: nonce,
-                        sourceDomain: sourceDomain,
-                    })];
-            case 2:
-                getNonceIx = _a.sent();
-                parserFunction = function (buf) {
-                    if (buf.length === 32) {
-                        return address(bs58.encode(buf));
-                    }
-                    throw new Error("Invalid buffer");
-                };
-                return [4 /*yield*/, simulateAndDecode(solanaClient, getNonceIx, signer, parserFunction, latestBlockhash)];
-            case 3: return [2 /*return*/, _a.sent()];
-        }
+export const getCCTPNoncePda = async (solanaClient, signer, nonce, sourceDomain, latestBlockhash) => {
+    const [messageTransmitterPda] = await getProgramDerivedAddress({
+        programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+        seeds: ["message_transmitter"],
+    });
+    const getNonceIx = await MessageTransmitterClient.getGetNoncePdaInstruction({
+        messageTransmitter: messageTransmitterPda,
+        nonce,
+        sourceDomain: sourceDomain,
     });
-}); };
+    const parserFunction = (buf) => {
+        if (buf.length === 32) {
+            return address(bs58.encode(buf));
+        }
+        throw new Error("Invalid buffer");
+    };
+    return await simulateAndDecode(solanaClient, getNonceIx, signer, parserFunction, latestBlockhash);
+};
 /**
  * Checks if a CCTP message is a deposit for burn event.
  * @param event The CCTP message event.
@@ -614,21 +417,21 @@ export function isDepositForBurnEvent(event) {
 /**
  * True if `body` encodes a `relayRootBundle(bytes32,bytes32)` call.
  */
-export var isRelayRootBundleMessageBody = function (body) {
+export const isRelayRootBundleMessageBody = (body) => {
     if (body.length < 4)
         return false;
-    var spokePoolInterface = new ethers.utils.Interface(SpokePool__factory.abi);
-    var relayRootBundleSelector = spokePoolInterface.getSighash("relayRootBundle");
+    const spokePoolInterface = new ethers.utils.Interface(SpokePool__factory.abi);
+    const relayRootBundleSelector = spokePoolInterface.getSighash("relayRootBundle");
     return body.slice(0, 4).equals(Buffer.from(relayRootBundleSelector.slice(2), "hex"));
 };
 /**
  * True if `body` encodes a `emergencyDeleteRootBundle(uint32)` call.
  */
-export var isEmergencyDeleteRootBundleMessageBody = function (body) {
+export const isEmergencyDeleteRootBundleMessageBody = (body) => {
     if (body.length < 4)
         return false;
-    var spokePoolInterface = new ethers.utils.Interface(SpokePool__factory.abi);
-    var emergencyDeleteRootBundleSelector = spokePoolInterface.getSighash("emergencyDeleteRootBundle");
+    const spokePoolInterface = new ethers.utils.Interface(SpokePool__factory.abi);
+    const emergencyDeleteRootBundleSelector = spokePoolInterface.getSighash("emergencyDeleteRootBundle");
     return body.slice(0, 4).equals(Buffer.from(emergencyDeleteRootBundleSelector.slice(2), "hex"));
 };
 /**
@@ -636,9 +439,9 @@ export var isEmergencyDeleteRootBundleMessageBody = function (body) {
  * @param body The message body.
  * @returns The root bundle ID.
  */
-export var getEmergencyDeleteRootBundleRootBundleId = function (body) {
-    var spokePoolInterface = new ethers.utils.Interface(SpokePool__factory.abi);
-    var result = spokePoolInterface.decodeFunctionData("emergencyDeleteRootBundle", body);
+export const getEmergencyDeleteRootBundleRootBundleId = (body) => {
+    const spokePoolInterface = new ethers.utils.Interface(SpokePool__factory.abi);
+    const result = spokePoolInterface.decodeFunctionData("emergencyDeleteRootBundle", body);
     return result.rootBundleId.toNumber();
 };
 /**
@@ -650,11 +453,9 @@ export function bigintToU8a32(n) {
     if (n < BigInt(0) || n > ethers.constants.MaxUint256.toBigInt()) {
         throw new RangeError("Value must fit in 256 bits");
     }
-    var hexPadded = ethers.utils.hexZeroPad("0x" + n.toString(16), 32);
+    const hexPadded = ethers.utils.hexZeroPad("0x" + n.toString(16), 32);
     return ethers.utils.arrayify(hexPadded);
 }
-export var bigToU8a32 = function (bn) {
-    return bigintToU8a32(typeof bn === "bigint" ? bn : BigInt(bn.toString()));
-};
-export var numberToU8a32 = function (n) { return bigintToU8a32(BigInt(n)); };
+export const bigToU8a32 = (bn) => bigintToU8a32(typeof bn === "bigint" ? bn : BigInt(bn.toString()));
+export const numberToU8a32 = (n) => bigintToU8a32(BigInt(n));
 //# sourceMappingURL=utils.js.map