viem 0.0.1-alpha.0 → 0.0.1-alpha.2

package/dist/{chunk-GI67STNV.js → chunk-3EOU525X.js}

@@ -9,15 +9,29 @@ var __publicField = (obj, key, value) => {
 var package_default = {
   name: "viem",
   description: "TypeScript (& JavaScript) Interface for Ethereum",
-  version: "0.0.1-alpha.0",
+  version: "0.0.1-alpha.2",
   scripts: {
+    anvil: "source .env && anvil --fork-url $ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
+    bench: "vitest bench --no-threads",
+    "bench:ci": "CI=true vitest bench --no-threads",
     build: "tsup",
-    dev: "DEV=true tsup"
-  },
-  dependencies: {
-    "@noble/hashes": "^1.1.2",
-    "@wagmi/chains": "^0.1.0",
-    abitype: "^0.2.5"
+    changeset: "changeset",
+    "changeset:release": "pnpm build && changeset publish",
+    "changeset:version": "changeset version && pnpm install --lockfile-only",
+    dev: "DEV=true tsup",
+    "dev:docs": "pnpm -r --filter site dev",
+    format: "rome format src/ test/ --write",
+    lint: "rome check .",
+    "lint:fix": "pnpm lint --apply-suggested",
+    playground: "pnpm --filter playground-dev dev",
+    "playground:benchmark": "pnpm --filter playground-benchmark dev",
+    postinstall: "pnpm dev",
+    preinstall: "npx only-allow pnpm",
+    prepare: "npx simple-git-hooks",
+    test: "vitest dev --coverage --no-threads",
+    "test:ci": "CI=true vitest --coverage --no-threads",
+    "test:ui": "vitest dev --ui --no-threads",
+    typecheck: "tsc --noEmit"
   },
   files: [
     "/actions",
@@ -59,17 +73,60 @@ var package_default = {
   main: "dist/index.js",
   types: "dist/index.d.ts",
   sideEffects: false,
-  license: "WAGMIT",
+  dependencies: {
+    "@noble/hashes": "^1.1.2",
+    "@wagmi/chains": "^0.1.0",
+    abitype: "^0.2.5"
+  },
+  devDependencies: {
+    "@actions/core": "^1.10.0",
+    "@actions/github": "^5.1.1",
+    "@changesets/changelog-github": "^0.4.5",
+    "@changesets/cli": "^2.23.2",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@types/dedent": "^0.7.0",
+    "@types/fs-extra": "^9.0.13",
+    "@types/node": "^17.0.45",
+    "@vitest/coverage-c8": "^0.24.3",
+    "@vitest/ui": "^0.19.1",
+    bundlewatch: "^0.3.3",
+    dedent: "^0.7.0",
+    esbuild: "^0.16.12",
+    "esbuild-register": "^3.4.2",
+    "essential-eth": "^0.6.2",
+    ethers: "^5.7.2",
+    execa: "^6.1.0",
+    "fs-extra": "^10.1.0",
+    jsdom: "^20.0.0",
+    rome: "^11.0.0",
+    "simple-git-hooks": "^2.8.1",
+    tsup: "^6.5.0",
+    typescript: "^4.9.3",
+    vite: "^3.0.4",
+    vitest: "^0.25.2",
+    web3: "^1.8.1"
+  },
+  license: "MIT",
   repository: "wagmi-dev/viem",
-  author: "moxey.eth",
-  ethereum: "moxey.eth",
+  authors: [
+    "awkweb.eth",
+    "jxom.eth"
+  ],
   keywords: [
     "eth",
     "ethereum",
     "dapps",
     "wallet",
     "web3"
-  ]
+  ],
+  "simple-git-hooks": {
+    "pre-commit": "pnpm format & pnpm lint:fix"
+  },
+  pnpm: {
+    patchedDependencies: {
+      "vitepress@1.0.0-alpha.34": "patches/vitepress@1.0.0-alpha.34.patch"
+    }
+  }
 };
 
 // src/utils/BaseError.ts
@@ -80,11 +137,11 @@ var BaseError = class extends Error {
     const docsPath = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
     const message = [
       humanMessage,
-      ...docsPath ? ["", "Docs: https://viem.sh" + docsPath] : [],
+      ...docsPath ? ["", `Docs: https://viem.sh${docsPath}`] : [],
       "",
-      ...details ? ["Details: " + details] : [],
-      "Version: viem@" + version,
-      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? ["Internal Error: " + JSON.stringify(args.cause)] : []
+      ...details ? [`Details: ${details}`] : [],
+      `Version: viem@${version}`,
+      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? [`Internal Error: ${JSON.stringify(args.cause)}`] : []
     ].join("\n");
     super(message);
     __publicField(this, "humanMessage");
@@ -157,7 +214,10 @@ function padHex(hex_, { dir, size: size2 = 32 } = {}) {
       targetSize: size2,
       type: "hex"
     });
-  return "0x" + hex[dir === "right" ? "padEnd" : "padStart"](size2 * 2, "0");
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](
+    size2 * 2,
+    "0"
+  )}`;
 }
 function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
   if (bytes.length > size2)
@@ -199,7 +259,7 @@ function trim(hexOrBytes, { dir = "left" } = {}) {
   data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
   if (typeof hexOrBytes === "string") {
     if (data.length === 1 && dir === "right")
-      data = data + "0";
+      data = `${data}0`;
     return `0x${data}`;
   }
   return data;
@@ -312,7 +372,7 @@ function encodeBytes(value) {
 function hexToBytes(hex_) {
   let hex = hex_.slice(2);
   if (hex.length % 2)
-    hex = "0" + hex;
+    hex = `0${hex}`;
   const bytes = new Uint8Array(hex.length / 2);
   for (let index = 0; index < bytes.length; index++) {
     const start = index * 2;
@@ -372,18 +432,26 @@ function decodeHex(hex, to) {
     return hexToBool(hex);
   return hexToBytes(hex);
 }
-function hexToBigInt(hex) {
-  return BigInt(hex);
+function hexToBigInt(hex, opts = {}) {
+  const { signed } = opts;
+  const value = BigInt(hex);
+  if (!signed)
+    return value;
+  const size2 = (hex.length - 2) / 2;
+  const max = (1n << BigInt(size2) * 8n - 1n) - 1n;
+  if (value <= max)
+    return value;
+  return value - BigInt(`0x${"f".padStart(size2 * 2, "f")}`) - 1n;
 }
 function hexToBool(hex) {
-  if (hex === "0x0")
+  if (trim(hex) === "0x0")
     return false;
-  if (hex === "0x1")
+  if (trim(hex) === "0x1")
     return true;
   throw new InvalidHexBooleanError(hex);
 }
-function hexToNumber(hex) {
-  return Number(BigInt(hex));
+function hexToNumber(hex, opts = {}) {
+  return Number(hexToBigInt(hex, opts));
 }
 function hexToString(hex) {
   const bytes = hexToBytes(hex);
@@ -597,7 +665,7 @@ function hashFunction(def) {
 var getEventSignature = (event) => hashFunction(event);
 
 // src/utils/hash/getFunctionSignature.ts
-var getFunctionSignature = (fn) => hashFunction(fn).slice(0, 10);
+var getFunctionSignature = (fn) => slice(hashFunction(fn), 0, 4);
 
 // src/utils/address/getAddress.ts
 var addressRegex = /^(0x)?[a-fA-F0-9]{40}$/;
@@ -639,7 +707,7 @@ function getCreateAddress(opts) {
   if (nonce[0] === 0)
     nonce = new Uint8Array([]);
   return getAddress(
-    "0x" + keccak256(encodeRlp([from, nonce], "bytes")).slice(26)
+    `0x${keccak256(encodeRlp([from, nonce], "bytes")).slice(26)}`
   );
 }
 function getCreate2Address(opts) {
@@ -675,6 +743,512 @@ function isAddressEqual(a, b) {
   return getAddress(a) === getAddress(b);
 }
 
+// src/utils/abi/encodeAbi.ts
+function encodeAbi({
+  params,
+  values
+}) {
+  if (params.length !== values.length)
+    throw new AbiEncodingLengthMismatchError({
+      expectedLength: params.length,
+      givenLength: values.length
+    });
+  const preparedParams = prepareParams({ params, values });
+  const data = encodeParams(preparedParams);
+  if (data.length === 0)
+    return void 0;
+  return data;
+}
+function prepareParams({
+  params,
+  values
+}) {
+  let preparedParams = [];
+  for (let i = 0; i < params.length; i++) {
+    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
+  }
+  return preparedParams;
+}
+function prepareParam({
+  param,
+  value
+}) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return encodeArray(value, { length, param: { ...param, type } });
+  }
+  if (param.type === "tuple") {
+    return encodeTuple(value, {
+      param
+    });
+  }
+  if (param.type === "address") {
+    return encodeAddress(value);
+  }
+  if (param.type === "bool") {
+    return encodeBool(value);
+  }
+  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+    const signed = param.type.startsWith("int");
+    return encodeNumber(value, { signed });
+  }
+  if (param.type.startsWith("bytes")) {
+    return encodeBytes2(value, { param });
+  }
+  if (param.type === "string") {
+    return encodeString(value);
+  }
+  throw new InvalidAbiEncodingTypeError(param.type);
+}
+function encodeParams(preparedParams) {
+  let staticSize = 0;
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic)
+      staticSize += 32;
+    else
+      staticSize += size(encoded);
+  }
+  let staticParams = [];
+  let dynamicParams = [];
+  let dynamicSize = 0;
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic) {
+      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
+      dynamicParams.push(encoded);
+      dynamicSize += size(encoded);
+    } else {
+      staticParams.push(encoded);
+    }
+  }
+  return concat([...staticParams, ...dynamicParams]);
+}
+function encodeArray(value, {
+  length,
+  param
+}) {
+  let dynamic = length === null;
+  if (!Array.isArray(value))
+    throw new InvalidArrayError(value);
+  if (!dynamic && value.length !== length)
+    throw new AbiEncodingArrayLengthMismatchError({
+      expectedLength: length,
+      givenLength: value.length,
+      type: `${param.type}[${length}]`
+    });
+  let dynamicChild = false;
+  let preparedParams = [];
+  for (let i = 0; i < value.length; i++) {
+    const preparedParam = prepareParam({ param, value: value[i] });
+    if (preparedParam.dynamic)
+      dynamicChild = true;
+    preparedParams.push(preparedParam);
+  }
+  if (dynamic || dynamicChild) {
+    const data = encodeParams(preparedParams);
+    if (dynamic) {
+      const length2 = numberToHex(preparedParams.length, { size: 32 });
+      return {
+        dynamic: true,
+        encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
+      };
+    }
+    if (dynamicChild)
+      return { dynamic: true, encoded: data };
+  }
+  return {
+    dynamic: false,
+    encoded: concat(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function encodeTuple(value, { param }) {
+  let dynamic = false;
+  let preparedParams = [];
+  for (let i = 0; i < param.components.length; i++) {
+    const param_ = param.components[i];
+    const index = Array.isArray(value) ? i : param_.name;
+    const preparedParam = prepareParam({
+      param: param_,
+      value: value[index]
+    });
+    preparedParams.push(preparedParam);
+    dynamic = preparedParam.dynamic;
+  }
+  return {
+    dynamic,
+    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function encodeAddress(value) {
+  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+}
+function encodeBytes2(value, { param }) {
+  const [_, size_] = param.type.split("bytes");
+  if (!size_)
+    return {
+      dynamic: true,
+      encoded: concat([
+        padHex(numberToHex(size(value), { size: 32 })),
+        padHex(value, { dir: "right" })
+      ])
+    };
+  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
+}
+function encodeBool(value) {
+  return { dynamic: false, encoded: padHex(boolToHex(value)) };
+}
+function encodeNumber(value, { signed }) {
+  return {
+    dynamic: false,
+    encoded: numberToHex(value, {
+      size: 32,
+      signed
+    })
+  };
+}
+function encodeString(value) {
+  return {
+    dynamic: true,
+    encoded: concat([
+      padHex(numberToHex(value.length, { size: 32 })),
+      padHex(stringToHex(value), { dir: "right" })
+    ])
+  };
+}
+function getArrayComponents(type) {
+  const matches = type.match(/^(.*)\[(\d+)?\]$/);
+  return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : void 0;
+}
+var AbiEncodingArrayLengthMismatchError = class extends BaseError {
+  constructor({
+    expectedLength,
+    givenLength,
+    type
+  }) {
+    super(
+      [
+        `ABI encoding array length mismatch for type ${type}.`,
+        `Expected length: ${expectedLength}`,
+        `Given length: ${givenLength}`
+      ].join("\n")
+    );
+    __publicField(this, "name", "AbiEncodingArrayLengthMismatchError");
+  }
+};
+var AbiEncodingLengthMismatchError = class extends BaseError {
+  constructor({
+    expectedLength,
+    givenLength
+  }) {
+    super(
+      [
+        "ABI encoding params/values length mismatch.",
+        `Expected length (params): ${expectedLength}`,
+        `Given length (values): ${givenLength}`
+      ].join("\n")
+    );
+    __publicField(this, "name", "AbiEncodingLengthMismatchError");
+  }
+};
+var InvalidAbiEncodingTypeError = class extends BaseError {
+  constructor(type) {
+    super(
+      [
+        `Type "${type}" is not a valid encoding type.`,
+        "Please provide a valid ABI type."
+      ].join("\n"),
+      { docsPath: "/docs/contract/encodeAbi#params" }
+    );
+    __publicField(this, "name", "InvalidAbiEncodingType");
+  }
+};
+var InvalidArrayError = class extends BaseError {
+  constructor(value) {
+    super([`Value "${value}" is not a valid array.`].join("\n"));
+    __publicField(this, "name", "InvalidArrayError");
+  }
+};
+
+// src/utils/abi/decodeAbi.ts
+function decodeAbi({
+  data,
+  params
+}) {
+  if (size(data) % 32 !== 0)
+    throw new AbiDecodingDataSizeInvalidError(size(data));
+  return decodeParams({
+    data,
+    params
+  });
+}
+function decodeParams({
+  data,
+  params
+}) {
+  let decodedValues = [];
+  let position = 0;
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+    const { consumed, value } = decodeParam({ data, param, position });
+    decodedValues.push(value);
+    position += consumed;
+  }
+  return decodedValues;
+}
+function decodeParam({
+  data,
+  param,
+  position
+}) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return decodeArray(data, {
+      length,
+      param: { ...param, type },
+      position
+    });
+  }
+  if (param.type === "tuple") {
+    return decodeTuple(data, { param, position });
+  }
+  if (param.type === "string") {
+    return decodeString(data, { position });
+  }
+  if (param.type.startsWith("bytes")) {
+    return decodeBytes2(data, { param, position });
+  }
+  let value = slice(data, position, position + 32);
+  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+    return decodeNumber(value, { param });
+  }
+  if (param.type === "address") {
+    return decodeAddress(value);
+  }
+  if (param.type === "bool") {
+    return decodeBool(value);
+  }
+  throw new InvalidAbiDecodingTypeError(param.type);
+}
+function decodeArray(data, {
+  param,
+  length,
+  position
+}) {
+  if (!length) {
+    const offset = hexToNumber(slice(data, position, position + 32));
+    const length2 = hexToNumber(slice(data, offset, offset + 32));
+    let consumed2 = 0;
+    let value2 = [];
+    for (let i = 0; i < length2; ++i) {
+      const decodedChild = decodeParam({
+        data: slice(data, offset + 32),
+        param,
+        position: consumed2
+      });
+      consumed2 += decodedChild.consumed;
+      value2.push(decodedChild.value);
+    }
+    return { value: value2, consumed: 32 };
+  }
+  if (hasDynamicChild(param)) {
+    const arrayComponents = getArrayComponents(param.type);
+    const dynamicChild = !arrayComponents?.[0];
+    let consumed2 = 0;
+    let value2 = [];
+    for (let i = 0; i < length; ++i) {
+      const offset = hexToNumber(slice(data, position, position + 32));
+      const decodedChild = decodeParam({
+        data: slice(data, offset),
+        param,
+        position: dynamicChild ? consumed2 : i * 32
+      });
+      consumed2 += decodedChild.consumed;
+      value2.push(decodedChild.value);
+    }
+    return { value: value2, consumed: consumed2 };
+  }
+  let consumed = 0;
+  let value = [];
+  for (let i = 0; i < length; ++i) {
+    const decodedChild = decodeParam({
+      data,
+      param,
+      position: position + consumed
+    });
+    consumed += decodedChild.consumed;
+    value.push(decodedChild.value);
+  }
+  return { value, consumed };
+}
+function decodeAddress(value) {
+  return { consumed: 32, value: checksumAddress(trim(value)) };
+}
+function decodeBool(value) {
+  return { consumed: 32, value: hexToBool(value) };
+}
+function decodeBytes2(data, { param, position }) {
+  const [_, size2] = param.type.split("bytes");
+  if (!size2) {
+    const offset = hexToNumber(slice(data, position, position + 32));
+    const length = hexToNumber(slice(data, offset, offset + 32));
+    const value2 = slice(data, offset + 32, offset + 32 + length);
+    return { consumed: 32, value: value2 };
+  }
+  const value = slice(data, position, position + parseInt(size2));
+  return { consumed: 32, value };
+}
+function decodeNumber(value, { param }) {
+  const signed = param.type.startsWith("int");
+  const size2 = parseInt(param.type.split("int")[1] || "256");
+  return {
+    consumed: 32,
+    value: size2 > 48 ? hexToBigInt(value, { signed }) : hexToNumber(value, { signed })
+  };
+}
+function decodeString(data, { position }) {
+  const offset = hexToNumber(slice(data, position, position + 32));
+  const length = hexToNumber(slice(data, offset, offset + 32));
+  const value = hexToString(
+    trim(slice(data, offset + 32, offset + 32 + length))
+  );
+  return { consumed: 32, value };
+}
+function decodeTuple(data, { param, position }) {
+  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+  let value = hasUnnamedChild ? [] : {};
+  let consumed = 0;
+  if (hasDynamicChild(param)) {
+    const offset = hexToNumber(slice(data, position, position + 32));
+    for (let i = 0; i < param.components.length; ++i) {
+      const component = param.components[i];
+      const decodedChild = decodeParam({
+        data: slice(data, offset),
+        param: component,
+        position: consumed
+      });
+      consumed += decodedChild.consumed;
+      value[hasUnnamedChild ? i : component?.name] = decodedChild.value;
+    }
+    return { consumed: 32, value };
+  }
+  for (let i = 0; i < param.components.length; ++i) {
+    const component = param.components[i];
+    const decodedChild = decodeParam({
+      data,
+      param: component,
+      position: position + consumed
+    });
+    consumed += decodedChild.consumed;
+    value[hasUnnamedChild ? i : component?.name] = decodedChild.value;
+  }
+  return { consumed, value };
+}
+function hasDynamicChild(param) {
+  const { type } = param;
+  if (type === "string")
+    return true;
+  if (type === "bytes")
+    return true;
+  if (type.endsWith("[]"))
+    return true;
+  if (type === "tuple")
+    return param.components?.some(hasDynamicChild);
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
+    return true;
+  return false;
+}
+var AbiDecodingDataSizeInvalidError = class extends BaseError {
+  constructor(size2) {
+    super(
+      [
+        `Data size of ${size2} bytes is invalid.`,
+        "Size must be in increments of 32 bytes (size % 32 === 0)."
+      ].join("\n")
+    );
+    __publicField(this, "name", "AbiDecodingDataSizeInvalidError");
+  }
+};
+var InvalidAbiDecodingTypeError = class extends BaseError {
+  constructor(type) {
+    super(
+      [
+        `Type "${type}" is not a valid decoding type.`,
+        "Please provide a valid ABI type."
+      ].join("\n"),
+      { docsPath: "/docs/contract/decodeAbi#params" }
+    );
+    __publicField(this, "name", "InvalidAbiDecodingType");
+  }
+};
+
+// src/utils/abi/getDefinition.ts
+function getDefinition(description) {
+  if (description.type !== "function" && description.type !== "event" && description.type !== "error")
+    throw new InvalidDefinitionTypeError(description.type);
+  return `${description.name}(${getParams(description.inputs)})`;
+}
+function getParams(params) {
+  if (!params)
+    return "";
+  return params.map(getParam).join(",");
+}
+function getParam(param) {
+  if (param.type.startsWith("tuple")) {
+    return `(${getParams(
+      param.components
+    )})${param.type.slice("tuple".length)}`;
+  }
+  return param.type;
+}
+var InvalidDefinitionTypeError = class extends BaseError {
+  constructor(type) {
+    super(
+      [
+        `"${type}" is not a valid definition type.`,
+        'Valid types: "function", "event", "error"'
+      ].join("\n"),
+      {
+        docsPath: "/docs/contract/getDefinition"
+      }
+    );
+  }
+};
+
+// src/utils/abi/encodeFunctionParams.ts
+function encodeFunctionParams({
+  abi,
+  args,
+  functionName
+}) {
+  const description = abi.find((x) => "name" in x && x.name === functionName);
+  if (!description)
+    throw new AbiFunctionNotFoundError(functionName);
+  const definition = getDefinition(description);
+  const signature = getFunctionSignature(definition);
+  const data = "inputs" in description && description.inputs ? encodeAbi({
+    params: description.inputs,
+    values: args ?? []
+  }) : void 0;
+  return concatHex([signature, data ?? "0x"]);
+}
+var AbiFunctionNotFoundError = class extends BaseError {
+  constructor(functionName) {
+    super(
+      [
+        `Function "${functionName}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the function exists on it."
+      ].join("\n"),
+      {
+        docsPath: "/docs/contract/encodeFunctionParams"
+      }
+    );
+  }
+};
+
 // src/utils/buildRequest.ts
 function buildRequest(request) {
   return async (args) => {
@@ -1427,6 +2001,9 @@ export {
   getCreate2Address,
   isAddress,
   isAddressEqual,
+  encodeAbi,
+  decodeAbi,
+  encodeFunctionParams,
   buildRequest,
   RpcRequestError,
   ParseRpcError,