@agoric/orchestration 0.1.1-dev-d57b08e.0.d57b08e → 0.1.1-dev-2ae3f1f.0.2ae3f1f

package/src/utils/permit2/signatureTransferHelpers.ts

@@ -0,0 +1,139 @@
+/**
+ * @file Helpers for working with permit2 signature transfer witness types
+ *
+ * This is original code that was adapted for permit2-sdk, unlike @see ./permit2SignatureTransfer.ts
+ */
+
+import type { TypedData } from 'viem';
+import type { TypedDataParameter } from '../abitype.ts';
+import {
+  PermitBatchTransferFromTypeParams,
+  permitBatchWitnessTransferFromTypes,
+  PermitTransferFromTypeParams,
+  permitWitnessTransferFromTypes,
+} from './signatureTransfer.ts';
+
+export const makeWitnessTypeStringExtractor = ({
+  encodeType,
+}: {
+  encodeType: ({
+    primaryType,
+    types,
+  }: {
+    primaryType: string;
+    types: TypedData;
+  }) => string;
+}) => {
+  const baseTypeStrings = Object.fromEntries(
+    Object.entries({
+      PermitBatchWitnessTransferFrom: permitBatchWitnessTransferFromTypes,
+      PermitWitnessTransferFrom: permitWitnessTransferFromTypes,
+    }).map(([typeName, typeFunc]) => {
+      const encoded = encodeType({
+        primaryType: typeName,
+        // @ts-expect-error undefined is not allowed in types but supported in implementation
+        types: typeFunc(undefined),
+      });
+
+      const prefix = encoded.substring(0, encoded.indexOf(')'));
+      return [typeName, `${prefix},`];
+    }),
+  );
+
+  return function getWitnessTypeString(types: TypedData) {
+    const matchingTypes = Object.keys(types).filter(
+      type => type in baseTypeStrings,
+    );
+
+    if (matchingTypes.length !== 1) {
+      throw new Error(
+        `TypedData must have exactly one of the following types: ${Object.keys(baseTypeStrings).join(', ')}`,
+      );
+    }
+
+    const primaryType = matchingTypes[0];
+    const encodedType = encodeType({
+      primaryType,
+      types,
+    });
+
+    const baseTypeString = baseTypeStrings[primaryType];
+    if (!encodedType.startsWith(baseTypeString)) {
+      throw new Error(
+        `TypedData has an invalid type string for ${primaryType}`,
+      );
+    }
+
+    return encodedType.substring(baseTypeString.length);
+  };
+};
+
+type MapUnion<U> = {
+  [K in U extends any ? keyof U : never]: U extends any
+    ? K extends keyof U
+      ? U[K]
+      : never
+    : never;
+};
+
+export const extractWitnessFieldFromTypes = <
+  T extends Readonly<TypedDataParameter>,
+>(
+  types:
+    | {
+        PermitBatchWitnessTransferFrom: readonly [
+          ...typeof PermitBatchTransferFromTypeParams,
+          T,
+        ];
+      }
+    | {
+        PermitWitnessTransferFrom: readonly [
+          ...typeof PermitTransferFromTypeParams,
+          T,
+        ];
+      },
+): T => {
+  const baseTypes = {
+    PermitBatchWitnessTransferFrom: PermitBatchTransferFromTypeParams,
+    PermitWitnessTransferFrom: PermitTransferFromTypeParams,
+  };
+
+  const matchingTypes = Object.keys(types).filter(
+    type => type in baseTypes,
+  ) as (keyof typeof baseTypes)[];
+
+  if (matchingTypes.length !== 1) {
+    throw new Error(
+      `TypedData must have exactly one of the following types: ${Object.keys(baseTypes).join(', ')}`,
+    );
+  }
+
+  const primaryType = matchingTypes[0];
+  const candidateType = (types as MapUnion<typeof types>)[primaryType];
+  const referenceType = baseTypes[primaryType];
+  if (candidateType.length !== referenceType.length + 1) {
+    throw new Error(
+      `TypedData has an invalid number of fields for ${primaryType}`,
+    );
+  }
+
+  for (const [i, field] of referenceType.entries()) {
+    if (
+      candidateType[i].name !== field.name ||
+      candidateType[i].type !== field.type
+    ) {
+      throw new Error(
+        `TypedData has an invalid field at index ${i} for ${primaryType}`,
+      );
+    }
+  }
+
+  return candidateType[candidateType.length - 1] as T;
+};
+
+export const isPermit2MessageType = (type: string) => {
+  return (
+    type === 'PermitBatchWitnessTransferFrom' ||
+    type === 'PermitWitnessTransferFrom'
+  );
+};

package/src/utils/permit2.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file entry point for orchestration's permit2 utils
+ *
+ * This file should eventually become a `.js` file once we can strip types from
+ * `.ts` files and rewrite relative import specifiers in `.js` files.
+ *
+ * NPM consumers could use jsr.io to consume this in the meantime.
+ */
+export * from './permit2/signatureTransfer.ts';
+export * from './permit2/signatureTransferHelpers.ts';
+//# sourceMappingURL=permit2.d.ts.map

package/src/utils/permit2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permit2.d.ts","sourceRoot":"","sources":["permit2.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC"}

package/src/utils/permit2.ts

@@ -0,0 +1,11 @@
+/**
+ * @file entry point for orchestration's permit2 utils
+ *
+ * This file should eventually become a `.js` file once we can strip types from
+ * `.ts` files and rewrite relative import specifiers in `.js` files.
+ *
+ * NPM consumers could use jsr.io to consume this in the meantime.
+ */
+
+export * from './permit2/signatureTransfer.ts';
+export * from './permit2/signatureTransferHelpers.ts';

package/src/utils/viem-utils/hashTypedData.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file viem internal typedData utils exported for direct usage
+ *
+ * @license MIT
+ * Copyright (c) 2023-present weth, LLC
+ * Copied from https://github.com/wevm/viem/blob/ea0b9d4c391567dd811acbfd889121bb9cb1c26c/src/utils/signature/hashTypedData.ts
+ */
+type MessageTypeProperty = {
+    name: string;
+    type: string;
+};
+export declare function encodeType({ primaryType, types, }: {
+    primaryType: string;
+    types: Record<string, readonly MessageTypeProperty[]>;
+}): string;
+export {};
+//# sourceMappingURL=hashTypedData.d.ts.map

package/src/utils/viem-utils/hashTypedData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashTypedData.d.ts","sourceRoot":"","sources":["hashTypedData.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,KAAK,mBAAmB,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,wBAAgB,UAAU,CAAC,EACzB,WAAW,EACX,KAAK,GACN,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC,CAAC;CACvD,UAaA"}

package/src/utils/viem-utils/hashTypedData.ts

@@ -0,0 +1,57 @@
+/**
+ * @file viem internal typedData utils exported for direct usage
+ *
+ * @license MIT
+ * Copyright (c) 2023-present weth, LLC
+ * Copied from https://github.com/wevm/viem/blob/ea0b9d4c391567dd811acbfd889121bb9cb1c26c/src/utils/signature/hashTypedData.ts
+ */
+
+type MessageTypeProperty = {
+  name: string;
+  type: string;
+};
+
+export function encodeType({
+  primaryType,
+  types,
+}: {
+  primaryType: string;
+  types: Record<string, readonly MessageTypeProperty[]>;
+}) {
+  let result = '';
+  const unsortedDeps = findTypeDependencies({ primaryType, types });
+  unsortedDeps.delete(primaryType);
+
+  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
+  for (const type of deps) {
+    result += `${type}(${types[type]
+      .map(({ name, type: t }) => `${t} ${name}`)
+      .join(',')})`;
+  }
+
+  return result;
+}
+
+function findTypeDependencies(
+  {
+    primaryType: primaryType_,
+    types,
+  }: {
+    primaryType: string;
+    types: Record<string, readonly MessageTypeProperty[]>;
+  },
+  results: Set<string> = new Set(),
+): Set<string> {
+  const match = primaryType_.match(/^\w*/u);
+  const primaryType = match?.[0] as string;
+  if (results.has(primaryType) || types[primaryType] === undefined) {
+    return results;
+  }
+
+  results.add(primaryType);
+
+  for (const field of types[primaryType]) {
+    findTypeDependencies({ primaryType: field.type, types }, results);
+  }
+  return results;
+}

package/src/utils/viem-utils/types.d.ts

@@ -0,0 +1,6 @@
+import type { ByteArray, Hex, Signature, TypedData, TypedDataDefinition } from 'viem';
+export type WithSignature<T> = T & {
+    signature: Hex | ByteArray | Signature;
+};
+export type SignedTypedDataDefinition<typedData extends TypedData | Record<string, unknown> = TypedData, primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData, primaryTypes = typedData extends TypedData ? keyof typedData : string> = WithSignature<TypedDataDefinition<typedData, primaryType, primaryTypes>>;
+//# sourceMappingURL=types.d.ts.map

package/src/utils/viem-utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,GAAG,EACH,SAAS,EACT,SAAS,EACT,mBAAmB,EACpB,MAAM,MAAM,CAAC;AAEd,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG;IACjC,SAAS,EAAE,GAAG,GAAG,SAAS,GAAG,SAAS,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,yBAAyB,CACnC,SAAS,SAAS,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACjE,WAAW,SAAS,MAAM,SAAS,GAAG,cAAc,GAAG,MAAM,SAAS,EAEtE,YAAY,GAAG,SAAS,SAAS,SAAS,GAAG,MAAM,SAAS,GAAG,MAAM,IACnE,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC,CAAC"}

package/src/utils/viem-utils/types.ts

@@ -0,0 +1,18 @@
+import type {
+  ByteArray,
+  Hex,
+  Signature,
+  TypedData,
+  TypedDataDefinition,
+} from 'viem';
+
+export type WithSignature<T> = T & {
+  signature: Hex | ByteArray | Signature;
+};
+
+export type SignedTypedDataDefinition<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = WithSignature<TypedDataDefinition<typedData, primaryType, primaryTypes>>;

package/src/utils/viem.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file entry point for some common viem utils
+ *
+ * This file should eventually become a `.js` file once we can strip types from
+ * `.ts` files and rewrite relative import specifiers in `.js` files.
+ *
+ * NPM consumers could use jsr.io to consume this in the meantime.
+ */
+export * from './viem-utils/hashTypedData.ts';
+export * from './viem-utils/types.ts';
+//# sourceMappingURL=viem.d.ts.map

package/src/utils/viem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["viem.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC"}

package/src/utils/viem.ts

@@ -0,0 +1,11 @@
+/**
+ * @file entry point for some common viem utils
+ *
+ * This file should eventually become a `.js` file once we can strip types from
+ * `.ts` files and rewrite relative import specifiers in `.js` files.
+ *
+ * NPM consumers could use jsr.io to consume this in the meantime.
+ */
+
+export * from './viem-utils/hashTypedData.ts';
+export * from './viem-utils/types.ts';

package/src/vendor/viem/{_esm-YOAV66U4.js → _esm-OKAICHVC.js}

@@ -2660,7 +2660,7 @@ var require_buffer = __commonJS({
     function numberIsNaN(obj) {
       return obj !== obj;
     }
-    var hexSliceLookupTable = function() {
+    var hexSliceLookupTable = (function() {
       const alphabet = "0123456789abcdef";
       const table = new Array(256);
       for (let i = 0; i < 16; ++i) {
@@ -2670,7 +2670,7 @@ var require_buffer = __commonJS({
         }
       }
       return table;
-    }();
+    })();
     function defineBigIntMethod(fn) {
       return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
     }

package/src/vendor/viem/{ccip-AAQDZF3N.js → ccip-34BSSMV5.js}

@@ -3,8 +3,7 @@ import {
   offchainLookup,
   offchainLookupAbiItem,
   offchainLookupSignature
-} from "./chunk-4EF4K2MH.js";
-import "./chunk-XN4LUOIH.js";
+} from "./chunk-GCI53Z2G.js";
 import "./chunk-4VNS5WPM.js";
 export {
   ccipRequest,

package/src/vendor/viem/{chunk-4EF4K2MH.js → chunk-GCI53Z2G.js}

@@ -708,6 +708,9 @@ function parseAbi(signatures) {
   return abi;
 }
 
+// ../../node_modules/ox/_esm/core/Hex.js
+import { equalBytes } from "@noble/curves/abstract/utils";
+
 // ../../node_modules/ox/_esm/core/version.js
 var version2 = "0.1.1";
 
@@ -1480,6 +1483,13 @@ var AbiItemAmbiguityError = class extends BaseError3 {
     });
   }
 };
+var BytesSizeMismatchError = class extends BaseError3 {
+  constructor({ expectedSize, givenSize }) {
+    super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
+      name: "BytesSizeMismatchError"
+    });
+  }
+};
 var InvalidAbiEncodingTypeError = class extends BaseError3 {
   constructor(type, { docsPath: docsPath6 }) {
     super([
@@ -1969,6 +1979,11 @@ function checksumAddress(address_, chainId) {
   checksumAddressCache.set(`${address_}.${chainId}`, result);
   return result;
 }
+function getAddress(address, chainId) {
+  if (!isAddress(address, { strict: false }))
+    throw new InvalidAddressError({ address });
+  return checksumAddress(address, chainId);
+}
 
 // ../../node_modules/viem/_esm/errors/cursor.js
 var NegativeOffsetError = class extends BaseError3 {
@@ -2214,6 +2229,7 @@ function concatHex(values) {
 }
 
 // ../../node_modules/viem/_esm/utils/regex.js
+var bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
 var integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
 
 // ../../node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
@@ -3698,7 +3714,7 @@ async function call(client, args) {
     return { data: response };
   } catch (err) {
     const data2 = getRevertErrorData(err);
-    const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await import("./ccip-AAQDZF3N.js");
+    const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await import("./ccip-34BSSMV5.js");
     if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
       return { data: await offchainLookup2(client, { data: data2, to }) };
     if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
@@ -4072,9 +4088,27 @@ async function ccipRequest({ data, sender, urls }) {
 }
 
 export {
+  BaseError3 as BaseError,
+  stringify,
+  isHex,
+  size2 as size,
+  hexToBigInt,
+  hexToNumber,
+  toHex,
+  numberToHex,
+  BytesSizeMismatchError,
+  keccak256,
+  InvalidAddressError,
+  isAddress,
+  checksumAddress,
+  getAddress,
+  concat,
+  bytesRegex2 as bytesRegex,
+  integerRegex2 as integerRegex,
   encodeAbiParameters,
   decodeAbiParameters,
   encodeFunctionData,
+  isAddressEqual,
   offchainLookupSignature,
   offchainLookupAbiItem,
   offchainLookup,