@agoric/portfolio-api 0.1.1-dev-d756c83.0.d756c83 → 0.1.1-dev-e9efaa1.0.e9efaa1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/portfolio-api",
-  "version": "0.1.1-dev-d756c83.0.d756c83",
+  "version": "0.1.1-dev-e9efaa1.0.e9efaa1",
   "description": "API for Portfolio management",
   "type": "module",
   "files": [
@@ -11,8 +11,8 @@
   "bin": "./src/cli/bin.js",
   "scripts": {
     "build": "exit 0",
-    "prepack": "yarn run -T tsc --build tsconfig.build.json",
-    "postpack": "git clean -f '*.d.*ts*' '*.tsbuildinfo'",
+    "prepack": "yarn run -T prepack-package",
+    "postpack": "yarn run -T postpack-package",
     "test": "ava",
     "test:c8": "c8 --all $C8_OPTIONS ava",
     "test:xs": "exit 0",
@@ -27,8 +27,8 @@
     "generate:ymax-machine": "npx tsx scripts/gen-ymax-machine.mts"
   },
   "dependencies": {
-    "@agoric/internal": "0.3.3-dev-d756c83.0.d756c83",
-    "@agoric/orchestration": "0.1.1-dev-d756c83.0.d756c83",
+    "@agoric/internal": "0.3.3-dev-e9efaa1.0.e9efaa1",
+    "@agoric/orchestration": "0.1.1-dev-e9efaa1.0.e9efaa1",
     "@endo/common": "^1.2.13",
     "@endo/errors": "^1.2.13",
     "@endo/patterns": "^1.7.0"
@@ -69,5 +69,5 @@
   "engines": {
     "node": "^20.9 || ^22.11"
   },
-  "gitHead": "d756c838c7eb3e3cec4a8bdf5c24b97f942b754e"
+  "gitHead": "e9efaa12254f2c9a6faffc40ade2f1d9a70b87ae"
 }

package/src/evm/types.js

@@ -0,0 +1,22 @@
+                           
+                                                         
+
+                              
+     
+                               
+                    
+                        
+     
+     
+                               
+                    
+                    
+                      
+     
+     
+                               
+                    
+                   
+      
+
+                                                       

package/src/evm-wallet/eip712-messages.d.ts

@@ -11,8 +11,8 @@
  */
 import type { Address, TypedDataDomain, TypedDataToPrimitiveTypes } from 'abitype';
 import type { TypedDataDefinition } from 'viem';
-import type { TypedDataParameter } from '@agoric/orchestration/src/utils/abitype.ts';
-import { type Witness, type getPermitWitnessTransferFromData, type getPermitBatchWitnessTransferFromData } from '@agoric/orchestration/src/utils/permit2.ts';
+import type { TypedDataParameter } from '@agoric/orchestration/src/utils/abitype.js';
+import { type Witness, type getPermitWitnessTransferFromData, type getPermitBatchWitnessTransferFromData } from '@agoric/orchestration/src/utils/permit2.js';
 declare const YMAX_DOMAIN_NAME = "Ymax";
 declare const YMAX_DOMAIN_VERSION = "1";
 declare const StandaloneDomainTypeParams: [{

package/src/evm-wallet/{eip712-messages.ts → eip712-messages.js}

@@ -10,21 +10,21 @@
  * name but with some effort this could be parametrizable
  */
 
-import type {
-  Address,
-  TypedData,
-  TypedDataDomain,
-  TypedDataToPrimitiveTypes,
-} from 'abitype';
-import type { TypedDataDefinition } from 'viem';
+             
+          
+            
+                  
+                            
+                 
+                                                
 import { Fail, q } from '@endo/errors';
-import type { TypedDataParameter } from '@agoric/orchestration/src/utils/abitype.ts';
+;                                                                                    
 import {
-  type Witness,
-  type getPermitWitnessTransferFromData,
-  type getPermitBatchWitnessTransferFromData,
+               
+                                        
+                                             
   makeWitness,
-} from '@agoric/orchestration/src/utils/permit2.ts';
+} from '@agoric/orchestration/src/utils/permit2.js';
 
 const YMAX_DOMAIN_NAME = 'Ymax';
 const YMAX_DOMAIN_VERSION = '1';
@@ -36,25 +36,25 @@ const StandaloneDomainTypeParams = [
   { name: 'version', type: 'string' },
   { name: 'chainId', type: 'uint256' },
   { name: 'verifyingContract', type: 'address' },
-] as const satisfies TypedDataParameter[];
+]                                        ;
 
 const YmaxStandaloneDomainBase = {
   name: YMAX_DOMAIN_NAME,
   version: YMAX_DOMAIN_VERSION,
-} as const satisfies TypedDataDomain;
-export type YmaxStandaloneDomain = typeof YmaxStandaloneDomainBase & {
-  chainId: bigint;
-  verifyingContract: Address;
-};
+}                                   ;
+;                                                                     
+                  
+                             
+  
 
 // A param to designate the portfolio in operations by its `portfolioId`
 const PortfolioIdParam = {
   name: 'portfolio',
   type: 'uint256',
-} as const satisfies TypedDataParameter;
+}                                      ;
 
 // XXX: Remove
-const SharedPortfolioTypeParams = [] as const satisfies TypedDataParameter[];
+const SharedPortfolioTypeParams = []                                        ;
 
 /**
  * Fields included in Permit data that we don't want duplicated in witness data,
@@ -63,7 +63,7 @@ const SharedPortfolioTypeParams = [] as const satisfies TypedDataParameter[];
 const PortfolioStandaloneTypeParams = [
   { name: 'nonce', type: 'uint256' },
   { name: 'deadline', type: 'uint256' },
-] as const satisfies TypedDataParameter[];
+]                                        ;
 
 /**
  * The set of portfolio operations supported by EVM Wallets, and their associated params
@@ -72,16 +72,16 @@ const OperationTypes = {
   OpenPortfolio: [{ name: 'allocations', type: 'Allocation[]' }],
   Rebalance: [{ name: 'allocations', type: 'Allocation[]' }, PortfolioIdParam],
   Deposit: [PortfolioIdParam],
-} as const satisfies TypedData;
-type OperationTypes = typeof OperationTypes;
-export type OperationTypeNames = keyof OperationTypes;
+}                             ;
+;                                           
+;                                                     
 
 const OperationSubTypes = {
   Allocation: [
     { name: 'instrument', type: 'string' },
     { name: 'portion', type: 'uint256' },
   ],
-} as const satisfies TypedData;
+}                             ;
 
 /**
  * Target allocation for portfolio positions.
@@ -92,86 +92,86 @@ const OperationSubTypes = {
  * - [{instrument: 'A', portion: 60}, {instrument: 'B', portion: 40}] => 60:40 ratio
  * - [{instrument: 'A', portion: 6}, {instrument: 'B', portion: 4}] => 6:4 ratio (same as 60:40)
  */
-export type TargetAllocation = TypedDataToPrimitiveTypes<
-  typeof OperationSubTypes
->['Allocation'];
+;                                                        
+                          
+                
 
 /**
  * In the wrapped case, the domain is fixed by permit2, so we can't choose name/version there.
  * so we put the ymax-specifc domain name and version in the type name.
  */
-const getYmaxWitnessTypeName = <T extends OperationTypeNames>(operation: T) =>
-  `${YMAX_DOMAIN_NAME}V${YMAX_DOMAIN_VERSION}${operation}` as const;
-type YmaxWitnessTypeName<T extends OperationTypeNames> = ReturnType<
-  typeof getYmaxWitnessTypeName<T>
->;
-const getYmaxWitnessFieldName = <T extends OperationTypeNames>(operation: T) =>
-  `${YMAX_WITNESS_FIELD_NAME_PREFIX}${operation}` as const;
-type YmaxWitnessFieldName<T extends OperationTypeNames> = ReturnType<
-  typeof getYmaxWitnessFieldName<T>
->;
+const getYmaxWitnessTypeName =                               (operation   ) =>
+  `${YMAX_DOMAIN_NAME}V${YMAX_DOMAIN_VERSION}${operation}`         ;
+;                                                                   
+                                  
+  
+const getYmaxWitnessFieldName =                               (operation   ) =>
+  `${YMAX_WITNESS_FIELD_NAME_PREFIX}${operation}`         ;
+;                                                                    
+                                   
+  
 
 /**
  * showing a field named "witness" in the wallet signing UI is... boring
  * so let's put something more relevant like the @{link OperationTypes}: Deposit etc.
  */
-const getYmaxWitnessTypeParam = <T extends OperationTypeNames>(
-  operation: T,
-): YmaxWitnessTypeParam<T> => ({
+const getYmaxWitnessTypeParam =                               (
+  operation   ,
+                         ) => ({
   name: getYmaxWitnessFieldName(operation),
   type: getYmaxWitnessTypeName(operation),
 });
-export type YmaxWitnessTypeParam<
-  T extends OperationTypeNames = OperationTypeNames,
-> = TypedDataParameter<YmaxWitnessFieldName<T>, YmaxWitnessTypeName<T>>;
+;                                
+                                                    
+                                                                        
 
 // TODO: Filter operation types to only those needed for witness/standalone
-type YmaxWitnessOperationTypes<
-  T extends OperationTypeNames = OperationTypeNames,
-> = {
-  [K in T as YmaxWitnessTypeName<K>]: [
-    ...OperationTypes[K],
-    ...typeof SharedPortfolioTypeParams,
-  ];
-};
-type YmaxWitnessTypes<T extends OperationTypeNames = OperationTypeNames> =
-  YmaxWitnessOperationTypes<T> & typeof OperationSubTypes;
-type YmaxStandaloneOperationTypes<
-  T extends OperationTypeNames = OperationTypeNames,
-> = {
-  [K in T]: [
-    ...OperationTypes[K],
-    ...typeof SharedPortfolioTypeParams,
-    ...typeof PortfolioStandaloneTypeParams,
-  ];
-};
-type YmaxStandaloneTypes<T extends OperationTypeNames = OperationTypeNames> =
-  YmaxStandaloneOperationTypes<T> &
-    typeof OperationSubTypes & {
-      EIP712Domain: typeof StandaloneDomainTypeParams;
-    };
-
-export type YmaxOperationType<T extends OperationTypeNames> =
-  TypedDataToPrimitiveTypes<OperationTypes & typeof OperationSubTypes>[T];
+;                              
+                                                    
+     
+                                       
+                         
+                                        
+    
+  
+;                                                                         
+                                                          
+;                                 
+                                                    
+     
+             
+                         
+                                        
+                                            
+    
+  
+;                                                                            
+                                   
+                                
+                                                      
+      
+
+;                                                            
+                                                                          
 
 // Hack to satisfy TypeScript limitations with generic inference in complex types
 // Equivalent to `YmaxWitnessTypeParam`
-type YmaxWitnessMappedTypeParam<T extends OperationTypeNames> =
-  TypedDataParameter<
-    YmaxWitnessFieldName<T>,
-    Extract<keyof YmaxWitnessOperationTypes<T>, string>
-  >;
+;                                                              
+                     
+                            
+                                                       
+    
 
-const getYmaxWitnessTypes = <T extends OperationTypeNames>(operation: T) =>
+const getYmaxWitnessTypes =                               (operation   ) =>
   ({
     [getYmaxWitnessTypeName(operation)]: [
       ...OperationTypes[operation],
       ...SharedPortfolioTypeParams,
     ],
     ...OperationSubTypes,
-  }) as YmaxWitnessTypes<T> satisfies TypedData;
+  })                                           ;
 
-const getYmaxStandaloneTypes = <T extends OperationTypeNames>(operation: T) =>
+const getYmaxStandaloneTypes =                               (operation   ) =>
   ({
     EIP712Domain: StandaloneDomainTypeParams,
     [operation]: [
@@ -180,24 +180,24 @@ const getYmaxStandaloneTypes = <T extends OperationTypeNames>(operation: T) =>
       ...PortfolioStandaloneTypeParams,
     ],
     ...OperationSubTypes,
-  }) as YmaxStandaloneTypes<T> satisfies TypedData;
+  })                                              ;
 
-export const getYmaxOperationTypes = <T extends OperationTypeNames>(
-  operation: T,
+export const getYmaxOperationTypes =                               (
+  operation   ,
 ) =>
   ({
     [operation]: OperationTypes[operation],
     ...OperationSubTypes,
-  }) as {
-    [K in T]: OperationTypes[K];
-  } & typeof OperationSubTypes satisfies TypedData;
-
-export const getYmaxWitness = <T extends OperationTypeNames>(
-  operation: T,
-  data: NoInfer<
-    TypedDataToPrimitiveTypes<YmaxWitnessTypes>[YmaxWitnessTypeName<T>]
-  >,
-): Witness<YmaxWitnessTypes<T>, YmaxWitnessMappedTypeParam<T>> =>
+  })     
+                                
+                                                  ;
+
+export const getYmaxWitness =                               (
+  operation   ,
+  data          
+                                                                       
+   ,
+                                                             ) =>
   // @ts-expect-error some generic inference issue I suppose?
   makeWitness(
     // @ts-expect-error some generic inference issue I suppose?
@@ -207,22 +207,22 @@ export const getYmaxWitness = <T extends OperationTypeNames>(
   );
 
 export const getYmaxStandaloneDomain = (
-  chainId: bigint | number,
-  verifyingContract: Address,
-): YmaxStandaloneDomain => ({
+  chainId                 ,
+  verifyingContract         ,
+                      ) => ({
   ...YmaxStandaloneDomainBase,
   chainId: BigInt(chainId),
   verifyingContract,
 });
 
-export const getYmaxStandaloneOperationData = <T extends OperationTypeNames>(
-  data: NoInfer<TypedDataToPrimitiveTypes<YmaxStandaloneTypes>[T]>,
-  operation: T,
-  chainId: bigint | number,
-  verifyingContract: Address,
-): TypedDataDefinition<YmaxStandaloneTypes<T>, T, T> & {
-  domain: YmaxStandaloneDomain;
-} => {
+export const getYmaxStandaloneOperationData =                               (
+  data                                                            ,
+  operation   ,
+  chainId                 ,
+  verifyingContract         ,
+                                                        
+                               
+) => {
   const types = getYmaxStandaloneTypes(operation);
 
   // @ts-expect-error some generic inference issue I suppose?
@@ -234,32 +234,32 @@ export const getYmaxStandaloneOperationData = <T extends OperationTypeNames>(
   };
 };
 
-export type YmaxStandaloneOperationData<
-  T extends OperationTypeNames = OperationTypeNames,
-> = ReturnType<typeof getYmaxStandaloneOperationData<T>>;
-
-export type YmaxPermitWitnessTransferFromData<
-  T extends OperationTypeNames = OperationTypeNames,
-> = ReturnType<
-  typeof getPermitWitnessTransferFromData<
-    YmaxWitnessTypes<T>,
-    YmaxWitnessMappedTypeParam<T>
-  >
->;
-
-export type YmaxPermitBatchWitnessTransferFromData<
-  T extends OperationTypeNames = OperationTypeNames,
-> = ReturnType<
-  typeof getPermitBatchWitnessTransferFromData<
-    YmaxWitnessTypes<T>,
-    YmaxWitnessMappedTypeParam<T>
-  >
->;
+;                                       
+                                                    
+                                                         
+
+;                                             
+                                                    
+               
+                                          
+                        
+                                 
+   
+  
+
+;                                                  
+                                                    
+               
+                                               
+                        
+                                 
+   
+  
 
 export function validateYmaxDomain(
-  domain: TypedDataDomain,
-  validContractAddresses?: Record<number | string, Address>,
-): asserts domain is YmaxStandaloneDomain {
+  domain                 ,
+  validContractAddresses                                   ,
+)                                         {
   if (domain.name !== YMAX_DOMAIN_NAME) {
     throw new Error(
       `Invalid Ymax domain name: ${domain.name} (expected ${YMAX_DOMAIN_NAME})`,
@@ -286,9 +286,9 @@ export function validateYmaxDomain(
   // XXX: check no extra fields?
 }
 
-export function validateYmaxOperationTypeName<T extends OperationTypeNames>(
-  typeName: string,
-): asserts typeName is T {
+export function validateYmaxOperationTypeName                              (
+  typeName        ,
+)                        {
   if (!(typeName in OperationTypes)) {
     throw new Error(
       `Unknown Ymax operation type: ${typeName} (expected one of ${Object.keys(OperationTypes).join(', ')})`,
@@ -296,8 +296,8 @@ export function validateYmaxOperationTypeName<T extends OperationTypeNames>(
   }
 }
 
-export const splitWitnessFieldType = <T extends OperationTypeNames>(
-  fieldName: `${typeof YMAX_DOMAIN_NAME}V${typeof YMAX_DOMAIN_VERSION}${T}`,
+export const splitWitnessFieldType =                               (
+  fieldName                                                                ,
 ) => {
   const match = fieldName.match(/^YmaxV(\d+)(\w+)$/u);
   if (!match) {
@@ -307,10 +307,10 @@ export const splitWitnessFieldType = <T extends OperationTypeNames>(
   const domain = {
     name: YMAX_DOMAIN_NAME,
     version,
-  } satisfies TypedDataDomain;
+  }                          ;
 
   validateYmaxDomain(domain);
-  validateYmaxOperationTypeName<T>(operation);
+  validateYmaxOperationTypeName   (operation);
 
   return {
     domain,

package/src/evm-wallet/message-handler-helpers.d.ts

@@ -7,8 +7,8 @@
  */
 import type { AbiParameterToPrimitiveType, Address, TypedDataDomain } from 'abitype';
 import type { hashStruct, isHex, recoverTypedDataAddress, validateTypedData } from 'viem/utils';
-import { encodeType, type WithSignature } from '@agoric/orchestration/src/utils/viem.ts';
-import { type PermitWitnessTransferFromInputComponents } from '@agoric/orchestration/src/utils/permit2.ts';
+import { encodeType, type WithSignature } from '@agoric/orchestration/src/utils/viem.js';
+import { type PermitWitnessTransferFromInputComponents } from '@agoric/orchestration/src/utils/permit2.js';
 import { type OperationTypeNames, type YmaxStandaloneOperationData, type YmaxPermitWitnessTransferFromData, type YmaxOperationType } from './eip712-messages.ts';
 export type YmaxOperationDetails<T extends OperationTypeNames = OperationTypeNames> = {
     [P in T]: {

package/src/evm-wallet/{message-handler-helpers.ts → message-handler-helpers.js}

@@ -6,82 +6,82 @@
  * on chain and in off-chain services.
  */
 
-import type {
-  AbiParameterToPrimitiveType,
-  Address,
-  TypedDataDomain,
-} from 'abitype';
-import type {
-  hashStruct,
-  isHex,
-  recoverTypedDataAddress,
-  RecoverTypedDataAddressParameters,
-  validateTypedData,
-} from 'viem/utils';
+             
+                              
+          
+                  
+                 
+             
+             
+        
+                          
+                                    
+                    
+                    
 import {
   encodeType,
-  type WithSignature,
-} from '@agoric/orchestration/src/utils/viem.ts';
+                     
+} from '@agoric/orchestration/src/utils/viem.js';
 import {
   extractWitnessFieldFromTypes,
   isPermit2MessageType,
   makeWitnessTypeStringExtractor,
-  type PermitWitnessTransferFromInputComponents,
-} from '@agoric/orchestration/src/utils/permit2.ts';
+                                                
+} from '@agoric/orchestration/src/utils/permit2.js';
 import {
-  type OperationTypeNames,
-  type YmaxStandaloneOperationData,
-  type YmaxPermitWitnessTransferFromData,
-  type YmaxOperationType,
+                          
+                                   
+                                         
+                         
   splitWitnessFieldType,
   validateYmaxDomain,
   validateYmaxOperationTypeName,
   getYmaxOperationTypes,
 } from './eip712-messages.ts';
 
-export type YmaxOperationDetails<
-  T extends OperationTypeNames = OperationTypeNames,
-> = {
-  [P in T]: {
-    operation: P;
-    data: YmaxOperationType<P>;
-  };
-}[T];
+;                                
+                                                    
+     
+             
+                 
+                               
+    
+     
 
-export type PermitWitnessTransferFromPayload = AbiParameterToPrimitiveType<{
-  type: 'tuple';
-  components: typeof PermitWitnessTransferFromInputComponents;
-}>;
+;                                                                           
+                
+                                                              
+   
 
-export type PermitDetails = {
-  chainId: NonNullable<TypedDataDomain['chainId']>;
-  token: Address;
-  amount: bigint;
-  spender: Address;
-  permit2Payload: Omit<PermitWitnessTransferFromPayload, 'transferDetails'>;
-};
+;                            
+                                                   
+                 
+                 
+                   
+                                                                            
+  
 
-export type FullMessageDetails<
-  T extends OperationTypeNames = OperationTypeNames,
-> = YmaxOperationDetails<T> & {
-  permitDetails?: PermitDetails;
-  evmWalletAddress: Address;
-  nonce: bigint;
-  deadline: bigint;
-};
+;                              
+                                                    
+                               
+                                
+                            
+                
+                   
+  
 
 /**
  * EVM Message handler utils that depend on 'viem' utils for their
  * implementation. Since on-chain we cannot directly import from 'viem',
  * use a maker pattern to create these utils.
  */
-export const makeEVMHandlerUtils = (viemUtils: {
-  isHex: typeof isHex;
-  hashStruct: typeof hashStruct;
-  recoverTypedDataAddress: typeof recoverTypedDataAddress;
-  validateTypedData: typeof validateTypedData;
-  encodeType: typeof encodeType;
-}) => {
+export const makeEVMHandlerUtils = (viemUtils   
+                      
+                                
+                                                          
+                                              
+                                
+ ) => {
   const {
     isHex,
     hashStruct,
@@ -95,21 +95,21 @@ export const makeEVMHandlerUtils = (viemUtils: {
    * @param data - The EIP-712 typed data of a standalone message
    * @returns The operation type name and associated data
    */
-  const extractOperationDetailsFromStandaloneData = <
-    T extends OperationTypeNames,
-  >(
-    data: YmaxStandaloneOperationData<T>,
-    validContractAddresses?: Record<number | string, Address>,
-  ): YmaxOperationDetails<T> => {
+  const extractOperationDetailsFromStandaloneData = (
+                                 
+    
+    data                                ,
+    validContractAddresses                                   ,
+                           ) => {
     // @ts-expect-error generic/union type compatibility
-    const standaloneData: YmaxStandaloneOperationData = data;
+    const standaloneData                              = data;
 
     validateYmaxDomain(standaloneData.domain, validContractAddresses);
-    validateYmaxOperationTypeName<T>(standaloneData.primaryType);
+    validateYmaxOperationTypeName   (standaloneData.primaryType);
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { nonce, deadline, ..._operationData } = standaloneData.message;
-    const operationData = _operationData as YmaxOperationType<T>;
+    const operationData = _operationData                        ;
     const operation = standaloneData.primaryType;
     // @ts-expect-error inference issue
     validateTypedData({
@@ -126,19 +126,19 @@ export const makeEVMHandlerUtils = (viemUtils: {
    * @param data - The EIP-712 typed data of a Permit2 witness message
    * @returns The operation type name and associated data
    */
-  const extractOperationDetailsFromPermit2WitnessData = <
-    T extends OperationTypeNames,
-  >(
-    data: YmaxPermitWitnessTransferFromData<T>,
-  ): YmaxOperationDetails<T> => {
+  const extractOperationDetailsFromPermit2WitnessData = (
+                                 
+    
+    data                                      ,
+                           ) => {
     // @ts-expect-error generic/union type compatibility
-    const permitData: YmaxPermitWitnessTransferFromData = data;
+    const permitData                                    = data;
 
     const witnessField = extractWitnessFieldFromTypes(permitData.types);
     const witnessData = permitData.message[
       witnessField.name
-    ] as YmaxOperationType<T>;
-    const operation = splitWitnessFieldType(witnessField.type).primaryType as T;
+    ]                        ;
+    const operation = splitWitnessFieldType(witnessField.type).primaryType     ;
     // @ts-expect-error inference issue
     validateTypedData({
       types: getYmaxOperationTypes(operation),
@@ -158,16 +158,16 @@ export const makeEVMHandlerUtils = (viemUtils: {
    * @param owner address of the permit2 message signer
    * @param signature signature of the permit2 message
    */
-  const extractPermitDetails = <T extends OperationTypeNames>(
-    data: YmaxPermitWitnessTransferFromData<T>,
-    owner: Address,
-    signature: WithSignature<object>['signature'],
-  ): PermitDetails => {
+  const extractPermitDetails =                               (
+    data                                      ,
+    owner         ,
+    signature                                    ,
+                 ) => {
     const witnessTypeStringExtractor = makeWitnessTypeStringExtractor({
       encodeType,
     });
     // @ts-expect-error generic/union type compatibility
-    const permitData: YmaxPermitWitnessTransferFromData = data;
+    const permitData                                    = data;
 
     if (!isHex(signature)) {
       throw new Error(`Invalid signature format: ${signature}`);
@@ -184,10 +184,10 @@ export const makeEVMHandlerUtils = (viemUtils: {
 
     const { spender, ...permitStruct } = permit;
 
-    const permit2Payload: Omit<
-      PermitWitnessTransferFromPayload,
-      'transferDetails'
-    > = {
+    const permit2Payload       
+                                       
+                       
+      = {
       permit: permitStruct,
       owner,
       witness,
@@ -195,8 +195,8 @@ export const makeEVMHandlerUtils = (viemUtils: {
       signature,
     };
 
-    const details: PermitDetails = {
-      chainId: permitData.domain!.chainId!,
+    const details                = {
+      chainId: permitData.domain .chainId ,
       token: permit.permitted.token,
       amount: permit.permitted.amount,
       permit2Payload,
@@ -213,26 +213,26 @@ export const makeEVMHandlerUtils = (viemUtils: {
    * @param signedData
    * @returns
    */
-  const extractOperationDetailsFromSignedData = async <
-    T extends OperationTypeNames = OperationTypeNames,
-  >(
-    signedData: WithSignature<
-      YmaxPermitWitnessTransferFromData<T> | YmaxStandaloneOperationData<T>
-    >,
-    validStandaloneContractAddresses?: Record<number | string, Address>,
-  ): Promise<FullMessageDetails<T>> => {
+  const extractOperationDetailsFromSignedData = async (
+                                                      
+    
+    signedData                
+                                                                           
+     ,
+    validStandaloneContractAddresses                                   ,
+                                  ) => {
     const tokenOwner = await recoverTypedDataAddress(
-      signedData as RecoverTypedDataAddressParameters,
+      signedData                                     ,
     );
     const { nonce, deadline } = (
-      signedData as unknown as
-        | YmaxPermitWitnessTransferFromData
-        | YmaxStandaloneOperationData
+      signedData              
+                                           
+                                     
     ).message;
 
     if (isPermit2MessageType(signedData.primaryType)) {
       const permit2Data =
-        signedData as unknown as YmaxPermitWitnessTransferFromData<T>;
+        signedData                                                   ;
 
       const permitDetails = extractPermitDetails(
         permit2Data,
@@ -251,7 +251,7 @@ export const makeEVMHandlerUtils = (viemUtils: {
       };
     } else {
       const standaloneData =
-        signedData as unknown as YmaxStandaloneOperationData<T>;
+        signedData                                             ;
       const operationDetails = extractOperationDetailsFromStandaloneData(
         standaloneData,
         validStandaloneContractAddresses,

package/src/{type-guards.ts → type-guards.js}

@@ -1,18 +1,18 @@
-import type { InstrumentId } from './instruments.js';
-import type {
-  DepositFromChainRef,
-  LocalChainAccountRef,
-  InterChainAccountRef,
-  WithdrawToChainRef,
-} from './types.js';
+                                                     
+             
+                      
+                       
+                       
+                     
+                    
 
 /**
  * Without regard to supported chains, is the input plausibly a
  * DepositFromChainRef (i.e., does it start with `+`)?
  */
 export const isDepositFromChainRef = (
-  ref: string,
-): ref is DepositFromChainRef => ref.startsWith('+');
+  ref        ,
+                            ) => ref.startsWith('+');
 harden(isDepositFromChainRef);
 
 /**
@@ -20,8 +20,8 @@ harden(isDepositFromChainRef);
  * LocalChainAccountRef (i.e., does it start with `+`)?
  */
 export const isLocalChainAccountRef = (
-  ref: string,
-): ref is LocalChainAccountRef => ref.startsWith('+');
+  ref        ,
+                             ) => ref.startsWith('+');
 harden(isLocalChainAccountRef);
 
 /**
@@ -29,15 +29,15 @@ harden(isLocalChainAccountRef);
  * InterChainAccountRef (i.e., does it start with `@`)?
  */
 export const isInterChainAccountRef = (
-  ref: string,
-): ref is InterChainAccountRef => ref.startsWith('@');
+  ref        ,
+                             ) => ref.startsWith('@');
 harden(isInterChainAccountRef);
 
 /**
  * Without regard to supported chains, is the input plausibly an InstrumentId
  * (i.e., does it start with an ASCII letter)?
  */
-export const isInstrumentId = (ref: string): ref is InstrumentId =>
+export const isInstrumentId = (ref        )                      =>
   !!ref.match(/^[a-z]/i);
 harden(isInstrumentId);
 
@@ -45,6 +45,6 @@ harden(isInstrumentId);
  * Without regard to supported chains, is the input plausibly a
  * WithdrawToChainRef (i.e., does it start with `-`)?
  */
-export const isWithdrawToChainRef = (ref: string): ref is WithdrawToChainRef =>
+export const isWithdrawToChainRef = (ref        )                            =>
   ref.startsWith('-');
 harden(isWithdrawToChainRef);

package/src/types.js

@@ -0,0 +1,234 @@
+/* eslint-disable @typescript-eslint/no-unused-vars -- doesn't see type usage in JSDoc */
+                                              
+import {
+                 
+                     
+                          
+                    
+} from '@agoric/orchestration';
+;            
+                           
+                         
+                                                 
+;            
+              
+                 
+                
+                        
+;                                                    
+;                                                
+;                                                                    
+
+/**
+ * Feature flags to handle contract upgrade flow compatibility.
+ */
+;                           
+                                           
+                               
+  
+
+/**
+ * Configuration options for flows.
+ */
+;                         
+                          
+  
+;                                            
+
+/**
+ * Reference to a local chain accounts (LCA).
+ * '+agoric' is published as `depositAddress`
+ */
+;                                            
+
+/**
+ * Identifies the blockchain hosting an address external to ymax from which
+ * funds for a deposit must be supplied.
+ */
+;                                                   
+
+/**
+ * Identifies the blockchain hosting an address external to ymax to which
+ * withdrawn funds will be sent.
+ */
+;                                                  
+
+;                                                       
+
+/**
+ * An AssetPlaceRef describes a place where funds can be, either an
+ * {@link InstrumentId} (starting with an ASCII letter), a {@link SeatKeyword}
+ * wrapped in `<...>` angle brackets, or a value consisting of a
+ * single-character punctuator followed by a SupportedChain (that character
+ * being `@` for {@link InterChainAccountRef}, `+` for
+ * {@link LocalChainAccountRef} and {@link DepositFromChainRef}, and `-` for
+ * {@link WithdrawToChainRef}).
+ */
+;                          
+                      
+                        
+                       
+                      
+                        
+                 
+
+;                                     
+
+/**
+ * Proposal shapes for portfolio operations.
+ *
+ * **openPortfolio**: Create portfolio with initial funding across protocols
+ * **rebalance**: Add funds (give) or withdraw funds (want) from protocols
+ */
+;                           
+                  
+           
+                                                                        
+                         
+                          
+      
+                 
+    
+            
+                                                    
+                                                 
+                                                       
+                                                         
+  
+
+/**
+ * Target allocation mapping from PoolKey to numerator (typically in basis points).
+ * Denominator is implicitly the sum of all numerators.
+ */
+;                                                                    
+
+;                       
+                                                                     
+                                                                      
+                           // aka simpleRebalance
+
+/** linked list of concurrent failures, including dependencies */
+;                         
+               
+              
+                
+                    
+  
+
+;                       
+     
+                   
+                                           
+                   
+                  
+                                                                 
+                       
+     
+                                                                 
+                                                
+                     
+                                     
+
+;                           
+                    
+                     
+                      
+                             
+                  
+                                      
+                                  
+                  
+  
+
+;                       
+                                                                                                  
+                                            
+              
+                    
+                     
+                      
+                               
+                            
+  
+
+/**
+ * Each step in the `flow` of a FundsFlowPlan can depend upon any number of
+ * other steps, subject to the complete directed graph being acyclic.
+ * The dependencies are expressed using 0-based indices.
+ */
+;                                                                            
+
+;                            
+                       
+                                                                          
+                               
+  
+
+;                            
+                          
+  
+
+;                                               
+;                                     
+
+;                        
+             
+                                                 
+                                                             
+    
+                         
+                             
+                                       
+               
+                               
+    
+              
+                                 
+                                                                 
+                                       
+                                   
+                                                                                              
+                                           
+                                        
+       
+                                                                                      
+                                                                       
+                                                                                  
+                                                                      
+       
+                                
+                                                                                                                 
+                          
+                                                                                                             
+                           
+                                               
+                      
+                                               
+    
+             
+                            
+                         
+                       
+                        
+    
+                                
+                        
+                                    
+  
+
+/**
+ * Names suitable for use as `publicInvitationMaker` in {@link ContractInvitationSpec}.
+ */
+;                                                                          
+
+/**
+ * Names suitable for use as `invitationMakerName` in {@link ContinuingInvitationSpec}.
+ *
+ * These continuing invitation makers are returned from portfolio creation and enable
+ * ongoing operations like rebalancing between yield protocols.
+ */
+;                                               
+             
+              
+               
+                      

package/src/evm/types.ts

@@ -1,22 +0,0 @@
-export type PortfolioPath =
-  `published.ymax${0 | 1}.portfolios.portfolio${number}`;
-
-export type EIPMessageUpdate =
-  | {
-      updated: 'messageUpdate';
-      nonce: bigint;
-      status: 'pending';
-    }
-  | {
-      updated: 'messageUpdate';
-      nonce: bigint;
-      error: string;
-      status: 'error';
-    }
-  | {
-      updated: 'messageUpdate';
-      nonce: bigint;
-      status: 'ok';
-    };
-
-export type EVMWalletUpdate = EIPMessageUpdate | never;

package/src/types.ts

@@ -1,234 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars -- doesn't see type usage in JSDoc */
-import type { NatAmount } from '@agoric/ertp';
-import {
-  type AccountId,
-  type Bech32Address,
-  type CosmosChainAddress,
-  type TrafficEntry,
-} from '@agoric/orchestration';
-import type {
-  ContinuingInvitationSpec,
-  ContractInvitationSpec,
-} from '@agoric/smart-wallet/src/invitations.js';
-import type {
-  AxelarChain,
-  SupportedChain,
-  YieldProtocol,
-} from './constants.js';
-import type { InstrumentId } from './instruments.js';
-import type { PublishedTx } from './resolver.js';
-import type { EVMWalletUpdate, PortfolioPath } from './evm/types.ts';
-
-/**
- * Feature flags to handle contract upgrade flow compatibility.
- */
-export type FlowFeatures = {
-  /** Control `ProgressTracker` support. */
-  useProgressTracker?: boolean;
-};
-
-/**
- * Configuration options for flows.
- */
-export type FlowConfig = {
-  features?: FlowFeatures;
-};
-export type SeatKeyword = 'Cash' | 'Deposit';
-
-/**
- * Reference to a local chain accounts (LCA).
- * '+agoric' is published as `depositAddress`
- */
-export type LocalChainAccountRef = '+agoric';
-
-/**
- * Identifies the blockchain hosting an address external to ymax from which
- * funds for a deposit must be supplied.
- */
-export type DepositFromChainRef = `+${AxelarChain}`;
-
-/**
- * Identifies the blockchain hosting an address external to ymax to which
- * withdrawn funds will be sent.
- */
-export type WithdrawToChainRef = `-${AxelarChain}`;
-
-export type InterChainAccountRef = `@${SupportedChain}`;
-
-/**
- * An AssetPlaceRef describes a place where funds can be, either an
- * {@link InstrumentId} (starting with an ASCII letter), a {@link SeatKeyword}
- * wrapped in `<...>` angle brackets, or a value consisting of a
- * single-character punctuator followed by a SupportedChain (that character
- * being `@` for {@link InterChainAccountRef}, `+` for
- * {@link LocalChainAccountRef} and {@link DepositFromChainRef}, and `-` for
- * {@link WithdrawToChainRef}).
- */
-export type AssetPlaceRef =
-  | `<${SeatKeyword}>`
-  | LocalChainAccountRef
-  | DepositFromChainRef
-  | WithdrawToChainRef
-  | InterChainAccountRef
-  | InstrumentId;
-
-type Empty = Record<never, NatAmount>;
-
-/**
- * Proposal shapes for portfolio operations.
- *
- * **openPortfolio**: Create portfolio with initial funding across protocols
- * **rebalance**: Add funds (give) or withdraw funds (want) from protocols
- */
-export type ProposalType = {
-  openPortfolio: {
-    give: {
-      /** required iff the contract was started with an Access issuer */
-      Access?: NatAmount;
-      Deposit?: NatAmount;
-    };
-    want?: Empty;
-  };
-  rebalance:
-    | { give: { Deposit?: NatAmount }; want: Empty }
-    | { want: { Cash: NatAmount }; give: Empty };
-  withdraw: { want: { Cash: NatAmount }; give: Empty };
-  deposit: { give: { Deposit: NatAmount }; want: Empty };
-};
-
-/**
- * Target allocation mapping from PoolKey to numerator (typically in basis points).
- * Denominator is implicitly the sum of all numerators.
- */
-export type TargetAllocation = Partial<Record<InstrumentId, bigint>>;
-
-export type FlowDetail =
-  | { type: 'withdraw'; amount: NatAmount; toChain?: SupportedChain }
-  | { type: 'deposit'; amount: NatAmount; fromChain?: SupportedChain }
-  | { type: 'rebalance' }; // aka simpleRebalance
-
-/** linked list of concurrent failures, including dependencies */
-export type FlowErrors = {
-  step: number;
-  how: string;
-  error: string;
-  next?: FlowErrors;
-};
-
-export type FlowStatus =
-  | {
-      state: 'run';
-      /** minimum currently running step */
-      step: number;
-      how: string;
-      /** currently running steps, when executing concurrently */
-      steps?: number[];
-    }
-  /** @deprecated - contract no longer does automatic recovery */
-  | { state: 'undo'; step: number; how: string }
-  | { state: 'done' }
-  | ({ state: 'fail' } & FlowErrors);
-
-export type MovementDesc = {
-  amount: NatAmount;
-  src: AssetPlaceRef;
-  dest: AssetPlaceRef;
-  /** for example: GMP fee */
-  fee?: NatAmount;
-  /** for example: { usdnOut: 98n } */
-  detail?: Record<string, bigint>;
-  claim?: boolean;
-};
-
-export type FlowStep = {
-  /** Human readable description of how the step accomplishes the transfer from `src` to `dest` */
-  // Distinct from `Way.how` in the contract
-  how: string;
-  amount: NatAmount;
-  src: AssetPlaceRef;
-  dest: AssetPlaceRef;
-  phases?: Record<string, any>;
-  // XXX all parts: fee etc.
-};
-
-/**
- * Each step in the `flow` of a FundsFlowPlan can depend upon any number of
- * other steps, subject to the complete directed graph being acyclic.
- * The dependencies are expressed using 0-based indices.
- */
-type FlowStepDependency = [stepIndex: number, prerequisiteIndexes: number[]];
-
-export type FundsFlowPlan = {
-  flow: MovementDesc[];
-  /** When `order` is absent, default to fully sequential dependencies. */
-  order?: FlowStepDependency[];
-};
-
-export type TrafficReport = {
-  traffic: TrafficEntry[];
-};
-
-export type PortfolioKey = `portfolio${number}`;
-export type FlowKey = `flow${number}`;
-
-export type StatusFor = {
-  contract: {
-    contractAccount: CosmosChainAddress['value'];
-    depositFactoryAddresses?: Record<AxelarChain, AccountId>;
-  };
-  pendingTx: PublishedTx;
-  evmWallet: EVMWalletUpdate;
-  evmWalletPortfolios: PortfolioPath[];
-  portfolios: {
-    addPortfolio: PortfolioKey;
-  };
-  portfolio: {
-    positionKeys: InstrumentId[];
-    accountIdByChain: Partial<Record<SupportedChain, AccountId>>;
-    accountsPending?: SupportedChain[];
-    depositAddress?: Bech32Address;
-    /** Noble Forwarding Address (NFA) registered by the contract for the `@agoric` address */
-    nobleForwardingAddress?: Bech32Address;
-    targetAllocation?: TargetAllocation;
-    /**
-     * CAIP-10 account ID of the authenticated EVM account that opened this portfolio.
-     * Derived from `permit2Payload.owner` in `openPortfolioFromEVM()`.
-     * The Permit2 signature is verified on-chain by the `depositFactory` contract
-     * when it receives the GMP call via `sendCreateAndDepositCall()`.
-     */
-    sourceAccountId?: AccountId;
-    /** incremented by the contract every time the user sends a transaction that the planner should respond to */
-    policyVersion: number;
-    /** the count of acknowledged submissions [from the planner] associated with the current policyVersion */
-    rebalanceCount: number;
-    /** @deprecated in favor of flowsRunning */
-    flowCount: number;
-    flowsRunning?: Record<FlowKey, FlowDetail>;
-  };
-  position: {
-    protocol: YieldProtocol;
-    accountId: AccountId;
-    totalIn: NatAmount;
-    totalOut: NatAmount;
-  };
-  flow: FlowStatus & FlowDetail;
-  flowSteps: FlowStep[];
-  flowOrder: FundsFlowPlan['order'];
-};
-
-/**
- * Names suitable for use as `publicInvitationMaker` in {@link ContractInvitationSpec}.
- */
-export type PortfolioPublicInvitationMaker = 'makeOpenPortfolioInvitation';
-
-/**
- * Names suitable for use as `invitationMakerName` in {@link ContinuingInvitationSpec}.
- *
- * These continuing invitation makers are returned from portfolio creation and enable
- * ongoing operations like rebalancing between yield protocols.
- */
-export type PortfolioContinuingInvitationMaker =
-  | 'Deposit'
-  | 'Withdraw'
-  | 'Rebalance'
-  | 'SimpleRebalance';