@layerzerolabs/lz-corekit-solana 3.0.2-initia.5 → 3.0.2

package/CHANGELOG.md

@@ -1,13 +1,5 @@
 # @layerzerolabs/lz-corekit-solana
 
-## 3.0.2-initia.5
-
-### Patch Changes
-
-- Build new initia,aptos,bsc,movement snpashot images(initiad upgrade to 0.5.6)
-- Updated dependencies
-  - @layerzerolabs/lz-core@3.0.2-initia.5
-
 ## 3.0.2
 
 ### Patch Changes

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-var bytes = require('@ethersproject/bytes');
 var web3_js = require('@solana/web3.js');
 var lzCore = require('@layerzerolabs/lz-core');
+var bytes = require('@ethersproject/bytes');
 var bip39 = require('bip39');
 var ed25519HdKey = require('ed25519-hd-key');
 var secp256k1 = require('@noble/secp256k1');
@@ -27,6 +27,398 @@ function _interopNamespace(e) {
 
 var bip39__namespace = /*#__PURE__*/_interopNamespace(bip39);
 
+// src/providers/solana.ts
+
+// ../../../node_modules/.store/@ethersproject-logger-npm-5.7.0-63fe9c3d29/package/lib.esm/_version.js
+var version = "logger/5.7.0";
+
+// ../../../node_modules/.store/@ethersproject-logger-npm-5.7.0-63fe9c3d29/package/lib.esm/index.js
+var _permanentCensorErrors = false;
+var _censorErrors = false;
+var LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 };
+var _logLevel = LogLevels["default"];
+var _globalLogger = null;
+function _checkNormalize() {
+  try {
+    const missing = [];
+    ["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(233).normalize("NFD") !== String.fromCharCode(101, 769)) {
+      throw new Error("broken implementation");
+    }
+  } catch (error) {
+    return error.message;
+  }
+  return null;
+}
+var _normalizeError = _checkNormalize();
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2["DEBUG"] = "DEBUG";
+  LogLevel2["INFO"] = "INFO";
+  LogLevel2["WARNING"] = "WARNING";
+  LogLevel2["ERROR"] = "ERROR";
+  LogLevel2["OFF"] = "OFF";
+})(LogLevel || (LogLevel = {}));
+var ErrorCode;
+(function(ErrorCode2) {
+  ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
+  ErrorCode2["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
+  ErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  ErrorCode2["SERVER_ERROR"] = "SERVER_ERROR";
+  ErrorCode2["TIMEOUT"] = "TIMEOUT";
+  ErrorCode2["BUFFER_OVERRUN"] = "BUFFER_OVERRUN";
+  ErrorCode2["NUMERIC_FAULT"] = "NUMERIC_FAULT";
+  ErrorCode2["MISSING_NEW"] = "MISSING_NEW";
+  ErrorCode2["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
+  ErrorCode2["MISSING_ARGUMENT"] = "MISSING_ARGUMENT";
+  ErrorCode2["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT";
+  ErrorCode2["CALL_EXCEPTION"] = "CALL_EXCEPTION";
+  ErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+  ErrorCode2["NONCE_EXPIRED"] = "NONCE_EXPIRED";
+  ErrorCode2["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED";
+  ErrorCode2["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
+  ErrorCode2["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED";
+  ErrorCode2["ACTION_REJECTED"] = "ACTION_REJECTED";
+})(ErrorCode || (ErrorCode = {}));
+var HEX = "0123456789abcdef";
+var Logger = class _Logger {
+  constructor(version3) {
+    Object.defineProperty(this, "version", {
+      enumerable: true,
+      value: version3,
+      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) {
+    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] & 15];
+          }
+          messageDetails.push(key + "=Uint8Array(0x" + hex + ")");
+        } else {
+          messageDetails.push(key + "=" + JSON.stringify(value));
+        }
+      } catch (error2) {
+        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(", ") + ")";
+    }
+    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
+    });
+  }
+  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 >= 9007199254740991) {
+      this.throwError(message, _Logger.errors.NUMERIC_FAULT, {
+        operation: "checkSafeInteger",
+        fault: "out-of-safe-range",
+        value
+      });
+    }
+    if (value % 1) {
+      this.throwError(message, _Logger.errors.NUMERIC_FAULT, {
+        operation: "checkSafeInteger",
+        fault: "non-integer",
+        value
+      });
+    }
+  }
+  checkArgumentCount(count, expectedCount, message) {
+    if (message) {
+      message = ": " + message;
+    } else {
+      message = "";
+    }
+    if (count < expectedCount) {
+      this.throwError("missing argument" + message, _Logger.errors.MISSING_ARGUMENT, {
+        count,
+        expectedCount
+      });
+    }
+    if (count > expectedCount) {
+      this.throwError("too many arguments" + message, _Logger.errors.UNEXPECTED_ARGUMENT, {
+        count,
+        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);
+    }
+    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(version3) {
+    return new _Logger(version3);
+  }
+};
+Logger.errors = ErrorCode;
+Logger.levels = LogLevel;
+
+// ../../../node_modules/.store/@ethersproject-bytes-npm-5.7.0-4454fe4cb0/package/lib.esm/_version.js
+var version2 = "bytes/5.7.0";
+
+// ../../../node_modules/.store/@ethersproject-bytes-npm-5.7.0-4454fe4cb0/package/lib.esm/index.js
+var logger = new Logger(version2);
+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.checkSafeUint53(value, "invalid arrayify value");
+    const result = [];
+    while (value) {
+      result.unshift(value & 255);
+      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.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.throwArgumentError("invalid arrayify value", "value", value);
+}
+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;
+}
+
+// src/utils.ts
+function toRawTransaction(transaction) {
+  const retval = typeof transaction === "string" ? arrayify(transaction) : transaction.serialize();
+  return retval;
+}
+
 // src/providers/solana.ts
 var SolanaProvider = class _SolanaProvider {
   constructor(url) {
@@ -102,14 +494,16 @@ var SolanaProvider = class _SolanaProvider {
   }
   async sendTransaction(transaction, sendOptions) {
     const _transaction = transaction.signed;
-    const response = await this.nativeProvider.sendRawTransaction(Buffer.from(bytes.arrayify(_transaction)), sendOptions);
+    const rawTransaction = toRawTransaction(_transaction);
+    const response = await this.nativeProvider.sendRawTransaction(rawTransaction, sendOptions);
     return lzCore.TransactionPending.from(response);
   }
   async sendAndConfirm(transaction, opts) {
     const _transaction = transaction.signed;
+    const rawTransaction = toRawTransaction(_transaction);
     const response = await web3_js.sendAndConfirmRawTransaction(
       this.nativeProvider,
-      Buffer.from(bytes.arrayify(_transaction)),
+      Buffer.from(rawTransaction),
       opts
     );
     return lzCore.TransactionReceipt.from(response);
@@ -185,42 +579,26 @@ var SolanaSigner = class {
   }
   async sendAndConfirm(transaction, opts) {
     const provider = this.assertAndGetProvider();
-    const stx = bytes.arrayify(transaction.signed);
-    const response = await web3_js.sendAndConfirmRawTransaction(provider, Buffer.from(stx), opts);
+    const _transaction = transaction.signed;
+    const rawTransaction = toRawTransaction(_transaction);
+    const response = await web3_js.sendAndConfirmRawTransaction(provider, Buffer.from(rawTransaction), opts);
     return lzCore.TransactionReceipt.from(response);
   }
   async sendTransaction(transaction, sendOptions) {
     const provider = this.assertAndGetProvider();
-    const stx = bytes.arrayify(transaction.signed);
-    const response = await provider.sendRawTransaction(stx, sendOptions);
+    const _transaction = transaction.signed;
+    const rawTransaction = toRawTransaction(_transaction);
+    const response = await provider.sendRawTransaction(rawTransaction, sendOptions);
     return lzCore.TransactionPending.from(response);
   }
   async signTransaction(transaction, opts) {
-    const populatedTransaction = transaction.request;
-    const provider = this.assertAndGetProvider();
-    const tx = await this.buildTxByPopulatedTx(populatedTransaction, opts);
+    const tx = transaction.request;
     if (isVersionedTransaction(tx)) {
-      if (populatedTransaction.signers) {
-        tx.sign(populatedTransaction.signers);
-      }
       tx.sign([this.keypair]);
     } else {
-      tx.feePayer = tx.feePayer ?? this.publicKey;
-      tx.recentBlockhash = (await provider.getLatestBlockhash(opts)).blockhash;
-      if (populatedTransaction.signers) {
-        for (const signer of populatedTransaction.signers) {
-          tx.partialSign(signer);
-        }
-      }
-      if (populatedTransaction.lzSingers) {
-        for (const signer of populatedTransaction.lzSingers) {
-          signer.partialSign(tx);
-        }
-      }
       tx.partialSign(this.keypair);
     }
-    const response = bytes.hexlify(tx.serialize());
-    return lzCore.SignedTransaction.from(response);
+    return Promise.resolve(lzCore.SignedTransaction.from(tx));
   }
   async signBuffer(_buffer) {
     await Promise.resolve();
@@ -233,17 +611,6 @@ var SolanaSigner = class {
       tx.partialSign(this.keypair);
     }
   }
-  async buildTxByPopulatedTx(populatedTransaction, commitmentOrConfig) {
-    const provider = this.assertAndGetProvider();
-    const tx = new web3_js.VersionedTransaction(
-      new web3_js.TransactionMessage({
-        payerKey: this.publicKey,
-        recentBlockhash: await provider.getLatestBlockhash(commitmentOrConfig).then((r) => r.blockhash),
-        instructions: populatedTransaction.instructions
-      }).compileToV0Message()
-    );
-    return tx;
-  }
   assertAndGetProvider() {
     if (!this.provider) {
       throw new Error("Signer was not connected to a provider, did you forgot to connect to provider?");