@agoric/orchestration 0.1.1-dev-d756c83.0.d756c83 → 0.1.1-dev-e9efaa1.0.e9efaa1

package/src/utils/permit2/{signatureTransfer.ts → signatureTransfer.js}

@@ -11,48 +11,48 @@
  * Some stylistic changes have also been made to conform to our code style.
  */
 
-import type { TypedDataToPrimitiveTypes } from 'abitype';
-import type {
-  Address,
-  TypedData,
-  TypedDataDefinition,
-  TypedDataDomain,
-} from 'viem';
-import type { TypedDataParameter } from '../abitype.ts';
+                                                         
+             
+          
+            
+                      
+                  
+              
+                                                        
 
 const PERMIT2_DOMAIN_NAME = 'Permit2';
 
 // TODO: disallow witness type field being another Permit field name
-interface WitnessDefinition<
-  T extends TypedData = TypedData,
-  TD extends TypedDataParameter<string, Extract<keyof T, string>> =
-    TypedDataParameter<'witness', Extract<keyof T, string>>,
-> {
-  witnessField: TD;
-  witnessTypes: T;
-}
-
-export interface Witness<
-  T extends TypedData = TypedData,
-  TD extends TypedDataParameter<string, Extract<keyof T, string>> =
-    TypedDataParameter<'witness', Extract<keyof T, string>>,
-> extends WitnessDefinition<T, TD> {
-  witness: TypedDataToPrimitiveTypes<T>[TD['type']];
-}
+;                           
+                                  
+                                                                   
+                                                            
+   
+                   
+                  
+ 
+
+;                        
+                                  
+                                                                   
+                                                            
+                                    
+                                                    
+ 
 
 /**
  * Helper to help caller check that the `data` matches the inferred witness types
  *
  * @see {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-4.html#the-noinfer-utility-type}
  */
-export function makeWitness<
-  T extends TypedData,
-  TD extends TypedDataParameter<string, Extract<keyof T, string>>,
->(
-  data: NoInfer<TypedDataToPrimitiveTypes<T>[TD['type']]>,
-  types: T,
-  typeParam: TD,
-): Witness<T, TD> {
+export function makeWitness(
+                      
+                                                                  
+  
+  data                                                   ,
+  types   ,
+  typeParam    ,
+)                 {
   return {
     witness: data,
     witnessTypes: types,
@@ -60,134 +60,134 @@ export function makeWitness<
   };
 }
 
-export type TokenPermissions = {
-  token: Address;
-  amount: bigint;
-};
-
-export type PermitTransferFrom = {
-  permitted: TokenPermissions;
-  spender: Address;
-  nonce: bigint;
-  deadline: bigint;
-};
-
-export type PermitBatchTransferFrom = {
-  permitted: readonly TokenPermissions[];
-  spender: Address;
-  nonce: bigint;
-  deadline: bigint;
-};
+;                               
+                 
+                 
+  
+
+;                                 
+                              
+                   
+                
+                   
+  
+
+;                                      
+                                         
+                   
+                
+                   
+  
 
 const Permit2DomainTypeParams = [
   { name: 'name', type: 'string' },
   { name: 'chainId', type: 'uint256' },
   { name: 'verifyingContract', type: 'address' },
-] as const satisfies TypedDataParameter[];
+]                                        ;
 
 export const PermitTransferFromTypeParams = [
   { name: 'permitted', type: 'TokenPermissions' },
   { name: 'spender', type: 'address' },
   { name: 'nonce', type: 'uint256' },
   { name: 'deadline', type: 'uint256' },
-] as const satisfies TypedDataParameter[];
+]                                        ;
 
 export const PermitBatchTransferFromTypeParams = [
   { name: 'permitted', type: 'TokenPermissions[]' },
   { name: 'spender', type: 'address' },
   { name: 'nonce', type: 'uint256' },
   { name: 'deadline', type: 'uint256' },
-] as const satisfies TypedDataParameter[];
+]                                        ;
 
 const TokenPermissionTypeParams = [
   { name: 'token', type: 'address' },
   { name: 'amount', type: 'uint256' },
-] as const satisfies TypedDataParameter[];
+]                                        ;
 
 export const PermitTransferFromTypes = {
   EIP712Domain: Permit2DomainTypeParams,
   PermitTransferFrom: PermitTransferFromTypeParams,
   TokenPermissions: TokenPermissionTypeParams,
-} as const satisfies TypedData;
+}                             ;
 
 export const PermitBatchTransferFromTypes = {
   EIP712Domain: Permit2DomainTypeParams,
   PermitBatchTransferFrom: PermitBatchTransferFromTypeParams,
   TokenPermissions: TokenPermissionTypeParams,
-} as const satisfies TypedData;
+}                             ;
 
-export function permitWitnessTransferFromTypes<
-  T extends TypedData,
-  TD extends TypedDataParameter<string, Extract<keyof T, string>> =
-    TypedDataParameter<'witness', Extract<keyof T, string>>,
->(witness: WitnessDefinition<T, TD>) {
+export function permitWitnessTransferFromTypes(
+                      
+                                                                   
+                                                            
+  witness                          ) {
   return {
     EIP712Domain: Permit2DomainTypeParams,
     PermitWitnessTransferFrom: [
       ...PermitTransferFromTypeParams,
       // Enable runtime type to accept undefined field for base type extraction
-      ...((witness ? [witness.witnessField] : []) as [TD]),
+      ...((witness ? [witness.witnessField] : [])        ),
     ],
     TokenPermissions: TokenPermissionTypeParams,
     ...witness?.witnessTypes,
-  } as const satisfies TypedData;
+  }                             ;
 }
 
-export function permitBatchWitnessTransferFromTypes<
-  T extends TypedData,
-  TD extends TypedDataParameter<string, Extract<keyof T, string>> =
-    TypedDataParameter<'witness', Extract<keyof T, string>>,
->(witness: WitnessDefinition<T, TD>) {
+export function permitBatchWitnessTransferFromTypes(
+                      
+                                                                   
+                                                            
+  witness                          ) {
   return {
     EIP712Domain: Permit2DomainTypeParams,
     PermitBatchWitnessTransferFrom: [
       ...PermitBatchTransferFromTypeParams,
       // Enable runtime type to accept undefined field for base type extraction
-      ...((witness ? [witness.witnessField] : []) as [TD]),
+      ...((witness ? [witness.witnessField] : [])        ),
     ],
     TokenPermissions: TokenPermissionTypeParams,
     ...witness?.witnessTypes,
-  } as const satisfies TypedData;
+  }                             ;
 }
 
-export type PermitWitnessTransferFrom<
-  T extends Record<string, unknown>,
-  TN extends string = 'witness',
-> = PermitTransferFrom & { [key in TN]: T };
+;                                     
+                                    
+                                
+                                            
 
-export type PermitBatchWitnessTransferFrom<
-  T extends Record<string, unknown>,
-  TN extends string = 'witness',
-> = PermitBatchTransferFrom & { [key in TN]: T };
+;                                          
+                                    
+                                
+                                                 
 
 export function permit2Domain(
-  permit2Address: Address,
-  chainId: number | bigint,
+  permit2Address         ,
+  chainId                 ,
 ) {
   return {
     name: PERMIT2_DOMAIN_NAME,
     chainId,
     verifyingContract: permit2Address,
-  } as const satisfies TypedDataDomain;
+  }                                   ;
 }
 
 // XXX: restore permit to be either PermitTransferFrom or PermitBatchTransferFrom
 // and remove duplication between the two functions below
 // Original method was `SignatureTransfer.getPermitData`
-export function getPermitWitnessTransferFromData<
-  T extends TypedData,
-  TD extends TypedDataParameter<string, Extract<keyof T, string>> =
-    TypedDataParameter<'witness', Extract<keyof T, string>>,
->(
-  permit: PermitTransferFrom,
-  permit2Address: Address,
-  chainId: number | bigint,
-  witness: Witness<T, TD>,
-): TypedDataDefinition<
-  ReturnType<typeof permitWitnessTransferFromTypes<T, TD>>,
-  'PermitWitnessTransferFrom',
-  'PermitWitnessTransferFrom'
-> {
+export function getPermitWitnessTransferFromData(
+                      
+                                                                   
+                                                            
+  
+  permit                    ,
+  permit2Address         ,
+  chainId                 ,
+  witness                ,
+)                      
+                                                           
+                              
+                             
+  {
   // type MessageType = TypedDataToPrimitiveTypes<
   //   ReturnType<typeof permitWitnessTransferFromTypes<T, TD>>
   // >['PermitWitnessTransferFrom'];
@@ -209,20 +209,20 @@ export function getPermitWitnessTransferFromData<
   };
 }
 
-export function getPermitBatchWitnessTransferFromData<
-  T extends TypedData,
-  TD extends TypedDataParameter<string, Extract<keyof T, string>> =
-    TypedDataParameter<'witness', Extract<keyof T, string>>,
->(
-  permit: PermitBatchTransferFrom,
-  permit2Address: Address,
-  chainId: number | bigint,
-  witness: Witness<T, TD>,
-): TypedDataDefinition<
-  ReturnType<typeof permitBatchWitnessTransferFromTypes<T, TD>>,
-  'PermitBatchWitnessTransferFrom',
-  'PermitBatchWitnessTransferFrom'
-> {
+export function getPermitBatchWitnessTransferFromData(
+                      
+                                                                   
+                                                            
+  
+  permit                         ,
+  permit2Address         ,
+  chainId                 ,
+  witness                ,
+)                      
+                                                                
+                                   
+                                  
+  {
   // type MessageType = TypedDataToPrimitiveTypes<
   //   ReturnType<typeof permitBatchWitnessTransferFromTypes<T, TD>>
   // >['PermitBatchWitnessTransferFrom'];

package/src/utils/permit2/{signatureTransferHelpers.ts → signatureTransferHelpers.js}

@@ -4,13 +4,13 @@
  * This is original code that was adapted for permit2-sdk, unlike @see ./permit2SignatureTransfer.ts
  */
 
-import type {
-  AbiFunction,
-  AbiParameter,
-  AbiParameterToPrimitiveType,
-  TypedData,
-} from 'abitype';
-import type { TypedDataParameter } from '../abitype.ts';
+             
+              
+               
+                              
+            
+                 
+                                                        
 import {
   PermitBatchTransferFromTypeParams,
   permitBatchWitnessTransferFromTypes,
@@ -20,15 +20,15 @@ import {
 
 export const makeWitnessTypeStringExtractor = ({
   encodeType,
-}: {
-  encodeType: ({
-    primaryType,
-    types,
-  }: {
-    primaryType: string;
-    types: TypedData;
-  }) => string;
-}) => {
+}   
+                
+                
+          
+      
+                        
+                     
+               
+ ) => {
   const baseTypeStrings = Object.fromEntries(
     Object.entries({
       PermitBatchWitnessTransferFrom: permitBatchWitnessTransferFromTypes,
@@ -45,7 +45,7 @@ export const makeWitnessTypeStringExtractor = ({
     }),
   );
 
-  return function getWitnessTypeString(types: TypedData) {
+  return function getWitnessTypeString(types           ) {
     const matchingTypes = Object.keys(types).filter(
       type => type in baseTypeStrings,
     );
@@ -73,31 +73,31 @@ export const makeWitnessTypeStringExtractor = ({
   };
 };
 
-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 => {
+export const extractWitnessFieldFromTypes = (
+                                         
+  
+  types 
+       
+                                                  
+                                                      
+            
+          
+       
+       
+                                             
+                                                 
+            
+          
+       ,
+   ) => {
   const baseTypes = {
     PermitBatchWitnessTransferFrom: PermitBatchTransferFromTypeParams,
     PermitWitnessTransferFrom: PermitTransferFromTypeParams,
@@ -105,7 +105,7 @@ export const extractWitnessFieldFromTypes = <
 
   const matchingTypes = Object.keys(types).filter(
     type => type in baseTypes,
-  ) as (keyof typeof baseTypes)[];
+  )                              ;
 
   if (matchingTypes.length !== 1) {
     throw new Error(
@@ -114,7 +114,7 @@ export const extractWitnessFieldFromTypes = <
   }
 
   const primaryType = matchingTypes[0];
-  const candidateType = (types as MapUnion<typeof types>)[primaryType];
+  const candidateType = (types                          )[primaryType];
   const referenceType = baseTypes[primaryType];
   if (candidateType.length !== referenceType.length + 1) {
     throw new Error(
@@ -133,10 +133,10 @@ export const extractWitnessFieldFromTypes = <
     }
   }
 
-  return candidateType[candidateType.length - 1] as T;
+  return candidateType[candidateType.length - 1]     ;
 };
 
-export const isPermit2MessageType = (type: string) => {
+export const isPermit2MessageType = (type        ) => {
   return (
     type === 'PermitBatchWitnessTransferFrom' ||
     type === 'PermitWitnessTransferFrom'
@@ -146,9 +146,9 @@ export const isPermit2MessageType = (type: string) => {
 export const TokenPermissionsComponents = [
   { name: 'token', type: 'address' },
   { name: 'amount', type: 'uint256' },
-] as const satisfies AbiParameter[];
+]                                  ;
 export const TokenPermissionsInternalTypeName =
-  'struct ISignatureTransfer.TokenPermissions' as const;
+  'struct ISignatureTransfer.TokenPermissions'         ;
 
 export const PermitTransferFromComponents = [
   {
@@ -159,14 +159,14 @@ export const PermitTransferFromComponents = [
   },
   { name: 'nonce', type: 'uint256' },
   { name: 'deadline', type: 'uint256' },
-] as const satisfies AbiParameter[];
+]                                  ;
 export const PermitTransferFromInternalTypeName =
-  'struct ISignatureTransfer.PermitTransferFrom' as const;
-export type PermitTransferFromStruct = AbiParameterToPrimitiveType<{
-  type: 'tuple';
-  internalType: typeof PermitTransferFromInternalTypeName;
-  components: typeof PermitTransferFromComponents;
-}>;
+  'struct ISignatureTransfer.PermitTransferFrom'         ;
+;                                                                   
+                
+                                                          
+                                                  
+   
 
 export const PermitBatchTransferFromComponents = [
   {
@@ -177,26 +177,26 @@ export const PermitBatchTransferFromComponents = [
   },
   { name: 'nonce', type: 'uint256' },
   { name: 'deadline', type: 'uint256' },
-] as const satisfies AbiParameter[];
+]                                  ;
 export const PermitBatchTransferFromInternalTypeName =
-  'struct ISignatureTransfer.PermitBatchTransferFrom' as const;
-export type PermitBatchTransferFromStruct = AbiParameterToPrimitiveType<{
-  type: 'tuple';
-  internalType: typeof PermitBatchTransferFromInternalTypeName;
-  components: typeof PermitBatchTransferFromComponents;
-}>;
+  'struct ISignatureTransfer.PermitBatchTransferFrom'         ;
+;                                                                        
+                
+                                                               
+                                                       
+   
 
 export const SignatureTransferDetailsComponents = [
   { name: 'to', type: 'address' },
   { name: 'requestedAmount', type: 'uint256' },
-] as const satisfies AbiParameter[];
+]                                  ;
 export const SignatureTransferDetailsInternalTypeName =
-  'struct ISignatureTransfer.SignatureTransferDetails' as const;
-export type SignatureTransferDetailsStruct = AbiParameterToPrimitiveType<{
-  type: 'tuple';
-  internalType: typeof SignatureTransferDetailsInternalTypeName;
-  components: typeof SignatureTransferDetailsComponents;
-}>;
+  'struct ISignatureTransfer.SignatureTransferDetails'         ;
+;                                                                         
+                
+                                                                
+                                                        
+   
 
 export const PermitWitnessTransferFromInputComponents = [
   {
@@ -215,11 +215,11 @@ export const PermitWitnessTransferFromInputComponents = [
   { name: 'witness', type: 'bytes32' },
   { name: 'witnessTypeString', type: 'string' },
   { name: 'signature', type: 'bytes' },
-] as const satisfies AbiParameter[];
-export type PermitWitnessTransferFromPayload = AbiParameterToPrimitiveType<{
-  type: 'tuple';
-  components: typeof PermitWitnessTransferFromInputComponents;
-}>;
+]                                  ;
+;                                                                           
+                
+                                                              
+   
 
 export const BatchPermitWitnessTransferFromInputComponents = [
   {
@@ -238,12 +238,12 @@ export const BatchPermitWitnessTransferFromInputComponents = [
   { name: 'witness', type: 'bytes32' },
   { name: 'witnessTypeString', type: 'string' },
   { name: 'signature', type: 'bytes' },
-] as const satisfies AbiParameter[];
-export type BatchPermitWitnessTransferFromPayload =
-  AbiParameterToPrimitiveType<{
-    type: 'tuple';
-    components: typeof BatchPermitWitnessTransferFromInputComponents;
-  }>;
+]                                  ;
+;                                                  
+                               
+                  
+                                                                     
+     
 
 export const PermitWitnessTransferFromFunctionABIType = {
   name: 'permitWitnessTransferFrom',
@@ -251,7 +251,7 @@ export const PermitWitnessTransferFromFunctionABIType = {
   outputs: [],
   stateMutability: 'nonpayable',
   type: 'function',
-} as const satisfies AbiFunction;
+}                               ;
 
 export const BatchPermitWitnessTransferFunctionABIType = {
   name: 'permitWitnessTransferFrom',
@@ -259,4 +259,4 @@ export const BatchPermitWitnessTransferFunctionABIType = {
   outputs: [],
   stateMutability: 'nonpayable',
   type: 'function',
-} as const satisfies AbiFunction;
+}                               ;

package/src/utils/viem-utils/{hashTypedData.ts → hashTypedData.js}

@@ -6,18 +6,18 @@
  * 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);
@@ -36,14 +36,14 @@ function findTypeDependencies(
   {
     primaryType: primaryType_,
     types,
-  }: {
-    primaryType: string;
-    types: Record<string, readonly MessageTypeProperty[]>;
-  },
-  results: Set<string> = new Set(),
-): Set<string> {
+  }   
+                        
+                                                          
+   ,
+  results              = new Set(),
+)              {
   const match = primaryType_.match(/^\w*/u);
-  const primaryType = match?.[0] as string;
+  const primaryType = match?.[0]          ;
   if (results.has(primaryType) || types[primaryType] === undefined) {
     return results;
   }

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

@@ -0,0 +1,18 @@
+             
+            
+      
+            
+            
+                      
+              
+
+                                    
+                                         
+  
+
+                                      
+                                                                    
+                                                                         
+     
+                                                                        
+