@debridge-finance/solana-utils 4.4.2 → 4.5.0

package/dist/browser/index.js

@@ -1,4 +1,4 @@
-import { VersionedTransaction, Transaction, Keypair, MessageV0, PublicKey, TransactionInstruction, SystemProgram } from '@solana/web3.js';
+import { MessageV0, VersionedTransaction, Transaction, PublicKey, TransactionInstruction, SystemProgram, Keypair } from '@solana/web3.js';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -6544,30 +6544,6 @@ function sleep(milliSeconds) {
         });
     });
 }
-/**
- * Serializes transaction and returns serialized size
- * @param transaction tx to get length
- * @param feePayer optional fee payer
- * @returns transaction size
- */
-function getTransactionSize(tx) {
-    try {
-        if (isVersionedTx(tx)) {
-            const txCopy = new VersionedTransaction(tx.message);
-            txCopy.message.recentBlockhash = FAKE_BLOCKHASH;
-            return txCopy.serialize().length;
-        }
-        else {
-            const txCopy = new Transaction(tx);
-            txCopy.feePayer = Keypair.generate().publicKey;
-            txCopy.recentBlockhash = FAKE_BLOCKHASH;
-            return tx.serialize({ verifySignatures: false }).length;
-        }
-    }
-    catch (e) {
-        return null;
-    }
-}
 function isVersionedTx(arg) {
     return "version" in arg;
 }
@@ -6736,7 +6712,6 @@ var helpers = /*#__PURE__*/Object.freeze({
 	hexToBuffer: hexToBuffer,
 	bufferToHex: bufferToHex,
 	sleep: sleep,
-	getTransactionSize: getTransactionSize,
 	Wallet: Wallet,
 	sendAll: sendAll
 });
@@ -6954,6 +6929,15 @@ function hashDebridgeId(nativeChainId, nativeTokenAddress) {
     return bridgeId;
 }
 function hashExternalCallBytes(data) {
+    if (data === undefined || (data === null || data === void 0 ? void 0 : data.length) === 0) {
+        // precomputed "empty" hash
+        return buffer.Buffer.from([
+            197, 210, 70, 1, 134, 247, 35, 60,
+            146, 126, 125, 178, 220, 199, 3, 192,
+            229, 0, 182, 83, 202, 130, 39, 59,
+            123, 250, 216, 4, 93, 133, 164, 112
+        ]);
+    }
     return hexToBuffer(solidityKeccak256(["bytes"], [data ? data : buffer.Buffer.from([])]), 32);
 }
 /**
@@ -7028,6 +7012,390 @@ var crypto = /*#__PURE__*/Object.freeze({
 	hashSubmissionIdRaw: hashSubmissionIdRaw
 });
 
+var microMemoize = {exports: {}};
+
+(function (module, exports) {
+	(function (global, factory) {
+	    module.exports = factory() ;
+	})(commonjsGlobal, (function () {
+	    /**
+	     * @constant DEFAULT_OPTIONS_KEYS the default options keys
+	     */
+	    var DEFAULT_OPTIONS_KEYS = {
+	        isEqual: true,
+	        isMatchingKey: true,
+	        isPromise: true,
+	        maxSize: true,
+	        onCacheAdd: true,
+	        onCacheChange: true,
+	        onCacheHit: true,
+	        transformKey: true,
+	    };
+	    /**
+	     * @function slice
+	     *
+	     * @description
+	     * slice.call() pre-bound
+	     */
+	    var slice = Array.prototype.slice;
+	    /**
+	     * @function cloneArray
+	     *
+	     * @description
+	     * clone the array-like object and return the new array
+	     *
+	     * @param arrayLike the array-like object to clone
+	     * @returns the clone as an array
+	     */
+	    function cloneArray(arrayLike) {
+	        var length = arrayLike.length;
+	        if (!length) {
+	            return [];
+	        }
+	        if (length === 1) {
+	            return [arrayLike[0]];
+	        }
+	        if (length === 2) {
+	            return [arrayLike[0], arrayLike[1]];
+	        }
+	        if (length === 3) {
+	            return [arrayLike[0], arrayLike[1], arrayLike[2]];
+	        }
+	        return slice.call(arrayLike, 0);
+	    }
+	    /**
+	     * @function getCustomOptions
+	     *
+	     * @description
+	     * get the custom options on the object passed
+	     *
+	     * @param options the memoization options passed
+	     * @returns the custom options passed
+	     */
+	    function getCustomOptions(options) {
+	        var customOptions = {};
+	        /* eslint-disable no-restricted-syntax */
+	        for (var key in options) {
+	            if (!DEFAULT_OPTIONS_KEYS[key]) {
+	                customOptions[key] = options[key];
+	            }
+	        }
+	        /* eslint-enable */
+	        return customOptions;
+	    }
+	    /**
+	     * @function isMemoized
+	     *
+	     * @description
+	     * is the function passed already memoized
+	     *
+	     * @param fn the function to test
+	     * @returns is the function already memoized
+	     */
+	    function isMemoized(fn) {
+	        return typeof fn === 'function' && fn.isMemoized;
+	    }
+	    /**
+	     * @function isSameValueZero
+	     *
+	     * @description
+	     * are the objects equal based on SameValueZero equality
+	     *
+	     * @param object1 the first object to compare
+	     * @param object2 the second object to compare
+	     * @returns are the two objects equal
+	     */
+	    function isSameValueZero(object1, object2) {
+	        // eslint-disable-next-line no-self-compare
+	        return object1 === object2 || (object1 !== object1 && object2 !== object2);
+	    }
+	    /**
+	     * @function mergeOptions
+	     *
+	     * @description
+	     * merge the options into the target
+	     *
+	     * @param existingOptions the options provided
+	     * @param newOptions the options to include
+	     * @returns the merged options
+	     */
+	    function mergeOptions(existingOptions, newOptions) {
+	        var target = {};
+	        /* eslint-disable no-restricted-syntax */
+	        for (var key in existingOptions) {
+	            target[key] = existingOptions[key];
+	        }
+	        for (var key in newOptions) {
+	            target[key] = newOptions[key];
+	        }
+	        /* eslint-enable */
+	        return target;
+	    }
+
+	    // utils
+	    var Cache = /** @class */ (function () {
+	        function Cache(options) {
+	            this.keys = [];
+	            this.values = [];
+	            this.options = options;
+	            var isMatchingKeyFunction = typeof options.isMatchingKey === 'function';
+	            if (isMatchingKeyFunction) {
+	                this.getKeyIndex = this._getKeyIndexFromMatchingKey;
+	            }
+	            else if (options.maxSize > 1) {
+	                this.getKeyIndex = this._getKeyIndexForMany;
+	            }
+	            else {
+	                this.getKeyIndex = this._getKeyIndexForSingle;
+	            }
+	            this.canTransformKey = typeof options.transformKey === 'function';
+	            this.shouldCloneArguments = this.canTransformKey || isMatchingKeyFunction;
+	            this.shouldUpdateOnAdd = typeof options.onCacheAdd === 'function';
+	            this.shouldUpdateOnChange = typeof options.onCacheChange === 'function';
+	            this.shouldUpdateOnHit = typeof options.onCacheHit === 'function';
+	        }
+	        Object.defineProperty(Cache.prototype, "size", {
+	            /**
+	             * The number of cached [key,value] results.
+	             */
+	            get: function () {
+	                return this.keys.length;
+	            },
+	            enumerable: false,
+	            configurable: true
+	        });
+	        Object.defineProperty(Cache.prototype, "snapshot", {
+	            /**
+	             * A copy of the cache at a moment in time. This is useful
+	             * to compare changes over time, since the cache mutates
+	             * internally for performance reasons.
+	             */
+	            get: function () {
+	                return {
+	                    keys: cloneArray(this.keys),
+	                    size: this.size,
+	                    values: cloneArray(this.values),
+	                };
+	            },
+	            enumerable: false,
+	            configurable: true
+	        });
+	        /**
+	         * Gets the matching key index when a custom key matcher is used.
+	         */
+	        Cache.prototype._getKeyIndexFromMatchingKey = function (keyToMatch) {
+	            var _a = this.options, isMatchingKey = _a.isMatchingKey, maxSize = _a.maxSize;
+	            var keys = this.keys;
+	            var keysLength = keys.length;
+	            if (!keysLength) {
+	                return -1;
+	            }
+	            if (isMatchingKey(keys[0], keyToMatch)) {
+	                return 0;
+	            }
+	            if (maxSize > 1) {
+	                for (var index = 1; index < keysLength; index++) {
+	                    if (isMatchingKey(keys[index], keyToMatch)) {
+	                        return index;
+	                    }
+	                }
+	            }
+	            return -1;
+	        };
+	        /**
+	         * Gets the matching key index when multiple keys are used.
+	         */
+	        Cache.prototype._getKeyIndexForMany = function (keyToMatch) {
+	            var isEqual = this.options.isEqual;
+	            var keys = this.keys;
+	            var keysLength = keys.length;
+	            if (!keysLength) {
+	                return -1;
+	            }
+	            if (keysLength === 1) {
+	                return this._getKeyIndexForSingle(keyToMatch);
+	            }
+	            var keyLength = keyToMatch.length;
+	            var existingKey;
+	            var argIndex;
+	            if (keyLength > 1) {
+	                for (var index = 0; index < keysLength; index++) {
+	                    existingKey = keys[index];
+	                    if (existingKey.length === keyLength) {
+	                        argIndex = 0;
+	                        for (; argIndex < keyLength; argIndex++) {
+	                            if (!isEqual(existingKey[argIndex], keyToMatch[argIndex])) {
+	                                break;
+	                            }
+	                        }
+	                        if (argIndex === keyLength) {
+	                            return index;
+	                        }
+	                    }
+	                }
+	            }
+	            else {
+	                for (var index = 0; index < keysLength; index++) {
+	                    existingKey = keys[index];
+	                    if (existingKey.length === keyLength &&
+	                        isEqual(existingKey[0], keyToMatch[0])) {
+	                        return index;
+	                    }
+	                }
+	            }
+	            return -1;
+	        };
+	        /**
+	         * Gets the matching key index when a single key is used.
+	         */
+	        Cache.prototype._getKeyIndexForSingle = function (keyToMatch) {
+	            var keys = this.keys;
+	            if (!keys.length) {
+	                return -1;
+	            }
+	            var existingKey = keys[0];
+	            var length = existingKey.length;
+	            if (keyToMatch.length !== length) {
+	                return -1;
+	            }
+	            var isEqual = this.options.isEqual;
+	            if (length > 1) {
+	                for (var index = 0; index < length; index++) {
+	                    if (!isEqual(existingKey[index], keyToMatch[index])) {
+	                        return -1;
+	                    }
+	                }
+	                return 0;
+	            }
+	            return isEqual(existingKey[0], keyToMatch[0]) ? 0 : -1;
+	        };
+	        /**
+	         * Order the array based on a Least-Recently-Used basis.
+	         */
+	        Cache.prototype.orderByLru = function (key, value, startingIndex) {
+	            var keys = this.keys;
+	            var values = this.values;
+	            var currentLength = keys.length;
+	            var index = startingIndex;
+	            while (index--) {
+	                keys[index + 1] = keys[index];
+	                values[index + 1] = values[index];
+	            }
+	            keys[0] = key;
+	            values[0] = value;
+	            var maxSize = this.options.maxSize;
+	            if (currentLength === maxSize && startingIndex === currentLength) {
+	                keys.pop();
+	                values.pop();
+	            }
+	            else if (startingIndex >= maxSize) {
+	                // eslint-disable-next-line no-multi-assign
+	                keys.length = values.length = maxSize;
+	            }
+	        };
+	        /**
+	         * Update the promise method to auto-remove from cache if rejected, and
+	         * if resolved then fire cache hit / changed.
+	         */
+	        Cache.prototype.updateAsyncCache = function (memoized) {
+	            var _this = this;
+	            var _a = this.options, onCacheChange = _a.onCacheChange, onCacheHit = _a.onCacheHit;
+	            var firstKey = this.keys[0];
+	            var firstValue = this.values[0];
+	            this.values[0] = firstValue.then(function (value) {
+	                if (_this.shouldUpdateOnHit) {
+	                    onCacheHit(_this, _this.options, memoized);
+	                }
+	                if (_this.shouldUpdateOnChange) {
+	                    onCacheChange(_this, _this.options, memoized);
+	                }
+	                return value;
+	            }, function (error) {
+	                var keyIndex = _this.getKeyIndex(firstKey);
+	                if (keyIndex !== -1) {
+	                    _this.keys.splice(keyIndex, 1);
+	                    _this.values.splice(keyIndex, 1);
+	                }
+	                throw error;
+	            });
+	        };
+	        return Cache;
+	    }());
+
+	    function createMemoizedFunction(fn, options) {
+	        if (options === void 0) { options = {}; }
+	        if (isMemoized(fn)) {
+	            return createMemoizedFunction(fn.fn, mergeOptions(fn.options, options));
+	        }
+	        if (typeof fn !== 'function') {
+	            throw new TypeError('You must pass a function to `memoize`.');
+	        }
+	        var _a = options.isEqual, isEqual = _a === void 0 ? isSameValueZero : _a, isMatchingKey = options.isMatchingKey, _b = options.isPromise, isPromise = _b === void 0 ? false : _b, _c = options.maxSize, maxSize = _c === void 0 ? 1 : _c, onCacheAdd = options.onCacheAdd, onCacheChange = options.onCacheChange, onCacheHit = options.onCacheHit, transformKey = options.transformKey;
+	        var normalizedOptions = mergeOptions({
+	            isEqual: isEqual,
+	            isMatchingKey: isMatchingKey,
+	            isPromise: isPromise,
+	            maxSize: maxSize,
+	            onCacheAdd: onCacheAdd,
+	            onCacheChange: onCacheChange,
+	            onCacheHit: onCacheHit,
+	            transformKey: transformKey,
+	        }, getCustomOptions(options));
+	        var cache = new Cache(normalizedOptions);
+	        var keys = cache.keys, values = cache.values, canTransformKey = cache.canTransformKey, shouldCloneArguments = cache.shouldCloneArguments, shouldUpdateOnAdd = cache.shouldUpdateOnAdd, shouldUpdateOnChange = cache.shouldUpdateOnChange, shouldUpdateOnHit = cache.shouldUpdateOnHit;
+	        var memoized = function () {
+	            var key = shouldCloneArguments
+	                ? cloneArray(arguments)
+	                : arguments;
+	            if (canTransformKey) {
+	                key = transformKey(key);
+	            }
+	            var keyIndex = keys.length ? cache.getKeyIndex(key) : -1;
+	            if (keyIndex !== -1) {
+	                if (shouldUpdateOnHit) {
+	                    onCacheHit(cache, normalizedOptions, memoized);
+	                }
+	                if (keyIndex) {
+	                    cache.orderByLru(keys[keyIndex], values[keyIndex], keyIndex);
+	                    if (shouldUpdateOnChange) {
+	                        onCacheChange(cache, normalizedOptions, memoized);
+	                    }
+	                }
+	            }
+	            else {
+	                var newValue = fn.apply(this, arguments);
+	                var newKey = shouldCloneArguments
+	                    ? key
+	                    : cloneArray(arguments);
+	                cache.orderByLru(newKey, newValue, keys.length);
+	                if (isPromise) {
+	                    cache.updateAsyncCache(memoized);
+	                }
+	                if (shouldUpdateOnAdd) {
+	                    onCacheAdd(cache, normalizedOptions, memoized);
+	                }
+	                if (shouldUpdateOnChange) {
+	                    onCacheChange(cache, normalizedOptions, memoized);
+	                }
+	            }
+	            return values[0];
+	        };
+	        memoized.cache = cache;
+	        memoized.fn = fn;
+	        memoized.isMemoized = true;
+	        memoized.options = normalizedOptions;
+	        return memoized;
+	    }
+
+	    return createMemoizedFunction;
+
+	}));
+	
+} (microMemoize));
+
+var memoize = microMemoize.exports;
+
+const TOKEN_2022_PROGRAM_ID = new PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
 const TOKEN_METADATA_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
 const TOKEN_PROGRAM_ID = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
@@ -7101,35 +7469,40 @@ const deBridgeSettings = {
     getNoBridgeFeeAddress: (SETTINGS_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(deBridgeSettings$1.Seeds.NO_BRIDGE_FEE_INFO)], SETTINGS_PROGRAM_ID),
 };
 const DlnSrc = {
-    getStateAccount: (PMM_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.STATE)], PMM_SRC_PROGRAM_ID),
-    getNonceAccount: (maker, PMM_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([
+    getStateAccount: (DLN_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.STATE)], DLN_SRC_PROGRAM_ID),
+    getNonceAccount: (maker, DLN_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([
         buffer.Buffer.from(dlnSrc$1.Seeds.NONCE),
         isBuffer(maker) ? maker : maker.toBuffer(),
-    ], PMM_SRC_PROGRAM_ID),
-    getGiveOrderStateAccount: (orderId, PMM_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.ORDER_STATE), orderId], PMM_SRC_PROGRAM_ID),
-    getAuthorizedNativeSenderAddress: (chainId, PMM_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.AUTHORIZED_NATIVE_SENDER), chainId], PMM_SRC_PROGRAM_ID),
-    getGiveOrderWalletAddress: (orderId, PMM_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.GIVE_ORDER_WALLET), orderId], PMM_SRC_PROGRAM_ID),
-    getFeeLedgerWalletAddress: (tokenMint, PMM_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([
+    ], DLN_SRC_PROGRAM_ID),
+    getGiveOrderStateAccount: (orderId, DLN_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.ORDER_STATE), orderId], DLN_SRC_PROGRAM_ID),
+    getAuthorizedNativeSenderAddress: (chainId, DLN_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.AUTHORIZED_NATIVE_SENDER), chainId], DLN_SRC_PROGRAM_ID),
+    getGiveOrderWalletAddress: (orderId, DLN_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.GIVE_ORDER_WALLET), orderId], DLN_SRC_PROGRAM_ID),
+    getFeeLedgerWalletAddress: (tokenMint, DLN_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([
         buffer.Buffer.from(dlnSrc$1.Seeds.FEE_LEDGER_WALLET),
         tokenMint.toBuffer(),
-    ], PMM_SRC_PROGRAM_ID),
-    getFeeLedgerAddress: (PMM_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.FEE_LEDGER)], PMM_SRC_PROGRAM_ID),
+    ], DLN_SRC_PROGRAM_ID),
+    getFeeLedgerAddress: (DLN_SRC_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnSrc$1.Seeds.FEE_LEDGER)], DLN_SRC_PROGRAM_ID),
 };
 const DlnDst = {
-    getAuthorizedSrcContractAddress: (chainId, PMM_DST_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnDst$1.Seeds.AUTHORIZED_SRC_CONTRACT), chainId], PMM_DST_PROGRAM_ID),
-    getAuthorizedDstNativeSenderAddress: (PMM_DST_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnDst$1.Seeds.AUTHORIZED_DST_NATIVE_SENDER)], PMM_DST_PROGRAM_ID),
-    getTakeOrderStateAddress: (orderId, PMM_DST_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnDst$1.Seeds.ORDER_STATE), orderId], PMM_DST_PROGRAM_ID),
-    getTakePatchAddress: (orderId, PMM_DST_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnDst$1.Seeds.TAKE_PATCH), orderId], PMM_DST_PROGRAM_ID),
+    getAuthorizedSrcContractAddress: (chainId, DLN_DST_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnDst$1.Seeds.AUTHORIZED_SRC_CONTRACT), chainId], DLN_DST_PROGRAM_ID),
+    getAuthorizedDstNativeSenderAddress: (DLN_DST_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnDst$1.Seeds.AUTHORIZED_DST_NATIVE_SENDER)], DLN_DST_PROGRAM_ID),
+    getTakeOrderStateAddress: (orderId, DLN_DST_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnDst$1.Seeds.ORDER_STATE), orderId], DLN_DST_PROGRAM_ID),
+    getTakePatchAddress: (orderId, DLN_DST_PROGRAM_ID) => PublicKey.findProgramAddressSync([buffer.Buffer.from(dlnDst$1.Seeds.TAKE_PATCH), orderId], DLN_DST_PROGRAM_ID),
 };
 function wrapFn(fn, arg) {
     return (...args) => fn(...args, arg);
 }
 class Resolver {
-    constructor(programId, obj) {
+    constructor(programId, obj, memoizeList) {
         this.programId = new PublicKey(programId);
         let methods = {};
         for (let [fnName, fn] of Object.entries(obj)) {
-            methods[fnName] = wrapFn(fn, this.programId);
+            if (fnName in memoizeList) {
+                methods[fnName] = memoize(wrapFn(fn, this.programId), Object.assign({}, memoizeList[fnName]));
+            }
+            else {
+                methods[fnName] = wrapFn(fn, this.programId);
+            }
         }
         this.methods = methods;
     }
@@ -7145,9 +7518,41 @@ class ResolverContainer2 {
         this.methods = methods;
     }
 }
-const DeBridgeResolver = (programId, settingsProgramId) => new ResolverContainer2(new Resolver(programId, deBridge$1), new Resolver(settingsProgramId, deBridgeSettings));
-const dlnSrcResolver = (programId) => new Resolver(programId, DlnSrc);
-const dlnDstResolver = (programId) => new Resolver(programId, DlnDst);
+const DeBridgeResolver = (programId, settingsProgramId) => {
+    const deBridgeMemoizeList = {
+        "getClaimMarkerAddress": {},
+        "getNonceAddress": {},
+        "getMintAuthorityAddress": { maxSize: 20 }
+    };
+    const settingsMemoizeList = {
+        "getTokenMetadataMasterAddress": {},
+        "getTokenMintAddress": { maxSize: 5 },
+        "getStateAddress": {},
+        "getBridgeFeeAddress": { maxSize: 40 },
+        "getChainSupportInfoAddress": { maxSize: 10 },
+        "getBridgeAddress": { maxSize: 10 },
+        "getBridgeMapAddress": { maxSize: 10 },
+        "getNoBridgeFeeAddress": {},
+        "getNoDiscountAddress": {},
+    };
+    return new ResolverContainer2(new Resolver(programId, deBridge$1, deBridgeMemoizeList), new Resolver(settingsProgramId, deBridgeSettings, settingsMemoizeList));
+};
+const dlnSrcResolver = (programId) => {
+    const dlnMemoizeList = {
+        "getStateAccount": {},
+        "getAuthorizedNativeSenderAddress": { maxSize: 10 },
+        "getFeeLedgerAddress": {},
+        "getFeeLedgerWalletAddress": { maxSize: 10 }
+    };
+    return new Resolver(programId, DlnSrc, dlnMemoizeList);
+};
+const dlnDstResolver = (programId) => {
+    const dstMemoizeList = {
+        "getAuthorizedSrcContractAddress": { maxSize: 10 },
+        "getAuthorizedDstNativeSenderAddress": {},
+    };
+    return new Resolver(programId, DlnDst, dstMemoizeList);
+};
 
 var Layout$1 = {};
 
@@ -9660,7 +10065,11 @@ function createAssociatedWalletInstruction(tokenMint, associatedAccount, owner,
         ],
     });
 }
-function parseSplAccount(data) {
+function parseSplAccount(dataOrInfo) {
+    if (dataOrInfo === null) {
+        return null;
+    }
+    const data = 'executable' in dataOrInfo ? dataOrInfo.data : dataOrInfo;
     try {
         return AccountLayout.decode(data);
     }
@@ -9882,5 +10291,89 @@ var programs = /*#__PURE__*/Object.freeze({
 	dlnExecutor: dlnExecutor
 });
 
-export { ASSOCIATED_TOKEN_PROGRAM_ID, DeBridgeResolver, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID, WRAPPED_SOL_MINT, constants, crypto, dlnDstResolver, dlnSrcResolver, findAssociatedTokenAddress, findAssociatedTokenAddressSync, getTokenMetadataAddress, helpers, interfaces, programs, spl };
+function simulateTransaction(connection, tx, simulateConfig) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return __awaiter(this, void 0, void 0, function* () {
+        const addressesToGetDiffFor = ((_b = (_a = simulateConfig.accounts) === null || _a === void 0 ? void 0 : _a.addresses) !== null && _b !== void 0 ? _b : []).map((a) => new PublicKey(a));
+        const accountsToFetch = addressesToGetDiffFor.length > 0 ? yield connection.getMultipleAccountsInfo(addressesToGetDiffFor) : [];
+        const result = yield connection.simulateTransaction(tx, simulateConfig);
+        const diffMap = new Map();
+        for (const [idx, simulatedAccountInfo] of ((_c = result.value.accounts) !== null && _c !== void 0 ? _c : []).entries()) {
+            const accountAddress = addressesToGetDiffFor[idx];
+            const oldAccountData = (_d = accountsToFetch.at(idx)) !== null && _d !== void 0 ? _d : null;
+            const oldParsedMaybeSpl = (oldAccountData === null || oldAccountData === void 0 ? void 0 : oldAccountData.owner.equals(TOKEN_PROGRAM_ID)) ? parseSplAccount(oldAccountData) : null;
+            const oldSolValue = (_e = oldAccountData === null || oldAccountData === void 0 ? void 0 : oldAccountData.lamports) !== null && _e !== void 0 ? _e : 0;
+            const newSolValue = (_f = simulatedAccountInfo === null || simulatedAccountInfo === void 0 ? void 0 : simulatedAccountInfo.lamports) !== null && _f !== void 0 ? _f : 0;
+            const solDiff = oldSolValue === newSolValue ? null : {
+                before: oldSolValue,
+                after: newSolValue,
+            };
+            let newParsedMaybeSpl = null;
+            if (simulatedAccountInfo) {
+                const [rawData, encoding] = simulatedAccountInfo.data;
+                if (encoding !== "base64")
+                    throw new Error("Expected bs64 account data");
+                const artificialAccountInfo = Object.assign(Object.assign({}, simulatedAccountInfo), { owner: new PublicKey(simulatedAccountInfo.owner), data: Buffer.from(rawData, "base64") });
+                newParsedMaybeSpl = artificialAccountInfo.owner.equals(TOKEN_PROGRAM_ID) ? parseSplAccount(artificialAccountInfo) : null;
+            }
+            let splDiff = null;
+            // old state is spl token account OR new state is spl token account
+            if (oldParsedMaybeSpl !== null || newParsedMaybeSpl !== null) {
+                if (oldParsedMaybeSpl !== newParsedMaybeSpl) {
+                    const token = (newParsedMaybeSpl === null || newParsedMaybeSpl === void 0 ? void 0 : newParsedMaybeSpl.mint) || (oldParsedMaybeSpl === null || oldParsedMaybeSpl === void 0 ? void 0 : oldParsedMaybeSpl.mint);
+                    if (token === undefined)
+                        throw new Error("Failed to get token from the spl token account");
+                    const owner = (newParsedMaybeSpl === null || newParsedMaybeSpl === void 0 ? void 0 : newParsedMaybeSpl.owner) || (oldParsedMaybeSpl === null || oldParsedMaybeSpl === void 0 ? void 0 : oldParsedMaybeSpl.owner);
+                    if (owner === undefined)
+                        throw new Error("Failed to get owner from the spl token account");
+                    splDiff = {
+                        before: (_g = oldParsedMaybeSpl === null || oldParsedMaybeSpl === void 0 ? void 0 : oldParsedMaybeSpl.amount) !== null && _g !== void 0 ? _g : BigInt(0),
+                        after: (_h = newParsedMaybeSpl === null || newParsedMaybeSpl === void 0 ? void 0 : newParsedMaybeSpl.amount) !== null && _h !== void 0 ? _h : BigInt(0),
+                        token,
+                        owner,
+                    };
+                }
+            }
+            if (splDiff !== null || solDiff !== null) {
+                diffMap.set(accountAddress.toBase58(), {
+                    native: solDiff,
+                    spl: splDiff,
+                });
+            }
+        }
+        return Object.assign(Object.assign({}, result.value), { diff: diffMap });
+    });
+}
+/**
+     * Serializes transaction and returns serialized size
+     * @param transaction tx to get length
+     * @param feePayer optional fee payer
+     * @returns transaction size
+     */
+function getTransactionSize(tx) {
+    try {
+        if ("version" in tx) {
+            const txCopy = new VersionedTransaction(tx.message);
+            txCopy.message.recentBlockhash = FAKE_BLOCKHASH;
+            return txCopy.serialize().length;
+        }
+        else {
+            const txCopy = new Transaction(tx);
+            txCopy.feePayer = Keypair.generate().publicKey;
+            txCopy.recentBlockhash = FAKE_BLOCKHASH;
+            return tx.serialize({ verifySignatures: false }).length;
+        }
+    }
+    catch (e) {
+        return null;
+    }
+}
+
+var transaction = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	simulateTransaction: simulateTransaction,
+	getTransactionSize: getTransactionSize
+});
+
+export { ASSOCIATED_TOKEN_PROGRAM_ID, DeBridgeResolver, TOKEN_2022_PROGRAM_ID, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID, WRAPPED_SOL_MINT, constants, crypto, dlnDstResolver, dlnSrcResolver, findAssociatedTokenAddress, findAssociatedTokenAddressSync, getTokenMetadataAddress, helpers, interfaces, programs, spl, transaction as txs };
 //# sourceMappingURL=index.js.map