@agoric/portfolio-api 0.1.1-dev-159ee8a.0.159ee8a → 0.1.1-dev-6deecfc.0.6deecfc

package/src/places.js

@@ -0,0 +1,190 @@
+import { Fail } from '@endo/errors';
+
+;            
+              
+                 
+                
+                        
+;                                                    
+;                                               
+
+const isPrimitive = (value         )          => Object(value) !== value;
+
+const deepFreeze =    (value   )    => {
+  if (isPrimitive(value)) return value;
+  const obj = value                                ;
+  Object.freeze(obj);
+  for (const key of Reflect.ownKeys(obj)) {
+    deepFreeze(obj[key]);
+  }
+  return value;
+};
+
+;                          
+                                                             
+                                                        
+
+// XXX special handling. What's the functional difference from other places?
+export const BeefyPoolPlaces = {
+  Beefy_re7_Avalanche: {
+    protocol: 'Beefy',
+    chainName: 'Avalanche',
+  },
+  Beefy_morphoGauntletUsdc_Ethereum: {
+    protocol: 'Beefy',
+    chainName: 'Ethereum',
+  },
+  Beefy_morphoSmokehouseUsdc_Ethereum: {
+    protocol: 'Beefy',
+    chainName: 'Ethereum',
+  },
+  Beefy_morphoSeamlessUsdc_Base: {
+    protocol: 'Beefy',
+    chainName: 'Base',
+  },
+  Beefy_compoundUsdc_Optimism: {
+    protocol: 'Beefy',
+    chainName: 'Optimism',
+  },
+  Beefy_compoundUsdc_Arbitrum: {
+    protocol: 'Beefy',
+    chainName: 'Arbitrum',
+  },
+}                                                                ;
+deepFreeze(BeefyPoolPlaces);
+
+;                                                            
+
+export const ERC4626PoolPlaces = {
+  ERC4626_vaultU2_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoClearstarHighYieldUsdc_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoClearstarUsdcCore_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoGauntletUsdcRwa_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoSteakhouseHighYieldInstant_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoClearstarInstitutionalUsdc_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoClearstarUsdcReactor_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoAlphaUsdcCore_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoResolvUsdc_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoGauntletUsdcFrontier_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoHyperithmUsdcMidcurve_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoHyperithmUsdcDegen_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoGauntletUsdcCore_Ethereum: {
+    protocol: 'ERC4626',
+    chainName: 'Ethereum',
+  },
+  ERC4626_morphoSteakhousePrimeUsdc_Base: {
+    protocol: 'ERC4626',
+    chainName: 'Base',
+  },
+  ERC4626_morphoSteakhouseUsdc_Base: {
+    protocol: 'ERC4626',
+    chainName: 'Base',
+  },
+  ERC4626_morphoGauntletUsdcPrime_Base: {
+    protocol: 'ERC4626',
+    chainName: 'Base',
+  },
+  ERC4626_morphoSeamlessUsdcVault_Base: {
+    protocol: 'ERC4626',
+    chainName: 'Base',
+  },
+  ERC4626_morphoSteakhouseHighYieldUsdc_Arbitrum: {
+    protocol: 'ERC4626',
+    chainName: 'Arbitrum',
+  },
+  ERC4626_morphoGauntletUsdcCore_Arbitrum: {
+    protocol: 'ERC4626',
+    chainName: 'Arbitrum',
+  },
+  ERC4626_morphoHyperithmUsdc_Arbitrum: {
+    protocol: 'ERC4626',
+    chainName: 'Arbitrum',
+  },
+  ERC4626_morphoGauntletUsdcPrime_Optimism: {
+    protocol: 'ERC4626',
+    chainName: 'Optimism',
+  },
+}                                                                ;
+deepFreeze(ERC4626PoolPlaces);
+
+;                                                                
+
+export const PoolPlaces = {
+  USDN: { protocol: 'USDN', vault: null, chainName: 'noble' }, // MsgSwap only
+  USDNVault: { protocol: 'USDN', vault: 1, chainName: 'noble' }, // MsgSwap, MsgLock
+  Aave_Avalanche: { protocol: 'Aave', chainName: 'Avalanche' },
+  Aave_Ethereum: { protocol: 'Aave', chainName: 'Ethereum' },
+  Aave_Optimism: { protocol: 'Aave', chainName: 'Optimism' },
+  Aave_Arbitrum: { protocol: 'Aave', chainName: 'Arbitrum' },
+  Aave_Base: { protocol: 'Aave', chainName: 'Base' },
+  Compound_Ethereum: { protocol: 'Compound', chainName: 'Ethereum' },
+  Compound_Optimism: { protocol: 'Compound', chainName: 'Optimism' },
+  Compound_Arbitrum: { protocol: 'Compound', chainName: 'Arbitrum' },
+  Compound_Base: { protocol: 'Compound', chainName: 'Base' },
+  ...BeefyPoolPlaces,
+  ...ERC4626PoolPlaces,
+}                                                       ;
+deepFreeze(PoolPlaces);
+
+;                                  
+
+/**
+ * Without regard to supported chains, is the input plausibly an InstrumentId
+ * (i.e., does it start with an ASCII letter)?
+ */
+export const isInstrumentId = (ref        )                      =>
+  !!ref.match(/^[a-z]/i);
+deepFreeze(isInstrumentId);
+
+// XXX Possible to consolidate with {@link getChainNameOfPlaceRef}?
+export const chainOf = (id               )                 => {
+  if (id.startsWith('<')) return 'agoric';
+  if (!isInstrumentId(id)) return id.slice(1)                  ;
+  if (Object.hasOwn(PoolPlaces, id)) {
+    return PoolPlaces[id           ].chainName;
+  }
+
+  // Fallback: syntactic pool id like `${Protocol}_${Chain}` => `${Chain}`.
+  // This enables base graph edges for pools even if not listed in PoolPlaces.
+  const m = /^([A-Za-z0-9]+)_([A-Za-z0-9-]+)$/.exec(id);
+  if (m) return m[2]                  ;
+
+  throw Fail`Cannot determine chain for ${id}`;
+};
+deepFreeze(chainOf);

package/src/target-balances.d.ts

@@ -0,0 +1,42 @@
+import type { Brand, NatAmount, NatValue } from '@agoric/ertp/src/types.js';
+import { type SupportedChain } from './constants.js';
+import type { AssetPlaceRef, TargetAllocation } from './types.js';
+import type { NetworkSpec } from './network/network-spec.js';
+export declare const DEFAULT_DELTA_SOFT_MIN = 1000000n;
+export declare const TargetBalanceError: ErrorConstructor;
+export type ComputeTargetBalancesOptions<C extends AssetPlaceRef, T extends string & keyof TargetAllocation> = {
+    /**
+     * Brand for the returned nat amounts. It must match the brand used by
+     * `currentBalances`.
+     */
+    brand: Brand<'nat'>;
+    /** Current portfolio balances keyed by pool, hub, or local place. */
+    currentBalances: Partial<Record<C, NatAmount>>;
+    /**
+     * Signed balance change to apply before computing targets. Deposits are
+     * positive, withdrawals are negative, and rebalances are zero.
+     */
+    balanceDelta?: NatValue;
+    /** Relative target weights. Empty means preserve the non-hub status quo. */
+    targetAllocation?: Partial<Pick<TargetAllocation, T>>;
+    /** Static network constraints and pool availability. */
+    network: NetworkSpec;
+    /**
+     * Chain providing a deposit. Used to keep funds on a reachable hub when a
+     * target sink is unavailable or suppressed.
+     */
+    depositFromChain?: SupportedChain;
+};
+/**
+ * Derive target balances for allocation keys, suppressing small changes and
+ * movements blocked by e.g. lack of instrument liquidity or available capacity.
+ * When target allocations cannot be satisfied, strive for proportionality and
+ * bend the rules for a withdrawal, but do not increase any position beyond its
+ * target allocation (opting instead to leave the excess at a non-instrument
+ * hub).
+ *
+ * Returns only entries whose values change by at least ACCOUNT_DUST_EPSILON
+ * compared to current.
+ */
+export declare const computeTargetBalances: <C extends AssetPlaceRef, T extends string & keyof TargetAllocation>({ brand, currentBalances, balanceDelta, targetAllocation, network, depositFromChain, }: ComputeTargetBalancesOptions<C, T>) => Partial<Record<C | T, NatAmount>>;
+//# sourceMappingURL=target-balances.d.ts.map

package/src/target-balances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target-balances.d.ts","sourceRoot":"","sources":["target-balances.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAO5E,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE3E,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAElE,OAAO,KAAK,EAEV,WAAW,EAEZ,MAAM,2BAA2B,CAAC;AAInC,eAAO,MAAM,sBAAsB,WAAa,CAAC;AAEjD,eAAO,MAAM,kBAAkB,EAA6B,gBAAgB,CAAC;AAG7E,MAAM,MAAM,4BAA4B,CACtC,CAAC,SAAS,aAAa,EACvB,CAAC,SAAS,MAAM,GAAG,MAAM,gBAAgB,IACvC;IACF;;;OAGG;IACH,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACpB,qEAAqE;IACrE,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;IAC/C;;;OAGG;IACH,YAAY,CAAC,EAAE,QAAQ,CAAC;IACxB,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,CAAC;IACtD,wDAAwD;IACxD,OAAO,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,cAAc,CAAC;CACnC,CAAC;AAwFF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,GAChC,CAAC,SAAS,aAAa,EACvB,CAAC,SAAS,MAAM,GAAG,MAAM,gBAAgB,EACzC,wFAOC,4BAA4B,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,CA0OvE,CAAC"}

package/src/target-balances.js

@@ -0,0 +1,394 @@
+                                                                            
+import {
+  fromTypedEntries,
+  objectMap,
+  provideLazyMap,
+  typedEntries,
+} from '@agoric/internal';
+import { ACCOUNT_DUST_EPSILON,                     } from './constants.js';
+import { chainOf, isInstrumentId } from './places.js';
+;                                                                 
+
+;            
+            
+              
+           
+                                   
+
+const hardenOrFreeze = globalThis.harden ?? Object.freeze;
+
+export const DEFAULT_DELTA_SOFT_MIN = 1_000_000n; // 1 USDC
+
+export const TargetBalanceError = class extends Error {}                    ;
+hardenOrFreeze(TargetBalanceError);
+
+;                                        
+                          
+                                            
+     
+     
+                                                                        
+                       
+     
+                      
+                                                                       
+                                                 
+     
+                                                                          
+                                                                 
+     
+                          
+                                                                              
+                                                        
+                                                          
+                       
+     
+                                                                            
+                                              
+     
+                                    
+  
+
+;                   
+                   
+                  
+  
+
+const placeRecordsByNetwork = new WeakMap 
+              
+                                 
+ ();
+
+const failTargetBalance = (message        )        => {
+  throw new TargetBalanceError(message);
+};
+
+const failInternal = (message        )        => {
+  throw Error(message);
+};
+
+const getOwn =    (
+  obj                                 ,
+  key             ,
+               ) => (Object.hasOwn(obj, key) ? obj[key] : undefined);
+
+const isDust = (value        )          =>
+  -ACCOUNT_DUST_EPSILON < value && value < ACCOUNT_DUST_EPSILON;
+
+// #region XXX These probably belong in @agoric/internal.
+const bigintAbs = (x        ) => (x < 0n ? -x : x);
+
+const bigintMin = (first        , ...rest          )         => {
+  let min = first;
+  for (const arg of rest) {
+    if (arg < min) min = arg;
+  }
+  return min;
+};
+// #endregion
+
+const sortEntriesDesc =                                                    (
+  entries     ,
+     ) => entries.sort(([_k1, a], [_k2, b]) => (a < b ? 1 : a > b ? -1 : 0));
+
+const makeNatAmount = (brand              , value          )            => {
+  value >= 0n ||
+    failInternal(`internal: computed negative target balance ${value}`);
+  return hardenOrFreeze({ brand, value })             ;
+};
+
+const getPlaceData = (
+  place               ,
+  network             ,
+             ) => {
+  // The `chains` and `pools` arrays of `network` are immutable, so we only need
+  // to build its corresponding Map<AssetPlaceRef, PlaceRecord> once.
+  const placeRecords = provideLazyMap(placeRecordsByNetwork, network, () => {
+    const records = new Map                            ();
+    for (const chain of network.chains) {
+      records.set(`@${chain.name}`                 , { chain });
+    }
+    for (const pool of network.pools) {
+      const chainRecord =
+        records.get(`@${pool.chain}`                 ) ??
+        failInternal(`No chain found for pool ${pool.pool}`);
+      records.set(pool.pool                 , {
+        chain: chainRecord.chain,
+        pool,
+      });
+    }
+    return records;
+  });
+
+  // `network.pools` is not necessarily complete.
+  return provideLazyMap(placeRecords, place, () => {
+    const chainName = chainOf(place);
+    const chainRecord =
+      placeRecords.get(`@${chainName}`                 ) ??
+      failInternal(`No chain found for asset place ${place}`);
+    return { chain: chainRecord.chain };
+  });
+};
+
+const isNonemptyPositionEntry = (entry                           )          => {
+  const [place, value] = entry;
+  return isInstrumentId(place) && value > 0n;
+};
+
+/**
+ * Derive target balances for allocation keys, suppressing small changes and
+ * movements blocked by e.g. lack of instrument liquidity or available capacity.
+ * When target allocations cannot be satisfied, strive for proportionality and
+ * bend the rules for a withdrawal, but do not increase any position beyond its
+ * target allocation (opting instead to leave the excess at a non-instrument
+ * hub).
+ *
+ * Returns only entries whose values change by at least ACCOUNT_DUST_EPSILON
+ * compared to current.
+ */
+export const computeTargetBalances = (
+                          
+                                            
+  {
+  brand,
+  currentBalances,
+  balanceDelta = 0n,
+  targetAllocation = {},
+  network,
+  depositFromChain,
+}                                    )                                    => {
+  const currentValues = objectMap(
+    currentBalances                        ,
+    amount => amount.value,
+  )                                ;
+  const currentTotal = Object.values          (
+    currentValues                       ,
+  ).reduce((acc, value) => acc + value, 0n);
+  const total = currentTotal + balanceDelta;
+  total >= 0n || failTargetBalance('Insufficient funds for withdrawal.');
+  let liquidTotal = total;
+
+  ;                           
+  const allWeights       = Object.keys(targetAllocation).length
+    ? (typedEntries({
+        // Any current balance with no target has an effective weight of 0.
+        ...objectMap(currentValues, () => 0n),
+        ...(targetAllocation                                     ),
+      }                                    )        )
+    : // In the absence of target weights, maintain the relative status quo but
+      // zero out hubs (chains) if there is anywhere else to deploy their funds.
+      (valueEntries => {
+        return valueEntries.some(isNonemptyPositionEntry)
+          ? valueEntries.map(([p, v]) => [p, isInstrumentId(p) ? v : 0n]      )
+          : (valueEntries        );
+      })(typedEntries(currentValues)                   );
+  allWeights.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+  let sumW = allWeights.reduce((acc, entry) => acc + entry[1], 0n);
+  sumW > 0n ||
+    failTargetBalance('Total target allocation weights must be positive.');
+
+  ;                   
+                          
+                              
+                              
+                               
+                                   
+                                    
+                                    
+                     
+                                        
+                            
+    
+  const makeDraftRecord = (
+    place       ,
+    weight           = 0n,
+               ) => {
+    const placeData = getPlaceData(place, network);
+    return {
+      place,
+      chain: placeData.chain,
+      weight,
+      current: getOwn(currentValues, place) ?? 0n,
+      blockDeposit: !!placeData.pool?.blockDepositReason,
+      blockWithdraw: !!placeData.pool?.blockWithdrawReason,
+      deltaSoftMin: placeData.chain.deltaSoftMin ?? DEFAULT_DELTA_SOFT_MIN,
+
+      target: 0n,
+      delta: 0n,
+      resolvedDelta: 0n,
+    };
+  };
+  const draft                             = Object.assign(
+    Object.create(null)                              ,
+    fromTypedEntries(
+      allWeights.map(([place, weight]) => {
+        return [place, makeDraftRecord(place, weight)]                        ;
+      }),
+    ),
+  );
+
+  // Blocked/suppressed sources proportionally reduce the other targets,
+  // potentially even cascading into new blocked sources (e.g., A/B/C/D target
+  // balances 40/20/20/20 can become 52/16/16/16 from A being withdraw-blocked
+  // at current 52, and then 52/15/15/18 from the originally-a-sink D being
+  // withdraw-blocked at current 18.
+  const suppressions = new Map                         ();
+  for (;;) {
+    const badSources                                 = [];
+    const needsSuppress                                 = [];
+    for (const [place, draftRecord] of typedEntries(draft)) {
+      if (suppressions.has(place)) continue;
+      const { weight, current, blockDeposit, blockWithdraw } = draftRecord;
+      const target = (liquidTotal * weight) / sumW; // rounds down
+      /** positive delta is a sink, negative delta is a source */
+      const delta = target - current;
+      Object.assign(draftRecord, { target, delta });
+      const absDelta = bigintAbs(delta);
+      const isBlocked =
+        (delta > 0n && blockDeposit) || (delta < 0n && blockWithdraw);
+      const isSuppressed = delta !== 0n && absDelta < draftRecord.deltaSoftMin;
+      if (isBlocked && delta < 0n) {
+        badSources.push([draftRecord, 0n]);
+      } else if (isSuppressed && delta < 0n) {
+        needsSuppress.push([draftRecord, draftRecord.deltaSoftMin - absDelta]);
+      }
+      draftRecord.resolvedDelta = isBlocked || isSuppressed ? 0n : delta;
+    }
+
+    if (badSources.length === 0) {
+      // No sources to block, but there still might be suppressions.
+      // Cement those with the largest gap.
+      sortEntriesDesc(needsSuppress);
+      for (let i = 0; i < needsSuppress.length; i += 1) {
+        const gap = needsSuppress[i][1];
+        if (i > 0 && gap !== needsSuppress[i - 1][1]) break;
+        badSources.push(needsSuppress[i]);
+      }
+    }
+    for (const [source, gap] of badSources) {
+      const { place, current, weight, blockWithdraw } = source;
+      // A blocked source is not usable even as a withdrawal fallback.
+      if (blockWithdraw) delete draft[place];
+      if (suppressions.has(place)) continue;
+      suppressions.set(place, gap);
+      liquidTotal -= current;
+      sumW -= weight;
+    }
+    if (badSources.length === 0 || liquidTotal < 0n) break;
+  }
+
+  // If all sources are suppressed for a deposit or rebalance, we're done.
+  if (liquidTotal <= 0n && balanceDelta >= 0n) return {};
+
+  // If all sources are suppressed for a withdrawal, try to succeed anyway but
+  // minimize the count of affected places rather than the divergence from
+  // allocation.
+  if (liquidTotal < 0n && balanceDelta < 0n) {
+    const fallback = Object.create(null)                                     ;
+    let unsatisfied = -balanceDelta;
+    for (const [place, value] of sortEntriesDesc(
+      typedEntries(currentValues)                   ,
+    )) {
+      if (isDust(value)) break;
+      if (draft[place]?.blockWithdraw !== false) continue;
+      const take = bigintMin(unsatisfied, value);
+      fallback[place] = makeNatAmount(brand, value - take);
+      unsatisfied -= take;
+      if (unsatisfied === 0n) return { ...fallback };
+    }
+    // TODO(AGO-535): Effect a partial withdrawal here if necessary (e.g., when
+    // some requested funds are in a low-liquidity position).
+    return {};
+  }
+
+  // Blocked/suppressed *sinks* just leave funds in a source chain account.
+  // We track chain-level outflow to know which one.
+  const outByChain                                            = {};
+  for (const [place, { chain, delta }] of typedEntries(draft)) {
+    if (suppressions.has(place)) continue;
+    const chainName = chain.name;
+    outByChain[chainName] = (getOwn(outByChain, chainName) ?? 0n) - delta;
+  }
+  if (depositFromChain) {
+    outByChain[depositFromChain] =
+      (getOwn(outByChain, depositFromChain) ?? 0n) + balanceDelta;
+  }
+  const donorChainsDesc = sortEntriesDesc(
+    typedEntries(outByChain)                                ,
+  );
+  let remainder = liquidTotal;
+  const pending = new Set             (Object.values(draft));
+  for (const draftRecord of pending) {
+    pending.delete(draftRecord);
+    const { place, current, delta, resolvedDelta } = draftRecord;
+    if (suppressions.has(place)) continue;
+    // No adjustment is necessary for a source and/or satisfied delta.
+    if (delta <= 0n || resolvedDelta !== 0n) {
+      const newBalance = current + resolvedDelta;
+      remainder -= newBalance;
+      continue;
+    }
+
+    // This sink cannot receive its inbound funds. If its chain is a net source
+    // or neutral, we leave them at the local hub. Otherwise, we reduce the net
+    // outflow from one or more donor-chain hubs.
+    remainder -= current;
+    const local = getPlaceData(place, network).chain;
+    const localNetOut = donorChainsDesc.find(([n]) => n === local.name) [1];
+    if (localNetOut >= 0n) {
+      const chainPlace = `@${local.name}`         ;
+      draft[chainPlace] ??= makeDraftRecord(chainPlace);
+      draft[chainPlace].resolvedDelta += delta;
+      if (!pending.has(draft[chainPlace])) remainder -= delta;
+    } else {
+      let excess = delta;
+      for (const donorEntry of donorChainsDesc) {
+        const [chainName, netOut] = donorEntry;
+        if (excess === 0n || netOut <= 0n) break;
+        const chainPlace = `@${chainName}`         ;
+        draft[chainPlace] ??= makeDraftRecord(chainPlace);
+        const d = bigintMin(excess, netOut);
+        if (!pending.has(draft[chainPlace])) remainder -= d;
+        draft[chainPlace].resolvedDelta += d;
+        donorEntry[1] -= d;
+        excess -= d;
+      }
+      if (excess !== 0n) {
+        failInternal(`internal: Unable to suppress ${place}`);
+      }
+      sortEntriesDesc(donorChainsDesc);
+    }
+  }
+
+  // We have our targets. Distribute any rounding loss to the highest-weight
+  // place that can accept it.
+  // XXX We should instead redistribute to minimize error.
+  if (remainder !== 0n) {
+    const weightsDesc = sortEntriesDesc(allWeights);
+    for (const [place, _w] of weightsDesc) {
+      if (draft[place]?.blockDeposit) continue;
+      draft[place] ??= makeDraftRecord(place);
+      const newDelta = draft[place].resolvedDelta + remainder;
+      if (newDelta === 0n || !isDust(newDelta)) {
+        draft[place].resolvedDelta = newDelta;
+        remainder = 0n;
+        break;
+      }
+    }
+    remainder === 0n ||
+      failTargetBalance(
+        `Nowhere to place ${remainder} in target balance update`,
+      );
+  }
+
+  // Return a mutable Record that omits no-change entries.
+  const result = Object.create(null)                                     ;
+  for (const [place, draftRecord] of typedEntries(draft)) {
+    const { current, resolvedDelta } = draftRecord;
+    if (resolvedDelta === 0n) continue;
+    const targetValue = current + resolvedDelta;
+    result[place] = makeNatAmount(brand, targetValue);
+  }
+  return { ...result };
+};
+hardenOrFreeze(computeTargetBalances);

package/src/type-guards.d.ts

@@ -1,6 +1,6 @@
-import type { BeefyInstrumentId, ERC4626InstrumentId } from '@aglocal/portfolio-contract/src/type-guards.js';
-import type { InstrumentId } from './instruments.js';
+import type { BeefyInstrumentId, ERC4626InstrumentId } from './places.js';
 import type { DepositFromChainRef, LocalChainAccountRef, InterChainAccountRef, WithdrawToChainRef } from './types.js';
+export { isInstrumentId } from './places.js';
 /**
  * Without regard to supported chains, is the input plausibly a
  * DepositFromChainRef (i.e., does it start with `+`)?
@@ -16,11 +16,6 @@ export declare const isLocalChainAccountRef: (ref: string) => ref is LocalChainA
  * InterChainAccountRef (i.e., does it start with `@`)?
  */
 export declare const isInterChainAccountRef: (ref: string) => ref is InterChainAccountRef;
-/**
- * Without regard to supported chains, is the input plausibly an InstrumentId
- * (i.e., does it start with an ASCII letter)?
- */
-export declare const isInstrumentId: (ref: string) => ref is InstrumentId;
 /**
  * Without regard to supported chains, is the input plausibly a
  * WithdrawToChainRef (i.e., does it start with `-`)?

package/src/type-guards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["type-guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,gDAAgD,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAChC,KAAK,MAAM,KACV,GAAG,IAAI,mBAA0C,CAAC;AAGrD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GACjC,KAAK,MAAM,KACV,GAAG,IAAI,oBAA2C,CAAC;AAGtD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GACjC,KAAK,MAAM,KACV,GAAG,IAAI,oBAA2C,CAAC;AAGtD;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,KAAG,GAAG,IAAI,YAC5B,CAAC;AAGzB;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,KAAK,MAAM,KAAG,GAAG,IAAI,kBACrC,CAAC;AAGtB;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAChC,KAAK,MAAM,KACV,GAAG,IAAI,mBAAiD,CAAC;AAG5D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,KAAG,GAAG,IAAI,iBAC/B,CAAC"}
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["type-guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAChC,KAAK,MAAM,KACV,GAAG,IAAI,mBAA0C,CAAC;AAGrD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GACjC,KAAK,MAAM,KACV,GAAG,IAAI,oBAA2C,CAAC;AAGtD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GACjC,KAAK,MAAM,KACV,GAAG,IAAI,oBAA2C,CAAC;AAGtD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,KAAK,MAAM,KAAG,GAAG,IAAI,kBACrC,CAAC;AAGtB;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAChC,KAAK,MAAM,KACV,GAAG,IAAI,mBAAiD,CAAC;AAG5D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,KAAG,GAAG,IAAI,iBAC/B,CAAC"}

package/src/type-guards.js

@@ -1,8 +1,4 @@
-             
-                    
-                      
-                                                        
-                                                     
+                                                                          
              
                       
                        
@@ -10,6 +6,8 @@
                      
                     
 
+export { isInstrumentId } from './places.js';
+
 /**
  * Without regard to supported chains, is the input plausibly a
  * DepositFromChainRef (i.e., does it start with `+`)?
@@ -37,14 +35,6 @@ export const isInterChainAccountRef = (
                              ) => 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        )                      =>
-  !!ref.match(/^[a-z]/i);
-harden(isInstrumentId);
-
 /**
  * Without regard to supported chains, is the input plausibly a
  * WithdrawToChainRef (i.e., does it start with `-`)?