@debridge-finance/solana-utils 3.0.0 → 4.0.1

package/dist/browser/index.js

@@ -5734,812 +5734,9 @@ var require$$0 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1);
 	})(module, commonjsGlobal);
 } (bn));
 
-var BN$1 = bn.exports;
+var BN = bn.exports;
 
-const version$4 = "logger/5.7.0";
-
-let _permanentCensorErrors = false;
-let _censorErrors = false;
-const LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 };
-let _logLevel = LogLevels["default"];
-let _globalLogger = null;
-function _checkNormalize() {
-    try {
-        const missing = [];
-        // Make sure all forms of normalization are supported
-        ["NFD", "NFC", "NFKD", "NFKC"].forEach((form) => {
-            try {
-                if ("test".normalize(form) !== "test") {
-                    throw new Error("bad normalize");
-                }
-                ;
-            }
-            catch (error) {
-                missing.push(form);
-            }
-        });
-        if (missing.length) {
-            throw new Error("missing " + missing.join(", "));
-        }
-        if (String.fromCharCode(0xe9).normalize("NFD") !== String.fromCharCode(0x65, 0x0301)) {
-            throw new Error("broken implementation");
-        }
-    }
-    catch (error) {
-        return error.message;
-    }
-    return null;
-}
-const _normalizeError = _checkNormalize();
-var LogLevel;
-(function (LogLevel) {
-    LogLevel["DEBUG"] = "DEBUG";
-    LogLevel["INFO"] = "INFO";
-    LogLevel["WARNING"] = "WARNING";
-    LogLevel["ERROR"] = "ERROR";
-    LogLevel["OFF"] = "OFF";
-})(LogLevel || (LogLevel = {}));
-var ErrorCode;
-(function (ErrorCode) {
-    ///////////////////
-    // Generic Errors
-    // Unknown Error
-    ErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-    // Not Implemented
-    ErrorCode["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
-    // Unsupported Operation
-    //   - operation
-    ErrorCode["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
-    // Network Error (i.e. Ethereum Network, such as an invalid chain ID)
-    //   - event ("noNetwork" is not re-thrown in provider.ready; otherwise thrown)
-    ErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
-    // Some sort of bad response from the server
-    ErrorCode["SERVER_ERROR"] = "SERVER_ERROR";
-    // Timeout
-    ErrorCode["TIMEOUT"] = "TIMEOUT";
-    ///////////////////
-    // Operational  Errors
-    // Buffer Overrun
-    ErrorCode["BUFFER_OVERRUN"] = "BUFFER_OVERRUN";
-    // Numeric Fault
-    //   - operation: the operation being executed
-    //   - fault: the reason this faulted
-    ErrorCode["NUMERIC_FAULT"] = "NUMERIC_FAULT";
-    ///////////////////
-    // Argument Errors
-    // Missing new operator to an object
-    //  - name: The name of the class
-    ErrorCode["MISSING_NEW"] = "MISSING_NEW";
-    // Invalid argument (e.g. value is incompatible with type) to a function:
-    //   - argument: The argument name that was invalid
-    //   - value: The value of the argument
-    ErrorCode["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
-    // Missing argument to a function:
-    //   - count: The number of arguments received
-    //   - expectedCount: The number of arguments expected
-    ErrorCode["MISSING_ARGUMENT"] = "MISSING_ARGUMENT";
-    // Too many arguments
-    //   - count: The number of arguments received
-    //   - expectedCount: The number of arguments expected
-    ErrorCode["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT";
-    ///////////////////
-    // Blockchain Errors
-    // Call exception
-    //  - transaction: the transaction
-    //  - address?: the contract address
-    //  - args?: The arguments passed into the function
-    //  - method?: The Solidity method signature
-    //  - errorSignature?: The EIP848 error signature
-    //  - errorArgs?: The EIP848 error parameters
-    //  - reason: The reason (only for EIP848 "Error(string)")
-    ErrorCode["CALL_EXCEPTION"] = "CALL_EXCEPTION";
-    // Insufficient funds (< value + gasLimit * gasPrice)
-    //   - transaction: the transaction attempted
-    ErrorCode["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-    // Nonce has already been used
-    //   - transaction: the transaction attempted
-    ErrorCode["NONCE_EXPIRED"] = "NONCE_EXPIRED";
-    // The replacement fee for the transaction is too low
-    //   - transaction: the transaction attempted
-    ErrorCode["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED";
-    // The gas limit could not be estimated
-    //   - transaction: the transaction passed to estimateGas
-    ErrorCode["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
-    // The transaction was replaced by one with a higher gas price
-    //   - reason: "cancelled", "replaced" or "repriced"
-    //   - cancelled: true if reason == "cancelled" or reason == "replaced")
-    //   - hash: original transaction hash
-    //   - replacement: the full TransactionsResponse for the replacement
-    //   - receipt: the receipt of the replacement
-    ErrorCode["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED";
-    ///////////////////
-    // Interaction Errors
-    // The user rejected the action, such as signing a message or sending
-    // a transaction
-    ErrorCode["ACTION_REJECTED"] = "ACTION_REJECTED";
-})(ErrorCode || (ErrorCode = {}));
-const HEX = "0123456789abcdef";
-class Logger {
-    constructor(version) {
-        Object.defineProperty(this, "version", {
-            enumerable: true,
-            value: version,
-            writable: false
-        });
-    }
-    _log(logLevel, args) {
-        const level = logLevel.toLowerCase();
-        if (LogLevels[level] == null) {
-            this.throwArgumentError("invalid log level name", "logLevel", logLevel);
-        }
-        if (_logLevel > LogLevels[level]) {
-            return;
-        }
-        console.log.apply(console, args);
-    }
-    debug(...args) {
-        this._log(Logger.levels.DEBUG, args);
-    }
-    info(...args) {
-        this._log(Logger.levels.INFO, args);
-    }
-    warn(...args) {
-        this._log(Logger.levels.WARNING, args);
-    }
-    makeError(message, code, params) {
-        // Errors are being censored
-        if (_censorErrors) {
-            return this.makeError("censored error", code, {});
-        }
-        if (!code) {
-            code = Logger.errors.UNKNOWN_ERROR;
-        }
-        if (!params) {
-            params = {};
-        }
-        const messageDetails = [];
-        Object.keys(params).forEach((key) => {
-            const value = params[key];
-            try {
-                if (value instanceof Uint8Array) {
-                    let hex = "";
-                    for (let i = 0; i < value.length; i++) {
-                        hex += HEX[value[i] >> 4];
-                        hex += HEX[value[i] & 0x0f];
-                    }
-                    messageDetails.push(key + "=Uint8Array(0x" + hex + ")");
-                }
-                else {
-                    messageDetails.push(key + "=" + JSON.stringify(value));
-                }
-            }
-            catch (error) {
-                messageDetails.push(key + "=" + JSON.stringify(params[key].toString()));
-            }
-        });
-        messageDetails.push(`code=${code}`);
-        messageDetails.push(`version=${this.version}`);
-        const reason = message;
-        let url = "";
-        switch (code) {
-            case ErrorCode.NUMERIC_FAULT: {
-                url = "NUMERIC_FAULT";
-                const fault = message;
-                switch (fault) {
-                    case "overflow":
-                    case "underflow":
-                    case "division-by-zero":
-                        url += "-" + fault;
-                        break;
-                    case "negative-power":
-                    case "negative-width":
-                        url += "-unsupported";
-                        break;
-                    case "unbound-bitwise-result":
-                        url += "-unbound-result";
-                        break;
-                }
-                break;
-            }
-            case ErrorCode.CALL_EXCEPTION:
-            case ErrorCode.INSUFFICIENT_FUNDS:
-            case ErrorCode.MISSING_NEW:
-            case ErrorCode.NONCE_EXPIRED:
-            case ErrorCode.REPLACEMENT_UNDERPRICED:
-            case ErrorCode.TRANSACTION_REPLACED:
-            case ErrorCode.UNPREDICTABLE_GAS_LIMIT:
-                url = code;
-                break;
-        }
-        if (url) {
-            message += " [ See: https:/\/links.ethers.org/v5-errors-" + url + " ]";
-        }
-        if (messageDetails.length) {
-            message += " (" + messageDetails.join(", ") + ")";
-        }
-        // @TODO: Any??
-        const error = new Error(message);
-        error.reason = reason;
-        error.code = code;
-        Object.keys(params).forEach(function (key) {
-            error[key] = params[key];
-        });
-        return error;
-    }
-    throwError(message, code, params) {
-        throw this.makeError(message, code, params);
-    }
-    throwArgumentError(message, name, value) {
-        return this.throwError(message, Logger.errors.INVALID_ARGUMENT, {
-            argument: name,
-            value: value
-        });
-    }
-    assert(condition, message, code, params) {
-        if (!!condition) {
-            return;
-        }
-        this.throwError(message, code, params);
-    }
-    assertArgument(condition, message, name, value) {
-        if (!!condition) {
-            return;
-        }
-        this.throwArgumentError(message, name, value);
-    }
-    checkNormalize(message) {
-        if (_normalizeError) {
-            this.throwError("platform missing String.prototype.normalize", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "String.prototype.normalize", form: _normalizeError
-            });
-        }
-    }
-    checkSafeUint53(value, message) {
-        if (typeof (value) !== "number") {
-            return;
-        }
-        if (message == null) {
-            message = "value not safe";
-        }
-        if (value < 0 || value >= 0x1fffffffffffff) {
-            this.throwError(message, Logger.errors.NUMERIC_FAULT, {
-                operation: "checkSafeInteger",
-                fault: "out-of-safe-range",
-                value: value
-            });
-        }
-        if (value % 1) {
-            this.throwError(message, Logger.errors.NUMERIC_FAULT, {
-                operation: "checkSafeInteger",
-                fault: "non-integer",
-                value: value
-            });
-        }
-    }
-    checkArgumentCount(count, expectedCount, message) {
-        if (message) {
-            message = ": " + message;
-        }
-        else {
-            message = "";
-        }
-        if (count < expectedCount) {
-            this.throwError("missing argument" + message, Logger.errors.MISSING_ARGUMENT, {
-                count: count,
-                expectedCount: expectedCount
-            });
-        }
-        if (count > expectedCount) {
-            this.throwError("too many arguments" + message, Logger.errors.UNEXPECTED_ARGUMENT, {
-                count: count,
-                expectedCount: expectedCount
-            });
-        }
-    }
-    checkNew(target, kind) {
-        if (target === Object || target == null) {
-            this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name });
-        }
-    }
-    checkAbstract(target, kind) {
-        if (target === kind) {
-            this.throwError("cannot instantiate abstract class " + JSON.stringify(kind.name) + " directly; use a sub-class", Logger.errors.UNSUPPORTED_OPERATION, { name: target.name, operation: "new" });
-        }
-        else if (target === Object || target == null) {
-            this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name });
-        }
-    }
-    static globalLogger() {
-        if (!_globalLogger) {
-            _globalLogger = new Logger(version$4);
-        }
-        return _globalLogger;
-    }
-    static setCensorship(censorship, permanent) {
-        if (!censorship && permanent) {
-            this.globalLogger().throwError("cannot permanently disable censorship", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "setCensorship"
-            });
-        }
-        if (_permanentCensorErrors) {
-            if (!censorship) {
-                return;
-            }
-            this.globalLogger().throwError("error censorship permanent", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "setCensorship"
-            });
-        }
-        _censorErrors = !!censorship;
-        _permanentCensorErrors = !!permanent;
-    }
-    static setLogLevel(logLevel) {
-        const level = LogLevels[logLevel.toLowerCase()];
-        if (level == null) {
-            Logger.globalLogger().warn("invalid log level - " + logLevel);
-            return;
-        }
-        _logLevel = level;
-    }
-    static from(version) {
-        return new Logger(version);
-    }
-}
-Logger.errors = ErrorCode;
-Logger.levels = LogLevel;
-
-const version$3 = "bytes/5.7.0";
-
-const logger$3 = new Logger(version$3);
-///////////////////////////////
-function isHexable(value) {
-    return !!(value.toHexString);
-}
-function addSlice(array) {
-    if (array.slice) {
-        return array;
-    }
-    array.slice = function () {
-        const args = Array.prototype.slice.call(arguments);
-        return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args)));
-    };
-    return array;
-}
-function isInteger(value) {
-    return (typeof (value) === "number" && value == value && (value % 1) === 0);
-}
-function isBytes(value) {
-    if (value == null) {
-        return false;
-    }
-    if (value.constructor === Uint8Array) {
-        return true;
-    }
-    if (typeof (value) === "string") {
-        return false;
-    }
-    if (!isInteger(value.length) || value.length < 0) {
-        return false;
-    }
-    for (let i = 0; i < value.length; i++) {
-        const v = value[i];
-        if (!isInteger(v) || v < 0 || v >= 256) {
-            return false;
-        }
-    }
-    return true;
-}
-function arrayify(value, options) {
-    if (!options) {
-        options = {};
-    }
-    if (typeof (value) === "number") {
-        logger$3.checkSafeUint53(value, "invalid arrayify value");
-        const result = [];
-        while (value) {
-            result.unshift(value & 0xff);
-            value = parseInt(String(value / 256));
-        }
-        if (result.length === 0) {
-            result.push(0);
-        }
-        return addSlice(new Uint8Array(result));
-    }
-    if (options.allowMissingPrefix && typeof (value) === "string" && value.substring(0, 2) !== "0x") {
-        value = "0x" + value;
-    }
-    if (isHexable(value)) {
-        value = value.toHexString();
-    }
-    if (isHexString(value)) {
-        let hex = value.substring(2);
-        if (hex.length % 2) {
-            if (options.hexPad === "left") {
-                hex = "0" + hex;
-            }
-            else if (options.hexPad === "right") {
-                hex += "0";
-            }
-            else {
-                logger$3.throwArgumentError("hex data is odd-length", "value", value);
-            }
-        }
-        const result = [];
-        for (let i = 0; i < hex.length; i += 2) {
-            result.push(parseInt(hex.substring(i, i + 2), 16));
-        }
-        return addSlice(new Uint8Array(result));
-    }
-    if (isBytes(value)) {
-        return addSlice(new Uint8Array(value));
-    }
-    return logger$3.throwArgumentError("invalid arrayify value", "value", value);
-}
-function concat(items) {
-    const objects = items.map(item => arrayify(item));
-    const length = objects.reduce((accum, item) => (accum + item.length), 0);
-    const result = new Uint8Array(length);
-    objects.reduce((offset, object) => {
-        result.set(object, offset);
-        return offset + object.length;
-    }, 0);
-    return addSlice(result);
-}
-function zeroPad(value, length) {
-    value = arrayify(value);
-    if (value.length > length) {
-        logger$3.throwArgumentError("value out of range", "value", arguments[0]);
-    }
-    const result = new Uint8Array(length);
-    result.set(value, length - value.length);
-    return addSlice(result);
-}
-function isHexString(value, length) {
-    if (typeof (value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
-        return false;
-    }
-    if (length && value.length !== 2 + 2 * length) {
-        return false;
-    }
-    return true;
-}
-const HexCharacters = "0123456789abcdef";
-function hexlify(value, options) {
-    if (!options) {
-        options = {};
-    }
-    if (typeof (value) === "number") {
-        logger$3.checkSafeUint53(value, "invalid hexlify value");
-        let hex = "";
-        while (value) {
-            hex = HexCharacters[value & 0xf] + hex;
-            value = Math.floor(value / 16);
-        }
-        if (hex.length) {
-            if (hex.length % 2) {
-                hex = "0" + hex;
-            }
-            return "0x" + hex;
-        }
-        return "0x00";
-    }
-    if (typeof (value) === "bigint") {
-        value = value.toString(16);
-        if (value.length % 2) {
-            return ("0x0" + value);
-        }
-        return "0x" + value;
-    }
-    if (options.allowMissingPrefix && typeof (value) === "string" && value.substring(0, 2) !== "0x") {
-        value = "0x" + value;
-    }
-    if (isHexable(value)) {
-        return value.toHexString();
-    }
-    if (isHexString(value)) {
-        if (value.length % 2) {
-            if (options.hexPad === "left") {
-                value = "0x0" + value.substring(2);
-            }
-            else if (options.hexPad === "right") {
-                value += "0";
-            }
-            else {
-                logger$3.throwArgumentError("hex data is odd-length", "value", value);
-            }
-        }
-        return value.toLowerCase();
-    }
-    if (isBytes(value)) {
-        let result = "0x";
-        for (let i = 0; i < value.length; i++) {
-            let v = value[i];
-            result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
-        }
-        return result;
-    }
-    return logger$3.throwArgumentError("invalid hexlify value", "value", value);
-}
-
-const version$2 = "bignumber/5.7.0";
-
-var BN = BN$1.BN;
-const logger$2 = new Logger(version$2);
-const _constructorGuard = {};
-const MAX_SAFE = 0x1fffffffffffff;
-// Only warn about passing 10 into radix once
-let _warnedToStringRadix = false;
-class BigNumber {
-    constructor(constructorGuard, hex) {
-        if (constructorGuard !== _constructorGuard) {
-            logger$2.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "new (BigNumber)"
-            });
-        }
-        this._hex = hex;
-        this._isBigNumber = true;
-        Object.freeze(this);
-    }
-    fromTwos(value) {
-        return toBigNumber(toBN(this).fromTwos(value));
-    }
-    toTwos(value) {
-        return toBigNumber(toBN(this).toTwos(value));
-    }
-    abs() {
-        if (this._hex[0] === "-") {
-            return BigNumber.from(this._hex.substring(1));
-        }
-        return this;
-    }
-    add(other) {
-        return toBigNumber(toBN(this).add(toBN(other)));
-    }
-    sub(other) {
-        return toBigNumber(toBN(this).sub(toBN(other)));
-    }
-    div(other) {
-        const o = BigNumber.from(other);
-        if (o.isZero()) {
-            throwFault("division-by-zero", "div");
-        }
-        return toBigNumber(toBN(this).div(toBN(other)));
-    }
-    mul(other) {
-        return toBigNumber(toBN(this).mul(toBN(other)));
-    }
-    mod(other) {
-        const value = toBN(other);
-        if (value.isNeg()) {
-            throwFault("division-by-zero", "mod");
-        }
-        return toBigNumber(toBN(this).umod(value));
-    }
-    pow(other) {
-        const value = toBN(other);
-        if (value.isNeg()) {
-            throwFault("negative-power", "pow");
-        }
-        return toBigNumber(toBN(this).pow(value));
-    }
-    and(other) {
-        const value = toBN(other);
-        if (this.isNegative() || value.isNeg()) {
-            throwFault("unbound-bitwise-result", "and");
-        }
-        return toBigNumber(toBN(this).and(value));
-    }
-    or(other) {
-        const value = toBN(other);
-        if (this.isNegative() || value.isNeg()) {
-            throwFault("unbound-bitwise-result", "or");
-        }
-        return toBigNumber(toBN(this).or(value));
-    }
-    xor(other) {
-        const value = toBN(other);
-        if (this.isNegative() || value.isNeg()) {
-            throwFault("unbound-bitwise-result", "xor");
-        }
-        return toBigNumber(toBN(this).xor(value));
-    }
-    mask(value) {
-        if (this.isNegative() || value < 0) {
-            throwFault("negative-width", "mask");
-        }
-        return toBigNumber(toBN(this).maskn(value));
-    }
-    shl(value) {
-        if (this.isNegative() || value < 0) {
-            throwFault("negative-width", "shl");
-        }
-        return toBigNumber(toBN(this).shln(value));
-    }
-    shr(value) {
-        if (this.isNegative() || value < 0) {
-            throwFault("negative-width", "shr");
-        }
-        return toBigNumber(toBN(this).shrn(value));
-    }
-    eq(other) {
-        return toBN(this).eq(toBN(other));
-    }
-    lt(other) {
-        return toBN(this).lt(toBN(other));
-    }
-    lte(other) {
-        return toBN(this).lte(toBN(other));
-    }
-    gt(other) {
-        return toBN(this).gt(toBN(other));
-    }
-    gte(other) {
-        return toBN(this).gte(toBN(other));
-    }
-    isNegative() {
-        return (this._hex[0] === "-");
-    }
-    isZero() {
-        return toBN(this).isZero();
-    }
-    toNumber() {
-        try {
-            return toBN(this).toNumber();
-        }
-        catch (error) {
-            throwFault("overflow", "toNumber", this.toString());
-        }
-        return null;
-    }
-    toBigInt() {
-        try {
-            return BigInt(this.toString());
-        }
-        catch (e) { }
-        return logger$2.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, {
-            value: this.toString()
-        });
-    }
-    toString() {
-        // Lots of people expect this, which we do not support, so check (See: #889)
-        if (arguments.length > 0) {
-            if (arguments[0] === 10) {
-                if (!_warnedToStringRadix) {
-                    _warnedToStringRadix = true;
-                    logger$2.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
-                }
-            }
-            else if (arguments[0] === 16) {
-                logger$2.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger.errors.UNEXPECTED_ARGUMENT, {});
-            }
-            else {
-                logger$2.throwError("BigNumber.toString does not accept parameters", Logger.errors.UNEXPECTED_ARGUMENT, {});
-            }
-        }
-        return toBN(this).toString(10);
-    }
-    toHexString() {
-        return this._hex;
-    }
-    toJSON(key) {
-        return { type: "BigNumber", hex: this.toHexString() };
-    }
-    static from(value) {
-        if (value instanceof BigNumber) {
-            return value;
-        }
-        if (typeof (value) === "string") {
-            if (value.match(/^-?0x[0-9a-f]+$/i)) {
-                return new BigNumber(_constructorGuard, toHex(value));
-            }
-            if (value.match(/^-?[0-9]+$/)) {
-                return new BigNumber(_constructorGuard, toHex(new BN(value)));
-            }
-            return logger$2.throwArgumentError("invalid BigNumber string", "value", value);
-        }
-        if (typeof (value) === "number") {
-            if (value % 1) {
-                throwFault("underflow", "BigNumber.from", value);
-            }
-            if (value >= MAX_SAFE || value <= -MAX_SAFE) {
-                throwFault("overflow", "BigNumber.from", value);
-            }
-            return BigNumber.from(String(value));
-        }
-        const anyValue = value;
-        if (typeof (anyValue) === "bigint") {
-            return BigNumber.from(anyValue.toString());
-        }
-        if (isBytes(anyValue)) {
-            return BigNumber.from(hexlify(anyValue));
-        }
-        if (anyValue) {
-            // Hexable interface (takes priority)
-            if (anyValue.toHexString) {
-                const hex = anyValue.toHexString();
-                if (typeof (hex) === "string") {
-                    return BigNumber.from(hex);
-                }
-            }
-            else {
-                // For now, handle legacy JSON-ified values (goes away in v6)
-                let hex = anyValue._hex;
-                // New-form JSON
-                if (hex == null && anyValue.type === "BigNumber") {
-                    hex = anyValue.hex;
-                }
-                if (typeof (hex) === "string") {
-                    if (isHexString(hex) || (hex[0] === "-" && isHexString(hex.substring(1)))) {
-                        return BigNumber.from(hex);
-                    }
-                }
-            }
-        }
-        return logger$2.throwArgumentError("invalid BigNumber value", "value", value);
-    }
-    static isBigNumber(value) {
-        return !!(value && value._isBigNumber);
-    }
-}
-// Normalize the hex string
-function toHex(value) {
-    // For BN, call on the hex string
-    if (typeof (value) !== "string") {
-        return toHex(value.toString(16));
-    }
-    // If negative, prepend the negative sign to the normalized positive value
-    if (value[0] === "-") {
-        // Strip off the negative sign
-        value = value.substring(1);
-        // Cannot have multiple negative signs (e.g. "--0x04")
-        if (value[0] === "-") {
-            logger$2.throwArgumentError("invalid hex", "value", value);
-        }
-        // Call toHex on the positive component
-        value = toHex(value);
-        // Do not allow "-0x00"
-        if (value === "0x00") {
-            return value;
-        }
-        // Negate the value
-        return "-" + value;
-    }
-    // Add a "0x" prefix if missing
-    if (value.substring(0, 2) !== "0x") {
-        value = "0x" + value;
-    }
-    // Normalize zero
-    if (value === "0x") {
-        return "0x00";
-    }
-    // Make the string even length
-    if (value.length % 2) {
-        value = "0x0" + value.substring(2);
-    }
-    // Trim to smallest even-length string
-    while (value.length > 4 && value.substring(0, 4) === "0x00") {
-        value = "0x" + value.substring(4);
-    }
-    return value;
-}
-function toBigNumber(value) {
-    return BigNumber.from(toHex(value));
-}
-function toBN(value) {
-    const hex = BigNumber.from(value).toHexString();
-    if (hex[0] === "-") {
-        return (new BN("-" + hex.substring(3), 16));
-    }
-    return new BN(hex.substring(2), 16);
-}
-function throwFault(fault, operation, value) {
-    const params = { fault: fault, operation: operation };
-    if (value != null) {
-        params.value = value;
-    }
-    return logger$2.throwError(fault, Logger.errors.NUMERIC_FAULT, params);
-}
-
-var sha3$1 = {exports: {}};
+var sha3 = {exports: {}};
 
 /**
  * [js-sha3]{@link https://github.com/emn178/js-sha3}
@@ -7165,243 +6362,66 @@ var sha3$1 = {exports: {}};
 	      s[26] = b26 ^ (~b28 & b20);
 	      s[27] = b27 ^ (~b29 & b21);
 	      s[36] = b36 ^ (~b38 & b30);
-	      s[37] = b37 ^ (~b39 & b31);
-	      s[46] = b46 ^ (~b48 & b40);
-	      s[47] = b47 ^ (~b49 & b41);
-	      s[8] = b8 ^ (~b0 & b2);
-	      s[9] = b9 ^ (~b1 & b3);
-	      s[18] = b18 ^ (~b10 & b12);
-	      s[19] = b19 ^ (~b11 & b13);
-	      s[28] = b28 ^ (~b20 & b22);
-	      s[29] = b29 ^ (~b21 & b23);
-	      s[38] = b38 ^ (~b30 & b32);
-	      s[39] = b39 ^ (~b31 & b33);
-	      s[48] = b48 ^ (~b40 & b42);
-	      s[49] = b49 ^ (~b41 & b43);
-
-	      s[0] ^= RC[n];
-	      s[1] ^= RC[n + 1];
-	    }
-	  };
-
-	  if (COMMON_JS) {
-	    module.exports = methods;
-	  } else {
-	    for (i = 0; i < methodNames.length; ++i) {
-	      root[methodNames[i]] = methods[methodNames[i]];
-	    }
-	  }
-	})();
-} (sha3$1));
-
-var sha3 = sha3$1.exports;
-
-function keccak256$1(data) {
-    return '0x' + sha3.keccak_256(arrayify(data));
-}
-
-const version$1 = "strings/5.7.0";
-
-const logger$1 = new Logger(version$1);
-///////////////////////////////
-var UnicodeNormalizationForm;
-(function (UnicodeNormalizationForm) {
-    UnicodeNormalizationForm["current"] = "";
-    UnicodeNormalizationForm["NFC"] = "NFC";
-    UnicodeNormalizationForm["NFD"] = "NFD";
-    UnicodeNormalizationForm["NFKC"] = "NFKC";
-    UnicodeNormalizationForm["NFKD"] = "NFKD";
-})(UnicodeNormalizationForm || (UnicodeNormalizationForm = {}));
-var Utf8ErrorReason;
-(function (Utf8ErrorReason) {
-    // A continuation byte was present where there was nothing to continue
-    // - offset = the index the codepoint began in
-    Utf8ErrorReason["UNEXPECTED_CONTINUE"] = "unexpected continuation byte";
-    // An invalid (non-continuation) byte to start a UTF-8 codepoint was found
-    // - offset = the index the codepoint began in
-    Utf8ErrorReason["BAD_PREFIX"] = "bad codepoint prefix";
-    // The string is too short to process the expected codepoint
-    // - offset = the index the codepoint began in
-    Utf8ErrorReason["OVERRUN"] = "string overrun";
-    // A missing continuation byte was expected but not found
-    // - offset = the index the continuation byte was expected at
-    Utf8ErrorReason["MISSING_CONTINUE"] = "missing continuation byte";
-    // The computed code point is outside the range for UTF-8
-    // - offset       = start of this codepoint
-    // - badCodepoint = the computed codepoint; outside the UTF-8 range
-    Utf8ErrorReason["OUT_OF_RANGE"] = "out of UTF-8 range";
-    // UTF-8 strings may not contain UTF-16 surrogate pairs
-    // - offset       = start of this codepoint
-    // - badCodepoint = the computed codepoint; inside the UTF-16 surrogate range
-    Utf8ErrorReason["UTF16_SURROGATE"] = "UTF-16 surrogate";
-    // The string is an overlong representation
-    // - offset       = start of this codepoint
-    // - badCodepoint = the computed codepoint; already bounds checked
-    Utf8ErrorReason["OVERLONG"] = "overlong representation";
-})(Utf8ErrorReason || (Utf8ErrorReason = {}));
-function errorFunc(reason, offset, bytes, output, badCodepoint) {
-    return logger$1.throwArgumentError(`invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
-}
-function ignoreFunc(reason, offset, bytes, output, badCodepoint) {
-    // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes
-    if (reason === Utf8ErrorReason.BAD_PREFIX || reason === Utf8ErrorReason.UNEXPECTED_CONTINUE) {
-        let i = 0;
-        for (let o = offset + 1; o < bytes.length; o++) {
-            if (bytes[o] >> 6 !== 0x02) {
-                break;
-            }
-            i++;
-        }
-        return i;
-    }
-    // This byte runs us past the end of the string, so just jump to the end
-    // (but the first byte was read already read and therefore skipped)
-    if (reason === Utf8ErrorReason.OVERRUN) {
-        return bytes.length - offset - 1;
-    }
-    // Nothing to skip
-    return 0;
-}
-function replaceFunc(reason, offset, bytes, output, badCodepoint) {
-    // Overlong representations are otherwise "valid" code points; just non-deistingtished
-    if (reason === Utf8ErrorReason.OVERLONG) {
-        output.push(badCodepoint);
-        return 0;
-    }
-    // Put the replacement character into the output
-    output.push(0xfffd);
-    // Otherwise, process as if ignoring errors
-    return ignoreFunc(reason, offset, bytes);
-}
-// Common error handing strategies
-Object.freeze({
-    error: errorFunc,
-    ignore: ignoreFunc,
-    replace: replaceFunc
-});
-// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array
-function toUtf8Bytes(str, form = UnicodeNormalizationForm.current) {
-    if (form != UnicodeNormalizationForm.current) {
-        logger$1.checkNormalize();
-        str = str.normalize(form);
-    }
-    let result = [];
-    for (let i = 0; i < str.length; i++) {
-        const c = str.charCodeAt(i);
-        if (c < 0x80) {
-            result.push(c);
-        }
-        else if (c < 0x800) {
-            result.push((c >> 6) | 0xc0);
-            result.push((c & 0x3f) | 0x80);
-        }
-        else if ((c & 0xfc00) == 0xd800) {
-            i++;
-            const c2 = str.charCodeAt(i);
-            if (i >= str.length || (c2 & 0xfc00) !== 0xdc00) {
-                throw new Error("invalid utf-8 string");
-            }
-            // Surrogate Pair
-            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);
-            result.push((pair >> 18) | 0xf0);
-            result.push(((pair >> 12) & 0x3f) | 0x80);
-            result.push(((pair >> 6) & 0x3f) | 0x80);
-            result.push((pair & 0x3f) | 0x80);
-        }
-        else {
-            result.push((c >> 12) | 0xe0);
-            result.push(((c >> 6) & 0x3f) | 0x80);
-            result.push((c & 0x3f) | 0x80);
-        }
-    }
-    return arrayify(result);
-}
+	      s[37] = b37 ^ (~b39 & b31);
+	      s[46] = b46 ^ (~b48 & b40);
+	      s[47] = b47 ^ (~b49 & b41);
+	      s[8] = b8 ^ (~b0 & b2);
+	      s[9] = b9 ^ (~b1 & b3);
+	      s[18] = b18 ^ (~b10 & b12);
+	      s[19] = b19 ^ (~b11 & b13);
+	      s[28] = b28 ^ (~b20 & b22);
+	      s[29] = b29 ^ (~b21 & b23);
+	      s[38] = b38 ^ (~b30 & b32);
+	      s[39] = b39 ^ (~b31 & b33);
+	      s[48] = b48 ^ (~b40 & b42);
+	      s[49] = b49 ^ (~b41 & b43);
 
-const version = "solidity/5.7.0";
+	      s[0] ^= RC[n];
+	      s[1] ^= RC[n + 1];
+	    }
+	  };
 
-const regexBytes = new RegExp("^bytes([0-9]+)$");
-const regexNumber = new RegExp("^(u?int)([0-9]*)$");
-const regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
-const Zeros = "0000000000000000000000000000000000000000000000000000000000000000";
-const logger = new Logger(version);
-function _pack(type, value, isArray) {
-    switch (type) {
-        case "address":
-            if (isArray) {
-                return zeroPad(value, 32);
-            }
-            return arrayify(value);
-        case "string":
-            return toUtf8Bytes(value);
-        case "bytes":
-            return arrayify(value);
-        case "bool":
-            value = (value ? "0x01" : "0x00");
-            if (isArray) {
-                return zeroPad(value, 32);
-            }
-            return arrayify(value);
-    }
-    let match = type.match(regexNumber);
-    if (match) {
-        //let signed = (match[1] === "int")
-        let size = parseInt(match[2] || "256");
-        if ((match[2] && String(size) !== match[2]) || (size % 8 !== 0) || size === 0 || size > 256) {
-            logger.throwArgumentError("invalid number type", "type", type);
-        }
-        if (isArray) {
-            size = 256;
-        }
-        value = BigNumber.from(value).toTwos(size);
-        return zeroPad(value, size / 8);
-    }
-    match = type.match(regexBytes);
-    if (match) {
-        const size = parseInt(match[1]);
-        if (String(size) !== match[1] || size === 0 || size > 32) {
-            logger.throwArgumentError("invalid bytes type", "type", type);
-        }
-        if (arrayify(value).byteLength !== size) {
-            logger.throwArgumentError(`invalid value for ${type}`, "value", value);
-        }
-        if (isArray) {
-            return arrayify((value + Zeros).substring(0, 66));
-        }
-        return value;
-    }
-    match = type.match(regexArray);
-    if (match && Array.isArray(value)) {
-        const baseType = match[1];
-        const count = parseInt(match[2] || String(value.length));
-        if (count != value.length) {
-            logger.throwArgumentError(`invalid array length for ${type}`, "value", value);
-        }
-        const result = [];
-        value.forEach(function (value) {
-            result.push(_pack(baseType, value, true));
-        });
-        return concat(result);
-    }
-    return logger.throwArgumentError("invalid type", "type", type);
-}
-// @TODO: Array Enum
-function pack(types, values) {
-    if (types.length != values.length) {
-        logger.throwArgumentError("wrong number of values; expected ${ types.length }", "values", values);
-    }
-    const tight = [];
-    types.forEach(function (type, index) {
-        tight.push(_pack(type, values[index]));
-    });
-    return hexlify(concat(tight));
-}
-function keccak256(types, values) {
-    return keccak256$1(pack(types, values));
+	  if (COMMON_JS) {
+	    module.exports = methods;
+	  } else {
+	    for (i = 0; i < methodNames.length; ++i) {
+	      root[methodNames[i]] = methods[methodNames[i]];
+	    }
+	  }
+	})();
+} (sha3));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 }
 
 const BPS_DENOMINATOR = 10000;
 const SOLANA_CHAIN_ID = 7565164;
 const MAX_TX_SIZE = 1232;
+const FAKE_BLOCKHASH = "1".repeat(32);
+const DEPLOY_INFO_PREFIX = 2;
+const SUBMISSION_PREFIX = 1;
 const deBridge$1 = {
     Seeds: {
         STATE: "DEBRIDGE_STATE",
@@ -7428,7 +6448,6 @@ const deBridge$1 = {
         SEND_HASHED_DATA: 8,
         SEND_TO_ATA: Math.pow(2, 31),
     },
-    SUBMISSION_PREFIX: 1,
 };
 const deBridgeSettings$1 = {
     Seeds: {
@@ -7470,43 +6489,21 @@ var constants = /*#__PURE__*/Object.freeze({
 	BPS_DENOMINATOR: BPS_DENOMINATOR,
 	SOLANA_CHAIN_ID: SOLANA_CHAIN_ID,
 	MAX_TX_SIZE: MAX_TX_SIZE,
+	FAKE_BLOCKHASH: FAKE_BLOCKHASH,
+	DEPLOY_INFO_PREFIX: DEPLOY_INFO_PREFIX,
+	SUBMISSION_PREFIX: SUBMISSION_PREFIX,
 	deBridge: deBridge$1,
 	deBridgeSettings: deBridgeSettings$1,
 	pmmSrc: pmmSrc,
 	pmmDst: pmmDst
 });
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
 function getAccountInfo(connection, account, commitment = "confirmed") {
     return __awaiter(this, void 0, void 0, function* () {
         const info = yield connection.getAccountInfo(account, commitment);
         if (info) {
             // alchemy bug fix
-            if (info.lamports === 0 && info.rentEpoch === 0)
+            if (info.lamports === 0)
                 return null;
             return info;
         }
@@ -7588,11 +6585,10 @@ class Wallet {
 function sendWithRetries(connection, serialized, lastValidBlockHeight, timesToSend = 5, blockhashCommitment = "finalized") {
     return __awaiter(this, void 0, void 0, function* () {
         const txId = yield connection.sendRawTransaction(serialized, {
-            skipPreflight: true,
-            maxRetries: 1000,
+            skipPreflight: false, // never skip preflight
         });
         let blockheight = yield connection.getBlockHeight();
-        let sent = 0;
+        let sent = 1;
         while (blockheight < lastValidBlockHeight && sent < timesToSend) {
             yield connection.sendRawTransaction(serialized, {
                 skipPreflight: true,
@@ -7639,15 +6635,14 @@ function sendAll(connection, wallet, transactions, options) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         const blockhashCommitment = (options === null || options === void 0 ? void 0 : options.blockhashCommitment) === undefined ? "finalized" : options.blockhashCommitment;
-        const fakeBlockHash = "1".repeat(32);
         const convertIntoTxV0 = (options === null || options === void 0 ? void 0 : options.convertIntoTxV0) === undefined ? true : options.convertIntoTxV0;
         const debug = (options === null || options === void 0 ? void 0 : options.debug) === undefined ? false : options.debug;
         const skipPreflight = (options === null || options === void 0 ? void 0 : options.skipPreflight) === undefined ? false : options.skipPreflight;
-        const rpcCalls = (options === null || options === void 0 ? void 0 : options.rpcCalls) === undefined ? 5 : options.rpcCalls;
+        const rpcCalls = (options === null || options === void 0 ? void 0 : options.rpcCalls) === undefined ? 3 : options.rpcCalls;
         if (!Array.isArray(transactions))
             transactions = [transactions];
         if (convertIntoTxV0) {
-            transactions = transactions.map((tx) => txToV0(tx, wallet.publicKey, fakeBlockHash));
+            transactions = transactions.map((tx) => txToV0(tx, wallet.publicKey, FAKE_BLOCKHASH));
         }
         let txIds = [];
         if ((options === null || options === void 0 ? void 0 : options.waitBetweenSend) === undefined || options.waitBetweenSend === 0) {
@@ -7655,16 +6650,16 @@ function sendAll(connection, wallet, transactions, options) {
                 var _b;
                 let txV0;
                 if (isVersionedTx(tx)) {
-                    tx.message.recentBlockhash = fakeBlockHash;
+                    tx.message.recentBlockhash = FAKE_BLOCKHASH;
                     txV0 = tx;
                 }
                 else {
-                    tx.recentBlockhash = fakeBlockHash;
+                    tx.recentBlockhash = FAKE_BLOCKHASH;
                     tx.feePayer = wallet.publicKey;
                     txV0 = new VersionedTransaction(MessageV0.compile({
                         addressLookupTableAccounts: [],
                         instructions: tx.instructions,
-                        recentBlockhash: fakeBlockHash,
+                        recentBlockhash: FAKE_BLOCKHASH,
                         payerKey: tx.feePayer,
                     }));
                 }
@@ -7752,12 +6747,177 @@ var interfaces = /*#__PURE__*/Object.freeze({
 	isBuffer: isBuffer
 });
 
+/**
+ * All functions are copied from ethers. This is optimization to reduce dependencies
+ */
+function concat(items) {
+    const objects = items.map(item => arrayify(item));
+    const length = objects.reduce((accum, item) => (accum + item.length), 0);
+    const result = new Uint8Array(length);
+    objects.reduce((offset, object) => {
+        result.set(object, offset);
+        return offset + object.length;
+    }, 0);
+    return result;
+}
+function arrayify(value) {
+    if (typeof (value) === "number") {
+        const numValue = value;
+        const result = [];
+        while (value) {
+            result.unshift(numValue & 0xff);
+            value = parseInt(String(numValue / 256));
+        }
+        if (result.length === 0) {
+            result.push(0);
+        }
+        return new Uint8Array(result);
+    }
+    if (BN.isBN(value)) {
+        value = `0x${value.toString("hex")}`;
+    }
+    if (typeof (value) === "string" && value.startsWith("0x")) {
+        return hexToBuffer(value);
+    }
+    if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+        return new Uint8Array(value);
+    }
+    throw new Error(`unknown value: ${value}`);
+}
+// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array
+function toUtf8Bytes(str) {
+    let result = [];
+    for (let i = 0; i < str.length; i++) {
+        const c = str.charCodeAt(i);
+        if (c < 0x80) {
+            result.push(c);
+        }
+        else if (c < 0x800) {
+            result.push((c >> 6) | 0xc0);
+            result.push((c & 0x3f) | 0x80);
+        }
+        else if ((c & 0xfc00) == 0xd800) {
+            i++;
+            const c2 = str.charCodeAt(i);
+            if (i >= str.length || (c2 & 0xfc00) !== 0xdc00) {
+                throw new Error("invalid utf-8 string");
+            }
+            // Surrogate Pair
+            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);
+            result.push((pair >> 18) | 0xf0);
+            result.push(((pair >> 12) & 0x3f) | 0x80);
+            result.push(((pair >> 6) & 0x3f) | 0x80);
+            result.push((pair & 0x3f) | 0x80);
+        }
+        else {
+            result.push((c >> 12) | 0xe0);
+            result.push(((c >> 6) & 0x3f) | 0x80);
+            result.push((c & 0x3f) | 0x80);
+        }
+    }
+    return arrayify(result);
+}
+const zeroPad = (value, length) => {
+    const bufValue = arrayify(value);
+    if (bufValue.length > length) {
+        throw new Error("value out of range");
+    }
+    const result = new Uint8Array(length);
+    result.set(bufValue, length - bufValue.length);
+    return result;
+};
+const isHexString = (data) => typeof (data) === "string" && data.startsWith("0x");
+const _pack = (type, value, isArray) => {
+    const regexBytes = new RegExp("^bytes([0-9]+)$");
+    const regexNumber = new RegExp("^(u?int)([0-9]*)$");
+    const regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
+    const Zeros = "0000000000000000000000000000000000000000000000000000000000000000";
+    switch (type) {
+        case "address":
+            if (isArray) {
+                return zeroPad(value, 32);
+            }
+            return arrayify(value);
+        case "string":
+            return toUtf8Bytes(value);
+        case "bytes":
+            return arrayify(value);
+        case "bool":
+            value = (value ? "0x01" : "0x00");
+            if (isArray) {
+                return zeroPad(value, 32);
+            }
+            return arrayify(value);
+    }
+    let match = type.match(regexNumber);
+    if (match) {
+        //let signed = (match[1] === "int")
+        let size = parseInt(match[2] || "256");
+        if ((match[2] && String(size) !== match[2]) || (size % 8 !== 0) || size === 0 || size > 256) {
+            throw new Error("invalid number type");
+        }
+        if (isArray) {
+            size = 256;
+        }
+        if (isHexString(value)) {
+            value = new BN(value.slice(2), "hex").toTwos(size);
+        }
+        else {
+            value = new BN(value).toTwos(size);
+        }
+        return zeroPad(value, size / 8);
+    }
+    match = type.match(regexBytes);
+    if (match) {
+        const size = parseInt(match[1]);
+        if (String(size) !== match[1] || size === 0 || size > 32) {
+            throw new Error("invalid bytes type");
+        }
+        if (arrayify(value).byteLength !== size) {
+            throw new Error(`invalid value for ${type}`);
+        }
+        if (isArray) {
+            return arrayify((value + Zeros).substring(0, 66));
+        }
+        return value;
+    }
+    match = type.match(regexArray);
+    if (match && Array.isArray(value)) {
+        const baseType = match[1];
+        const count = parseInt(match[2] || String(value.length));
+        if (count != value.length) {
+            throw new Error(`invalid array length for ${type}`);
+        }
+        const result = [];
+        value.forEach(function (value) {
+            result.push(_pack(baseType, value, true));
+        });
+        return concat(result);
+    }
+    throw new Error("invalid type");
+};
+function solidityPack(types, values) {
+    if (types.length != values.length) {
+        throw new Error("types and values length mismatch");
+    }
+    const tight = [];
+    types.forEach((type, index) => {
+        tight.push(_pack(type, values[index]));
+    });
+    return concat(tight);
+}
+
+const keccak256 = (data) => `0x${sha3.exports.keccak256(data)}`;
+const solidityKeccak256 = (types, values) => {
+    const packed = solidityPack(types, values);
+    return keccak256(packed);
+};
 function denormalizeAmount(amount, denominator) {
-    const denominatorBN = new BN$1(Math.pow(10, denominator));
+    const denominatorBN = new BN(Math.pow(10, denominator));
     return amount.mul(denominatorBN).toArrayLike(buffer.Buffer, "be", 32);
 }
 function normalizeChainId(chainId) {
-    return hexToBuffer(`0x${isBuffer(chainId) ? chainId.toString("hex") : new BN$1(chainId).toString(16)}`, 32);
+    return hexToBuffer(`0x${isBuffer(chainId) ? chainId.toString("hex") : new BN(chainId).toString(16)}`, 32);
 }
 /**
  * Hashes deploy info
@@ -7765,9 +6925,9 @@ function normalizeChainId(chainId) {
  * @returns keccak256 of deployInfo structure
  */
 function hashDeployInfo(params) {
-    const nameHash = keccak256(["string"], [params.tokenName]);
-    const symbolHash = keccak256(["string"], [params.tokenSymbol]);
-    const deployInfoHash = keccak256(["uint256", "uint256", "uint256", "uint256", "uint8"], [2, params.debridgeId, nameHash, symbolHash, params.decimals]);
+    const nameHash = solidityKeccak256(["string"], [params.tokenName]);
+    const symbolHash = solidityKeccak256(["string"], [params.tokenSymbol]);
+    const deployInfoHash = solidityKeccak256(["uint256", "uint256", "uint256", "uint256", "uint8"], [DEPLOY_INFO_PREFIX, params.debridgeId, nameHash, symbolHash, params.decimals]);
     return deployInfoHash;
 }
 /**
@@ -7778,11 +6938,11 @@ function hashDeployInfo(params) {
  */
 function hashDebridgeId(nativeChainId, nativeTokenAddress) {
     const chainIdBuffer = normalizeChainId(nativeChainId);
-    const bridgeId = keccak256(["uint256", "bytes"], [chainIdBuffer, nativeTokenAddress]);
+    const bridgeId = solidityKeccak256(["uint256", "bytes"], [chainIdBuffer, nativeTokenAddress]);
     return bridgeId;
 }
 function hashExternalCallBytes(data) {
-    return hexToBuffer(keccak256(["bytes"], [data ? data : buffer.Buffer.from([])]), 32);
+    return hexToBuffer(solidityKeccak256(["bytes"], [data ? data : buffer.Buffer.from([])]), 32);
 }
 /**
  * Hashes submission for provided data
@@ -7808,11 +6968,11 @@ function hashSubmissionIdRaw(params) {
                 : new PublicKey(params.receiver)
             : new PublicKey(params.receiver).toBuffer();
     let packData = [
-        deBridge$1.SUBMISSION_PREFIX,
+        SUBMISSION_PREFIX,
         params.debridgeId,
         normalizeChainId(params.sourceChainId),
         normalizeChainId(params.targetChainId),
-        new BN$1(params.amount).toArray("be", 32),
+        new BN(params.amount).toArray("be", 32),
         receiver,
         params.nonce, // nonce
     ];
@@ -7833,19 +6993,21 @@ function hashSubmissionIdRaw(params) {
             ? hexToBuffer(params.autoParams.fallbackAddress)
             : new PublicKey(params.autoParams.fallbackAddress).toBuffer();
         packData = packData.concat([
-            new BN$1(((_c = params === null || params === void 0 ? void 0 : params.autoParams) === null || _c === void 0 ? void 0 : _c.executionFee) || 0).toArray("be", 32),
-            new BN$1(((_d = params.autoParams) === null || _d === void 0 ? void 0 : _d.flags) || 0).toArray("be", 32),
+            new BN(((_c = params === null || params === void 0 ? void 0 : params.autoParams) === null || _c === void 0 ? void 0 : _c.executionFee) || 0).toArray("be", 32),
+            new BN(((_d = params.autoParams) === null || _d === void 0 ? void 0 : _d.flags) || 0).toArray("be", 32),
             hashExternalCallBytes(fallback),
             shortcut,
             hashExternalCallBytes(params.autoParams.nativeSender),
         ]);
     }
-    const submissionIdHash = keccak256(packParams, packData);
+    const submissionIdHash = solidityKeccak256(packParams, packData);
     return submissionIdHash;
 }
 
 var crypto = /*#__PURE__*/Object.freeze({
 	__proto__: null,
+	keccak256: keccak256,
+	solidityKeccak256: solidityKeccak256,
 	denormalizeAmount: denormalizeAmount,
 	normalizeChainId: normalizeChainId,
 	hashDeployInfo: hashDeployInfo,
@@ -10442,7 +9604,7 @@ function getNativeWalletBalance(connection, wallet) {
     return __awaiter(this, void 0, void 0, function* () {
         wallet = new PublicKey(wallet);
         const result = yield connection.getBalance(wallet);
-        return new BN$1(result.toString());
+        return new BN(result.toString());
     });
 }
 /**
@@ -10456,7 +9618,7 @@ function getAssocSPLWalletBalance(connection, originalWallet, tokenMint) {
         tokenMint = new PublicKey(tokenMint);
         const [wallet] = findAssociatedTokenAddress(originalWallet, tokenMint);
         const result = yield connection.getTokenAccountBalance(wallet, "finalized");
-        return new BN$1(result.value.amount);
+        return new BN(result.value.amount);
     });
 }
 /**
@@ -10467,7 +9629,7 @@ function getSPLWalletBalance(connection, wallet) {
     return __awaiter(this, void 0, void 0, function* () {
         wallet = new PublicKey(wallet);
         const result = yield connection.getTokenAccountBalance(wallet, "finalized");
-        return new BN$1(result.value.amount);
+        return new BN(result.value.amount);
     });
 }
 /**
@@ -10484,7 +9646,7 @@ function getAllTokenAccountsWithBalances(connection, owner) {
             return {
                 address: wallet.pubkey,
                 mint: new PublicKey(tokenInfo.info.mint),
-                amount: new BN$1(tokenInfo.info.tokenAmount.amount),
+                amount: new BN(tokenInfo.info.tokenAmount.amount),
                 decimals: tokenInfo.info.tokenAmount.decimals,
                 isInitialized: true,
                 isNative: tokenInfo.info.isNative,
@@ -10508,7 +9670,7 @@ function getTokenAccountsWithBalance(connection, tokenMint, owner) {
             return {
                 address: wallet.pubkey,
                 mint: new PublicKey(tokenInfo.info.mint),
-                amount: new BN$1(tokenInfo.info.tokenAmount.amount),
+                amount: new BN(tokenInfo.info.tokenAmount.amount),
                 decimals: tokenInfo.info.tokenAmount.decimals,
                 isInitialized: true,
                 isNative: tokenInfo.info.isNative,
@@ -10528,7 +9690,7 @@ function buildReplenishWsolBalanceTransaction(amount, transferFrom, transferTo)
     transferFrom = new PublicKey(transferFrom);
     transferTo = new PublicKey(transferTo);
     const tx = new Transaction();
-    tx.add(SystemProgram.transfer({ fromPubkey: transferFrom, toPubkey: transferTo, lamports: new BN$1(amount).toNumber() }));
+    tx.add(SystemProgram.transfer({ fromPubkey: transferFrom, toPubkey: transferTo, lamports: new BN(amount).toNumber() }));
     tx.add(
     // sync native
     new TransactionInstruction({
@@ -10548,27 +9710,20 @@ function updateWsolBalance(connection, amount, owner) {
     return __awaiter(this, void 0, void 0, function* () {
         owner = new PublicKey(owner);
         const tx = new Transaction();
-        const accountSize = 165;
         const [wSolATA] = findAssociatedTokenAddress(owner, WRAPPED_SOL_MINT);
         const existingATA = yield getAccountInfo(connection, wSolATA);
-        let amountToWrap = new BN$1(amount);
+        let amountToWrap = new BN(amount);
         if (existingATA === null) {
-            tx.add(SystemProgram.createAccount({
-                fromPubkey: owner,
-                space: accountSize,
-                programId: TOKEN_PROGRAM_ID,
-                newAccountPubkey: wSolATA,
-                lamports: yield connection.getMinimumBalanceForRentExemption(accountSize),
-            }));
+            tx.add(createAssociatedWalletInstruction(WRAPPED_SOL_MINT, wSolATA, owner, owner));
         }
         else {
             const parsed = parseSplAccount(existingATA.data);
             if (!parsed)
                 throw new Error("WSol account exists, but failed to decode its content");
-            const parsedAmount = new BN$1(parsed.amount.toString());
+            const parsedAmount = new BN(parsed.amount.toString());
             if (amountToWrap.lte(parsedAmount))
                 return null; // don't need to wrap
-            amountToWrap = parsedAmount.sub(amountToWrap);
+            amountToWrap = amountToWrap.sub(parsedAmount);
         }
         const replenishTx = buildReplenishWsolBalanceTransaction(amountToWrap, owner, wSolATA);
         tx.add(replenishTx);