@layerzerolabs/lz-v2-utilities 3.0.7 → 3.0.8

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @layerzerolabs/lz-v2-utilities
 
+## 3.0.8
+
+### Patch Changes
+
+- 1cd5e8e: support READ library
+
 ## 3.0.7
 
 ### Patch Changes

package/dist/index.cjs

@@ -172,6 +172,7 @@ var ExecutorOptionType = /* @__PURE__ */ ((ExecutorOptionType2) => {
   ExecutorOptionType2[ExecutorOptionType2["NATIVE_DROP"] = 2] = "NATIVE_DROP";
   ExecutorOptionType2[ExecutorOptionType2["COMPOSE"] = 3] = "COMPOSE";
   ExecutorOptionType2[ExecutorOptionType2["ORDERED"] = 4] = "ORDERED";
+  ExecutorOptionType2[ExecutorOptionType2["LZ_READ"] = 5] = "LZ_READ";
   return ExecutorOptionType2;
 })(ExecutorOptionType || {});
 var VerifierOptionType = /* @__PURE__ */ ((VerifierOptionType2) => {
@@ -297,6 +298,16 @@ var Options = class _Options {
     });
     return this;
   }
+  addExecutorLzReadOption(gasLimit, dataSize, nativeDrop = 0) {
+    const gasLimitBN = bignumber.BigNumber.from(gasLimit);
+    const dataSizeBN = bignumber.BigNumber.from(dataSize);
+    const nativeDropBN = bignumber.BigNumber.from(nativeDrop);
+    this.addOption(1 /* EXECUTOR */, {
+      type: 5 /* LZ_READ */,
+      params: nativeDropBN.eq(0) ? solidity.pack(["uint128", "uint32"], [gasLimitBN, dataSizeBN]) : solidity.pack(["uint128", "uint32", "uint128"], [gasLimitBN, dataSizeBN, nativeDropBN])
+    });
+    return this;
+  }
   /**
    * Add VerifierOptionType.PRECRIME option.
    * @param {number} verifierIdx
@@ -431,6 +442,29 @@ var Options = class _Options {
     const option = this.findOptions(1 /* EXECUTOR */, 4 /* ORDERED */);
     return option !== void 0;
   }
+  /**
+   * Decode ExecutorOptionType.LZ_READ options.  Returns undefined if the options is not present.
+   */
+  decodeExecutorLzReadOption() {
+    let options = this.findOptions(1 /* EXECUTOR */, 5 /* LZ_READ */);
+    if (options === void 0 || Array.isArray(options) && options.length === 0) {
+      return void 0;
+    }
+    let totalGas = bignumber.BigNumber.from(0).toBigInt();
+    let dataSize = bignumber.BigNumber.from(0).toBigInt();
+    let totalValue = bignumber.BigNumber.from(0).toBigInt();
+    options = Array.isArray(options) ? options : [options];
+    for (const option of options) {
+      const buffer = Buffer.from(trim0x(option.params), "hex");
+      const gas = bignumber.BigNumber.from(buffer.subarray(0, 16)).toBigInt();
+      const size = bignumber.BigNumber.from(buffer.subarray(16, 20)).toBigInt();
+      const value = bignumber.BigNumber.from(buffer.length === 20 ? 0 : buffer.subarray(20, 32)).toBigInt();
+      totalGas = totalGas + gas;
+      dataSize = dataSize + size;
+      totalValue = totalValue + value;
+    }
+    return { gas: totalGas, dataSize, value: totalValue };
+  }
   findOptions(workerId, optionType) {
     const worker = this.workerOptions.find((w) => w.workerId === workerId);
     if (worker) {
@@ -605,15 +639,396 @@ var PacketSerializer = class {
   }
 };
 
+// src/commandCodec/commandCodec.ts
+var Codec = class {
+  byteLength;
+  constructor() {
+    this.byteLength = 0;
+  }
+  getByteLength() {
+    return this.byteLength;
+  }
+  getHexLength() {
+    return this.byteLength * 2;
+  }
+  static decode(hex) {
+    throw new Error("Not implemented");
+  }
+};
+var TimestampBlockConfiguration = /* @__PURE__ */ ((TimestampBlockConfiguration2) => {
+  TimestampBlockConfiguration2[TimestampBlockConfiguration2["Timestamp"] = 0] = "Timestamp";
+  TimestampBlockConfiguration2[TimestampBlockConfiguration2["BlockNumber"] = 1] = "BlockNumber";
+  return TimestampBlockConfiguration2;
+})(TimestampBlockConfiguration || {});
+var ResolverType = /* @__PURE__ */ ((ResolverType2) => {
+  ResolverType2[ResolverType2["SingleViewFunctionEVMCall"] = 1] = "SingleViewFunctionEVMCall";
+  return ResolverType2;
+})(ResolverType || {});
+var ComputeSetting = /* @__PURE__ */ ((ComputeSetting2) => {
+  ComputeSetting2[ComputeSetting2["OnlyMap"] = 0] = "OnlyMap";
+  ComputeSetting2[ComputeSetting2["OnlyReduce"] = 1] = "OnlyReduce";
+  ComputeSetting2[ComputeSetting2["MapReduce"] = 2] = "MapReduce";
+  return ComputeSetting2;
+})(ComputeSetting || {});
+var ComputeType = /* @__PURE__ */ ((ComputeType2) => {
+  ComputeType2[ComputeType2["SingleViewFunctionEVMCall"] = 1] = "SingleViewFunctionEVMCall";
+  return ComputeType2;
+})(ComputeType || {});
+var Header = class _Header extends Codec {
+  globalVersion;
+  // 2 bytes
+  appCommandLabel;
+  // 2 bytes
+  requestCount;
+  // 2 bytes
+  static GLOBAL_VERSION_BYTES = 2;
+  static APP_COMMAND_LABEL_BYTES = 2;
+  static REQUEST_COUNT_BYTES = 2;
+  constructor(globalVersion, appCommandLabel, requestCount) {
+    super();
+    this.globalVersion = globalVersion;
+    this.appCommandLabel = appCommandLabel;
+    this.requestCount = requestCount;
+    this.byteLength = _Header.GLOBAL_VERSION_BYTES + _Header.APP_COMMAND_LABEL_BYTES + _Header.REQUEST_COUNT_BYTES;
+  }
+  encode() {
+    const globalVersionHex = numberToHex(this.globalVersion, _Header.GLOBAL_VERSION_BYTES);
+    const appCommandLabelHex = this.appCommandLabel.padStart(bytesToHexLength(_Header.APP_COMMAND_LABEL_BYTES), "0");
+    const requestCountHex = numberToHex(this.requestCount, _Header.REQUEST_COUNT_BYTES);
+    return globalVersionHex + appCommandLabelHex + requestCountHex;
+  }
+  static decode(hex, offset) {
+    let internalOffset = offset ?? 0;
+    const globalVersion = hexToNumber(sliceHex(hex, internalOffset, _Header.GLOBAL_VERSION_BYTES));
+    internalOffset += bytesToHexLength(_Header.GLOBAL_VERSION_BYTES);
+    const appCommandLabel = sliceHex(hex, internalOffset, _Header.APP_COMMAND_LABEL_BYTES);
+    internalOffset += bytesToHexLength(_Header.APP_COMMAND_LABEL_BYTES);
+    const requestCount = hexToNumber(sliceHex(hex, internalOffset, _Header.REQUEST_COUNT_BYTES));
+    return new _Header(globalVersion, appCommandLabel, requestCount);
+  }
+};
+var RequestHeader = class _RequestHeader extends Codec {
+  requestVersion;
+  // 1 byte
+  appRequestLabel;
+  // 2 bytes (hex or string)
+  resolverType;
+  // 2 bytes
+  requestSize;
+  // 2 bytes
+  static REQUEST_VERSION_BYTES = 1;
+  static APP_REQUEST_LABEL_BYTES = 2;
+  static RESOLVER_TYPE_BYTES = 2;
+  static REQUEST_SIZE_BYTES = 2;
+  constructor(requestVersion, appRequestLabel, resolverType, requestSize) {
+    super();
+    this.requestVersion = requestVersion;
+    this.appRequestLabel = appRequestLabel;
+    this.resolverType = resolverType;
+    this.requestSize = requestSize;
+    this.byteLength = _RequestHeader.REQUEST_VERSION_BYTES + _RequestHeader.APP_REQUEST_LABEL_BYTES + _RequestHeader.RESOLVER_TYPE_BYTES + _RequestHeader.REQUEST_SIZE_BYTES;
+  }
+  encode() {
+    const requestVersionHex = numberToHex(this.requestVersion, _RequestHeader.REQUEST_VERSION_BYTES);
+    const appRequestLabelHex = this.appRequestLabel.padStart(
+      bytesToHexLength(_RequestHeader.APP_REQUEST_LABEL_BYTES),
+      "0"
+    );
+    const resolverTypeHex = numberToHex(this.resolverType, _RequestHeader.RESOLVER_TYPE_BYTES);
+    const requestSizeHex = numberToHex(this.requestSize, _RequestHeader.REQUEST_SIZE_BYTES);
+    return requestVersionHex + appRequestLabelHex + resolverTypeHex + requestSizeHex;
+  }
+  static decode(hex, offset) {
+    let internalOffset = offset ?? 0;
+    const requestVersion = hexToNumber(sliceHex(hex, internalOffset, _RequestHeader.REQUEST_VERSION_BYTES));
+    internalOffset += bytesToHexLength(_RequestHeader.REQUEST_VERSION_BYTES);
+    const appRequestLabel = sliceHex(hex, internalOffset, _RequestHeader.APP_REQUEST_LABEL_BYTES);
+    internalOffset += bytesToHexLength(_RequestHeader.APP_REQUEST_LABEL_BYTES);
+    const resolverType = hexToNumber(sliceHex(hex, internalOffset, _RequestHeader.RESOLVER_TYPE_BYTES));
+    internalOffset += bytesToHexLength(_RequestHeader.RESOLVER_TYPE_BYTES);
+    const requestSize = hexToNumber(sliceHex(hex, internalOffset, _RequestHeader.REQUEST_SIZE_BYTES));
+    return new _RequestHeader(requestVersion, appRequestLabel, resolverType, requestSize);
+  }
+};
+var EVMBase = class _EVMBase extends Codec {
+  targetEid;
+  // 4 bytes
+  timestampBlockFlag;
+  // 1 byte
+  blockConfirmations;
+  // 2 bytes
+  to;
+  // 20 bytes (hex or string)
+  timestamp;
+  // 8 bytes (if timestampBlockFlag indicates Unix timestamp)
+  blockNumber;
+  // 8 bytes (if timestampBlockFlag indicates block number)
+  static TARGET_EID_BYTES = 4;
+  static TIMESTAMP_BLOCK_FLAG_BYTES = 1;
+  static BLOCK_CONFIRMATIONS_BYTES = 2;
+  static TO_BYTES = 20;
+  static TIMESTAMP_BYTES = 8;
+  static BLOCK_NUMBER_BYTES = 8;
+  constructor(targetEid, timestampBlockFlag, blockConfirmations, to, timestamp, blockNumber) {
+    super();
+    this.targetEid = targetEid;
+    this.timestampBlockFlag = timestampBlockFlag;
+    this.blockConfirmations = blockConfirmations;
+    this.to = to;
+    this.timestamp = timestamp;
+    this.blockNumber = blockNumber;
+    this.byteLength = _EVMBase.TARGET_EID_BYTES + _EVMBase.TIMESTAMP_BLOCK_FLAG_BYTES + _EVMBase.BLOCK_CONFIRMATIONS_BYTES + _EVMBase.TO_BYTES + (timestamp !== void 0 ? _EVMBase.TIMESTAMP_BYTES : 0) + (blockNumber !== void 0 ? _EVMBase.BLOCK_NUMBER_BYTES : 0);
+  }
+  encode() {
+    const targetEidHex = numberToHex(this.targetEid, _EVMBase.TARGET_EID_BYTES);
+    const timestampBlockFlagHex = numberToHex(this.timestampBlockFlag, _EVMBase.TIMESTAMP_BLOCK_FLAG_BYTES);
+    const blockNumberHex = this.blockNumber !== void 0 ? bigIntToHex(this.blockNumber, _EVMBase.BLOCK_NUMBER_BYTES) : void 0;
+    const timestampHex = this.timestamp !== void 0 ? bigIntToHex(this.timestamp, _EVMBase.TIMESTAMP_BYTES) : void 0;
+    if (timestampHex !== void 0 && blockNumberHex !== void 0) {
+      throw new Error("Cannot have both timestamp and block number");
+    }
+    const blockConfirmationsHex = numberToHex(this.blockConfirmations, _EVMBase.BLOCK_CONFIRMATIONS_BYTES);
+    const toHex = this.to.padStart(bytesToHexLength(_EVMBase.TO_BYTES), "0");
+    const blockOrTimestampHex = blockNumberHex ?? timestampHex;
+    if (blockOrTimestampHex === void 0) {
+      throw new Error("Either block number or timestamp must be set");
+    }
+    return targetEidHex + timestampBlockFlagHex + blockOrTimestampHex + blockConfirmationsHex + toHex;
+  }
+  static decode(hex, offset) {
+    let internalOffset = offset ?? 0;
+    const targetEid = hexToNumber(sliceHex(hex, internalOffset, _EVMBase.TARGET_EID_BYTES));
+    internalOffset += bytesToHexLength(_EVMBase.TARGET_EID_BYTES);
+    const timestampBlockFlag = hexToNumber(
+      sliceHex(hex, internalOffset, _EVMBase.TIMESTAMP_BLOCK_FLAG_BYTES)
+    );
+    internalOffset += bytesToHexLength(_EVMBase.TIMESTAMP_BLOCK_FLAG_BYTES);
+    let timestamp;
+    let blockNumber;
+    if (timestampBlockFlag === 0 /* Timestamp */) {
+      timestamp = hexToBigInt(sliceHex(hex, internalOffset, _EVMBase.TIMESTAMP_BYTES));
+      internalOffset += bytesToHexLength(_EVMBase.TIMESTAMP_BYTES);
+    } else {
+      blockNumber = hexToBigInt(sliceHex(hex, internalOffset, _EVMBase.BLOCK_NUMBER_BYTES));
+      internalOffset += bytesToHexLength(_EVMBase.BLOCK_NUMBER_BYTES);
+    }
+    const blockConfirmations = hexToNumber(sliceHex(hex, internalOffset, _EVMBase.BLOCK_CONFIRMATIONS_BYTES));
+    internalOffset += bytesToHexLength(_EVMBase.BLOCK_CONFIRMATIONS_BYTES);
+    const to = sliceHex(hex, internalOffset, _EVMBase.TO_BYTES);
+    return new _EVMBase(targetEid, timestampBlockFlag, blockConfirmations, to, timestamp, blockNumber);
+  }
+};
+var SingleViewFunctionEVMCall = class _SingleViewFunctionEVMCall extends EVMBase {
+  requestHeader;
+  calldata;
+  // Calldata (size specified by calldataSize)
+  constructor(requestHeader, targetEid, timestampBlockFlag, blockConfirmations, to, calldata, timestamp, blockNumber) {
+    super(targetEid, timestampBlockFlag, blockConfirmations, to, timestamp, blockNumber);
+    this.requestHeader = requestHeader;
+    this.calldata = calldata;
+    const evmByteLength = super.getByteLength();
+    const callDataSize = this.requestHeader.requestSize - evmByteLength;
+    this.byteLength = this.requestHeader.getByteLength() + evmByteLength + callDataSize;
+  }
+  encode() {
+    const requestHeaderHex = this.requestHeader.encode();
+    const evmBaseHex = super.encode();
+    const callDataSize = this.requestHeader.requestSize - super.getByteLength();
+    const calldataHex = this.calldata.padStart(callDataSize * 2, "0");
+    return requestHeaderHex + evmBaseHex + calldataHex;
+  }
+  static decode(hex, offset) {
+    let internalOffset = offset ?? 0;
+    const requestHeader = RequestHeader.decode(hex, internalOffset);
+    internalOffset += requestHeader.getHexLength();
+    const evmBase = super.decode(hex, internalOffset);
+    internalOffset += evmBase.getHexLength();
+    const calldataSize = requestHeader.requestSize - evmBase.getByteLength();
+    const calldata = sliceHex(hex, internalOffset, calldataSize);
+    return new _SingleViewFunctionEVMCall(
+      requestHeader,
+      evmBase.targetEid,
+      evmBase.timestampBlockFlag,
+      evmBase.blockConfirmations,
+      evmBase.to,
+      calldata,
+      evmBase.timestamp,
+      evmBase.blockNumber
+    );
+  }
+};
+var ComputeHeader = class _ComputeHeader extends Codec {
+  computeVersion;
+  // 1 byte
+  computeType;
+  // 2 bytes
+  computeSetting;
+  // 1 byte
+  static COMPUTE_VERSION_BYTES = 1;
+  static COMPUTE_TYPE_BYTES = 2;
+  static COMPUTE_SETTING_BYTES = 1;
+  constructor(computeVersion, computeType, computeSetting) {
+    super();
+    this.computeVersion = computeVersion;
+    this.computeType = computeType;
+    this.computeSetting = computeSetting;
+    this.byteLength = _ComputeHeader.COMPUTE_VERSION_BYTES + _ComputeHeader.COMPUTE_TYPE_BYTES + _ComputeHeader.COMPUTE_SETTING_BYTES;
+  }
+  encode() {
+    const computeVersionHex = numberToHex(this.computeVersion, _ComputeHeader.COMPUTE_VERSION_BYTES);
+    const computeTypeHex = numberToHex(this.computeType, _ComputeHeader.COMPUTE_TYPE_BYTES);
+    const computeSettingHex = numberToHex(this.computeSetting, _ComputeHeader.COMPUTE_SETTING_BYTES);
+    return computeVersionHex + computeTypeHex + computeSettingHex;
+  }
+  static decode(hex, offset) {
+    let internalOffset = offset ?? 0;
+    const computeVersion = hexToNumber(sliceHex(hex, internalOffset, _ComputeHeader.COMPUTE_VERSION_BYTES));
+    internalOffset += bytesToHexLength(_ComputeHeader.COMPUTE_VERSION_BYTES);
+    const computeType = hexToNumber(sliceHex(hex, internalOffset, _ComputeHeader.COMPUTE_TYPE_BYTES));
+    internalOffset += bytesToHexLength(_ComputeHeader.COMPUTE_TYPE_BYTES);
+    const computeSetting = hexToNumber(sliceHex(hex, internalOffset, _ComputeHeader.COMPUTE_SETTING_BYTES));
+    return new _ComputeHeader(computeVersion, computeType, computeSetting);
+  }
+};
+var ComputeEVM = class _ComputeEVM extends EVMBase {
+  computeHeader;
+  constructor(computeHeader, targetEid, timestampBlockFlag, blockConfirmations, to, timestamp, blockNumber) {
+    super(targetEid, timestampBlockFlag, blockConfirmations, to, timestamp, blockNumber);
+    this.computeHeader = computeHeader;
+    const evmByteLength = super.getByteLength();
+    this.byteLength += evmByteLength + this.computeHeader.getByteLength();
+  }
+  encode() {
+    const computeHeaderHex = this.computeHeader.encode();
+    const evmBaseHex = super.encode();
+    return computeHeaderHex + evmBaseHex;
+  }
+  static decode(hex, offset) {
+    let internalOffset = offset ?? 0;
+    const computeHeader = ComputeHeader.decode(hex, internalOffset);
+    internalOffset += computeHeader.getHexLength();
+    const evmBase = EVMBase.decode(hex, internalOffset);
+    internalOffset += evmBase.getHexLength();
+    return new _ComputeEVM(
+      computeHeader,
+      evmBase.targetEid,
+      evmBase.timestampBlockFlag,
+      evmBase.blockConfirmations,
+      evmBase.to,
+      evmBase.timestamp,
+      evmBase.blockNumber
+    );
+  }
+};
+var Command = class _Command extends Codec {
+  header;
+  requests;
+  compute;
+  constructor(header, requests, compute) {
+    super();
+    this.header = header;
+    this.requests = requests;
+    this.compute = compute;
+    this.byteLength = this.header.getByteLength() + this.requests.reduce((acc, req) => acc + req.getByteLength(), 0) + (this.compute ? this.compute.getByteLength() : 0);
+  }
+  encodeCommandRequest(request) {
+    switch (request.requestHeader.resolverType) {
+      case 1 /* SingleViewFunctionEVMCall */:
+        return request.encode();
+      default:
+        throw new Error("Invalid resolver type");
+    }
+  }
+  encodeCompute() {
+    if (!this.compute) {
+      return "";
+    }
+    switch (this.compute.computeHeader.computeType) {
+      case 1 /* SingleViewFunctionEVMCall */:
+        return this.compute.encode();
+      default:
+        throw new Error("Invalid compute type");
+    }
+  }
+  encode() {
+    const headerHex = this.header.encode();
+    const requestsHex = this.requests.map((req) => this.encodeCommandRequest(req)).join("");
+    const computeHex = this.encodeCompute();
+    return headerHex + requestsHex + computeHex;
+  }
+  static decodeRequest(hex, offset) {
+    const requestHeader = RequestHeader.decode(hex, offset);
+    switch (requestHeader.resolverType) {
+      case 1 /* SingleViewFunctionEVMCall */:
+        return SingleViewFunctionEVMCall.decode(hex, offset);
+      default:
+        throw new Error("Invalid resolver type");
+    }
+  }
+  static decodeCompute(hex, offset) {
+    const computeHeader = ComputeHeader.decode(hex, offset);
+    switch (computeHeader.computeType) {
+      case 1 /* SingleViewFunctionEVMCall */:
+        return ComputeEVM.decode(hex, offset);
+      default:
+        throw new Error("Invalid compute type");
+    }
+  }
+  static decode(hex, offset) {
+    let internalOffset = offset ?? 0;
+    const header = Header.decode(hex, internalOffset);
+    internalOffset += header.getHexLength();
+    const requests = [];
+    for (let i = 0; i < header.requestCount; i++) {
+      const request = _Command.decodeRequest(hex, internalOffset);
+      requests.push(request);
+      internalOffset += request.getHexLength();
+    }
+    const command = internalOffset === hex.length ? new _Command(header, requests) : new _Command(header, requests, _Command.decodeCompute(hex, internalOffset));
+    return command;
+  }
+};
+function bytesToHexLength(bytes) {
+  return bytes * 2;
+}
+function sliceHex(hex, offset, bytes) {
+  const length = bytesToHexLength(bytes);
+  const slice = hex.slice(offset, offset + length);
+  return slice;
+}
+function hexToNumber(hexStr) {
+  return parseInt(hexStr, 16);
+}
+function hexToBigInt(hexStr) {
+  return BigInt(`0x${hexStr}`);
+}
+function numberToHex(num, bytes) {
+  return num.toString(16).padStart(bytes * 2, "0");
+}
+function bigIntToHex(bigInt, bytes) {
+  return bigInt.toString(16).padStart(bytes * 2, "0");
+}
+
 Object.defineProperty(exports, "keccak256", {
   enumerable: true,
   get: function () { return keccak256.keccak256; }
 });
+exports.Command = Command;
+exports.ComputeEVM = ComputeEVM;
+exports.ComputeHeader = ComputeHeader;
+exports.ComputeSetting = ComputeSetting;
+exports.ComputeType = ComputeType;
+exports.EVMBase = EVMBase;
 exports.ExecutorOptionType = ExecutorOptionType;
+exports.Header = Header;
 exports.OptionType = OptionType;
 exports.Options = Options;
 exports.PacketSerializer = PacketSerializer;
 exports.PacketV1Codec = PacketV1Codec;
+exports.RequestHeader = RequestHeader;
+exports.ResolverType = ResolverType;
+exports.SingleViewFunctionEVMCall = SingleViewFunctionEVMCall;
+exports.TimestampBlockConfiguration = TimestampBlockConfiguration;
 exports.VerifierOptionType = VerifierOptionType;
 exports.WorkerId = WorkerId;
 exports.addressToBytes32 = addressToBytes32;