@agoric/vats 0.15.2-dev-d756c83.0.d756c83 → 0.15.2-dev-9b2a827.0.9b2a827

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vats",
-  "version": "0.15.2-dev-d756c83.0.d756c83",
+  "version": "0.15.2-dev-9b2a827.0.9b2a827",
   "description": "Agoric's Vat library",
   "type": "module",
   "main": "./index.js",
@@ -8,8 +8,8 @@
   "scripts": {
     "build": "yarn build:bundles",
     "build:bundles": "node scripts/build-bundles.js",
-    "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",
@@ -22,19 +22,19 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/cosmic-proto": "0.4.1-dev-d756c83.0.d756c83",
-    "@agoric/ertp": "0.16.3-dev-d756c83.0.d756c83",
-    "@agoric/governance": "0.10.4-dev-d756c83.0.d756c83",
-    "@agoric/internal": "0.3.3-dev-d756c83.0.d756c83",
-    "@agoric/network": "0.1.1-dev-d756c83.0.d756c83",
-    "@agoric/notifier": "0.6.3-dev-d756c83.0.d756c83",
-    "@agoric/store": "0.9.3-dev-d756c83.0.d756c83",
-    "@agoric/swingset-vat": "0.32.3-dev-d756c83.0.d756c83",
-    "@agoric/time": "0.3.3-dev-d756c83.0.d756c83",
-    "@agoric/vat-data": "0.5.3-dev-d756c83.0.d756c83",
-    "@agoric/vow": "0.1.1-dev-d756c83.0.d756c83",
-    "@agoric/zoe": "0.26.3-dev-d756c83.0.d756c83",
-    "@agoric/zone": "0.2.3-dev-d756c83.0.d756c83",
+    "@agoric/cosmic-proto": "0.4.1-dev-9b2a827.0.9b2a827",
+    "@agoric/ertp": "0.16.3-dev-9b2a827.0.9b2a827",
+    "@agoric/governance": "0.10.4-dev-9b2a827.0.9b2a827",
+    "@agoric/internal": "0.3.3-dev-9b2a827.0.9b2a827",
+    "@agoric/network": "0.1.1-dev-9b2a827.0.9b2a827",
+    "@agoric/notifier": "0.6.3-dev-9b2a827.0.9b2a827",
+    "@agoric/store": "0.9.3-dev-9b2a827.0.9b2a827",
+    "@agoric/swingset-vat": "0.32.3-dev-9b2a827.0.9b2a827",
+    "@agoric/time": "0.3.3-dev-9b2a827.0.9b2a827",
+    "@agoric/vat-data": "0.5.3-dev-9b2a827.0.9b2a827",
+    "@agoric/vow": "0.1.1-dev-9b2a827.0.9b2a827",
+    "@agoric/zoe": "0.26.3-dev-9b2a827.0.9b2a827",
+    "@agoric/zone": "0.2.3-dev-9b2a827.0.9b2a827",
     "@endo/errors": "^1.2.13",
     "@endo/far": "^1.1.14",
     "@endo/import-bundle": "^1.5.2",
@@ -47,7 +47,7 @@
     "jessie.js": "^0.3.4"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-d756c83.0.d756c83",
+    "@agoric/swingset-liveslots": "0.10.3-dev-9b2a827.0.9b2a827",
     "@endo/bundle-source": "^4.1.2",
     "@endo/init": "^1.1.12",
     "ava": "^5.3.0",
@@ -79,5 +79,5 @@
   "typeCoverage": {
     "atLeast": 90.66
   },
-  "gitHead": "d756c838c7eb3e3cec4a8bdf5c24b97f942b754e"
+  "gitHead": "9b2a827cdf1c3203c1a73637ed80dcd5b13edb8a"
 }

package/src/types.js

@@ -1,2 +1,344 @@
-// Empty JS file to correspond with types.d.ts
-export {};
+/* eslint-disable @typescript-eslint/no-unused-vars -- fails to notice the @see uses */
+                                                     
+                                                                                                           
+                                                                                         
+                                                         
+                                             
+                                         
+                                                    
+                                                         
+
+                               
+                                                             
+           
+
+/**
+ * read-only access to a node in a name hierarchy
+ *
+ * NOTE: We need to return arrays, not iterables, because even if marshal could
+ * allow passing a remote iterable, there would be an inordinate number of round
+ * trips for the contents of even the simplest nameHub.
+ */
+                                    
+                                
+     
+                                                                          
+                       
+     
+                                              
+                                                             
+                                                            
+                                                       
+                       
+                                                        
+                        
+  
+
+/** write access to a node in a name hierarchy */
+                         
+                                                                          
+     
+                                                                             
+                                                                             
+                  
+     
+                                          
+     
+                                                                             
+              
+     
+                                                                    
+                                                           
+                                                                  
+     
+                                                                             
+                                                                             
+                 
+     
+                                                                     
+     
+                                                                           
+                                              
+     
+                                                         
+                                                                            
+                                
+                                                               
+                          
+     
+                                                                                                               
+    
+                                      
+     
+                                                           
+  
+
+                                    
+                                                                                      
+                                            
+  
+
+/** a node in a name hierarchy */
+                          
+                    
+                   
+                     
+                       
+  
+
+                                              
+                         
+  
+                                               
+               
+                 
+                        
+              
+                     
+                                  
+     
+                                                         
+  
+
+/** An object that can receive messages from the bridge device */
+                             
+                                  
+                                                       
+  
+
+                                                              
+     
+                                                                         
+                                                                              
+                                
+     
+                        
+                                         
+                                       
+                                       
+                                             
+                                                        
+                                                       
+  
+
+/** An object which handles messages for a specific bridge */
+                                                              
+                               
+  
+
+/** The object to manage this bridge */
+                             
+                                 
+                
+                                    
+                              
+  
+
+                               
+                                               
+                                                     
+                                                         
+
+                                  
+              
+                               
+                         
+                                    
+                              
+                                       
+                                                   
+                                                         
+   
+
+/**
+ * The network host is the tuple type that identifies the system providing a
+ * NetworkBinding. We currently only support chain-based Caip10 hosts, but
+ * others may be added later.
+ */
+                                                             
+
+/**
+ * A network binding is the protocol-specific minimal information needed to
+ * identify a specific source or destination, knowing the NetworkHost for which
+ * it has been bound.
+ */
+                                 
+                                                        
+ 
+
+/**
+ * A network endpoint is a tuple that identifies a specific network location,
+ * including the protocol, host, and any protocol-specific binding information.
+ */
+                                                                   
+        
+                        
+                                  
+  
+
+                               
+                     
+                           
+  
+
+                              
+                            
+                                    
+                    
+                          
+                                
+                              
+                  
+                          
+  
+
+/** see [ibc_module.go](../../../golang/cosmos/x/vibc/types/ibc_module.go) */
+                            
+                          
+                     
+                    
+                    
+                        
+                      
+                         
+                   
+                           
+                   
+                 
+
+                        
+                                  
+                                 
+                                 
+                                     
+                  
+                      
+    
+                          
+                           
+                      
+                                     
+    
+                         
+                           
+                      
+                                     
+    
+                  
+                      
+    
+                                                                   
+                                                                      
+                                                               
+  
+
+/**
+ * ActionTypes as specified by `vibc` and `vtransfer`. This list is expected to
+ * grow as more IBC Applications modules are implemented.
+ */
+                                                        
+
+                     
+                           
+                                       
+     
+          
+                                                           
+                       
+                                                         
+                     
+           
+                                                        
+                                                 
+     
+                                                         
+  
+
+/** see [receiver.go](../../../golang/cosmos/x/vibc/types/receiver.go) */
+                               
+                
+                     
+                     
+                          
+                           
+              
+                     
+                       
+
+                        
+                                 
+                                          
+                    
+                      
+               
+    
+                                                
+                          
+                                                              
+    
+                                                   
+                    
+                      
+    
+                                           
+  
+
+                         
+                                  
+  
+
+                                                      
+                     
+            
+     
+                                                         
+  
+
+                                                        
+                                                         
+  
+
+                                                            
+                                                                
+
+                                                            
+                                                             
+
+                                
+                          
+                            
+                  
+  
+
+                                                          
+                                                              
+  
+
+                                                         
+               
+              
+                        
+                   
+                           
+                      
+    
+  
+
+                           
+                    
+                            
+  
+
+/**
+ * This event is emitted when a FungibleTokenPacket is sent or received
+ * by a target (e.g. a {@link LocalChainAccount}) that has a registered
+ * {@link TargetApp}. It is passed through the `receiveUpcall` handler.
+ *
+ * For ICS-20 transfer (including `MsgTransfer`), the `packet.data` field is a
+ * {@link FungibleTokenPacketData} object, and you can use
+ * `JSON.parse(atob(packet.data))` to extract it.
+ */
+                               
+                                                            
+                                                           
+                                                     

package/src/types.ts

@@ -1,344 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars -- fails to notice the @see uses */
-import type { JsonSafe } from '@agoric/cosmic-proto';
-import type { FungibleTokenPacketData } from '@agoric/cosmic-proto/ibc/applications/transfer/v2/packet.js';
-import type { PacketSDKType } from '@agoric/cosmic-proto/ibc/core/channel/v1/channel.js';
-import type { BridgeId, Remote } from '@agoric/internal';
-import type { Bytes } from '@agoric/network';
-import type { Guarded } from '@endo/exo';
-import type { TargetApp } from './bridge-target.js';
-import type { LocalChainAccount } from './localchain.js';
-
-export type Board = ReturnType<
-  ReturnType<typeof import('./lib-board.js').prepareBoardKit>
->['board'];
-
-/**
- * read-only access to a node in a name hierarchy
- *
- * NOTE: We need to return arrays, not iterables, because even if marshal could
- * allow passing a remote iterable, there would be an inordinate number of round
- * trips for the contents of even the simplest nameHub.
- */
-export type NameHub<Value = any> = {
-  has: (key: string) => boolean;
-  /**
-   * Look up a path of keys starting from the current NameHub. Wait on any
-   * reserved promises.
-   */
-  lookup: (...path: string[]) => Promise<any>;
-  /** get all the entries available in the current NameHub */
-  entries: (includeReserved?: boolean) => [string, Value][];
-  /** get all names available in the current NameHub */
-  keys: () => string[];
-  /** get all values available in the current NameHub */
-  values: () => Value[];
-};
-
-/** write access to a node in a name hierarchy */
-export type NameAdmin = {
-  provideChild: (key: string, reserved?: string[]) => Promise<NameHubKit>;
-  /**
-   * Mark a key as reserved; will return a promise that is fulfilled when the
-   * key is updated (or rejected when deleted). If the key was already set it
-   * does nothing.
-   */
-  reserve: (key: string) => Promise<void>;
-  /**
-   * Update if not already updated. Return existing value, or newValue if not
-   * existing.
-   */
-  default: <T>(key: string, newValue: T, newAdmin?: NameAdmin) => T;
-  /** Update only if already initialized. Reject if not. */
-  set: (key: string, newValue: any, newAdmin?: NameAdmin) => void;
-  /**
-   * Fulfill an outstanding reserved promise (if any) to the newValue and set
-   * the key to the newValue. If newAdmin is provided, set that to return via
-   * lookupAdmin.
-   */
-  update: (key: string, newValue: any, newAdmin?: NameAdmin) => void;
-  /**
-   * Look up the `newAdmin` from the path of keys starting from the current
-   * NameAdmin. Wait on any reserved promises.
-   */
-  lookupAdmin: (...path: string[]) => Promise<NameAdmin>;
-  /** Delete a value and reject an outstanding reserved promise (if any). */
-  delete: (key: string) => void;
-  /** get the NameHub corresponding to the current NameAdmin */
-  readonly: () => NameHub;
-  /**
-   * Set a function to be called whenever an update or deletion is made, with all the entries as of that point.
-   *
-   * Note: can be called at most once.
-   */
-  onUpdate: (fn: undefined | NameHubUpdateHandler) => void;
-};
-
-export type NameHubUpdateHandler = {
-  /** Called when an update or deletion is made, with all entries as of that point. */
-  write: (entries: [string, any][]) => void;
-};
-
-/** a node in a name hierarchy */
-export type NameHubKit = {
-  /** read access */
-  nameHub: NameHub;
-  /** write access */
-  nameAdmin: NameAdmin;
-};
-
-export type MyAddressNameAdmin = NameAdmin & {
-  getMyAddress(): string;
-};
-export type NamesByAddressAdmin = NameAdmin & {
-  provideChild(
-    addr: string,
-    reserved?: string[],
-  ): Promise<{
-    nameHub: NameHub;
-    nameAdmin: MyAddressNameAdmin;
-  }>;
-  lookupAdmin(addr: string): Promise<MyAddressNameAdmin>;
-};
-
-/** An object that can receive messages from the bridge device */
-export type BridgeHandler = {
-  /** Handle an inbound message */
-  fromBridge: (obj: any) => Promise<unknown> | unknown;
-};
-
-export type ScopedBridgeManagerMethods<B extends BridgeId> = {
-  /**
-   * Optional bridge ID getter. Not part of the production bridge vat but
-   * available in fake bridges as a means for test reflection and for the type
-   * system to hang the bridgeId
-   */
-  getBridgeId?: () => B;
-  /** Downcall from the VM into Golang */
-  toBridge: (obj: any) => Promise<any>;
-  /** Upcall from Golang into the VM */
-  fromBridge: (obj: any) => Promise<unknown>;
-  initHandler: (handler: Remote<BridgeHandler>) => void;
-  setHandler: (handler: Remote<BridgeHandler>) => void;
-};
-
-/** An object which handles messages for a specific bridge */
-export type ScopedBridgeManager<B extends BridgeId> = Guarded<
-  ScopedBridgeManagerMethods<B>
->;
-
-/** The object to manage this bridge */
-export type BridgeManager = {
-  register: <B extends BridgeId>(
-    bridgeId: B,
-    handler?: Remote<BridgeHandler>,
-  ) => ScopedBridgeManager<B>;
-};
-
-export type IBCPortID = string;
-export type IBCChannelID = `channel-${number}`;
-export type IBCConnectionID = `connection-${number}`;
-export type IBCChannelOrdering = 'ORDERED' | 'UNORDERED';
-
-export type IBCPacket = JsonSafe<{
-  data: Bytes;
-  source_channel: IBCChannelID;
-  source_port: IBCPortID;
-  destination_channel: IBCChannelID;
-  destination_port: IBCPortID;
-  sequence?: PacketSDKType['sequence'];
-  timeout_height?: PacketSDKType['timeout_height'];
-  timeout_timestamp?: PacketSDKType['timeout_timestamp'];
-}>;
-
-/**
- * The network host is the tuple type that identifies the system providing a
- * NetworkBinding. We currently only support chain-based Caip10 hosts, but
- * others may be added later.
- */
-export type NetworkHost = [['chain', `${string}:${string}`]];
-
-/**
- * A network binding is the protocol-specific minimal information needed to
- * identify a specific source or destination, knowing the NetworkHost for which
- * it has been bound.
- */
-export interface NetworkBinding {
-  ibc: [['port', IBCPortID], ['channel', IBCChannelID]];
-}
-
-/**
- * A network endpoint is a tuple that identifies a specific network location,
- * including the protocol, host, and any protocol-specific binding information.
- */
-export type NetworkEndpoint<Proto extends keyof NetworkBinding> = [
-  Proto,
-  ...(NetworkHost | []),
-  ...(NetworkBinding[Proto] | []),
-];
-
-export type IBCCounterParty = {
-  port_id: IBCPortID;
-  channel_id: IBCChannelID;
-};
-
-export type ConnectingInfo = {
-  order: IBCChannelOrdering;
-  connectionHops: IBCConnectionID[];
-  portID: IBCPortID;
-  channelID: IBCChannelID;
-  counterparty: IBCCounterParty;
-  counterpartyVersion: string;
-  version: string;
-  asyncVersions?: boolean;
-};
-
-/** see [ibc_module.go](../../../golang/cosmos/x/vibc/types/ibc_module.go) */
-export type IBCBridgeEvent =
-  | 'writeAcknowledgement'
-  | 'channelOpenInit'
-  | 'channelOpenTry'
-  | 'channelOpenAck'
-  | 'channelOpenConfirm'
-  | 'channelCloseInit'
-  | 'channelCloseConfirm'
-  | 'receivePacket'
-  | 'acknowledgementPacket'
-  | 'timeoutPacket'
-  | 'sendPacket';
-
-type IBCPacketEvents = {
-  channelOpenInit: ConnectingInfo;
-  channelOpenTry: ConnectingInfo;
-  channelOpenAck: ConnectingInfo;
-  channelOpenConfirm: ConnectingInfo;
-  receivePacket: {
-    packet: IBCPacket;
-  };
-  acknowledgementPacket: {
-    acknowledgement: Bytes;
-    packet: IBCPacket;
-    relayer: string; // chain address
-  };
-  writeAcknowledgement: {
-    acknowledgement: Bytes;
-    packet: IBCPacket;
-    relayer: string; // chain address
-  };
-  timeoutPacket: {
-    packet: IBCPacket;
-  };
-  channelCloseInit: { channelID: IBCChannelID; portID: IBCPortID };
-  channelCloseConfirm: { channelID: IBCChannelID; portID: IBCPortID };
-  sendPacket: { relativeTimeoutNs: bigint; packet: IBCPacket };
-};
-
-/**
- * ActionTypes as specified by `vibc` and `vtransfer`. This list is expected to
- * grow as more IBC Applications modules are implemented.
- */
-type IBCEventType = 'IBC_EVENT' | 'VTRANSFER_IBC_EVENT';
-
-export type IBCEvent<
-  E extends IBCBridgeEvent,
-  T extends IBCEventType = 'IBC_EVENT',
-> = {
-  type: T;
-  /** blockHeight may be missing from synthetic packets. */
-  blockHeight?: number;
-  /** blockTime may be missing from synthetic packets. */
-  blockTime?: number;
-  event: E;
-  /** e.g. the chain address of the LocalChainAccount */
-  target?: string | { onlyIfRegistered: string };
-} & {
-  [K in keyof IBCPacketEvents[E]]: IBCPacketEvents[E][K];
-};
-
-/** see [receiver.go](../../../golang/cosmos/x/vibc/types/receiver.go) */
-export type IBCDowncallMethod =
-  | 'sendPacket'
-  | 'tryOpenExecuted'
-  | 'receiveExecuted'
-  | 'startChannelOpenInit'
-  | 'startChannelCloseInit'
-  | 'bindPort'
-  | 'timeoutExecuted'
-  | 'initOpenExecuted';
-
-type IBCMethodEvents = {
-  sendPacket: SendPacketDownCall;
-  tryOpenExecuted: ChannelOpenAckDowncall;
-  receiveExecuted: {
-    packet: IBCPacket;
-    ack: Bytes;
-  };
-  startChannelOpenInit: ChannelOpenInitDowncall;
-  startChannelCloseInit: {
-    packet: Pick<IBCPacket, 'source_port' | 'source_channel'>;
-  };
-  bindPort: { packet: { source_port: IBCPortID } };
-  timeoutExecuted: {
-    packet: IBCPacket;
-  };
-  initOpenExecuted: ChannelOpenAckDowncall;
-};
-
-type IBCMethodReturns = {
-  sendPacket: Required<IBCPacket>;
-};
-
-export type IBCMethod<M extends IBCDowncallMethod> = {
-  type: 'IBC_METHOD';
-  method: M;
-} & {
-  [K in keyof IBCMethodEvents[M]]: IBCMethodEvents[M][K];
-};
-
-export type IBCDowncall<M extends IBCDowncallMethod> = {
-  [K in keyof IBCMethodEvents[M]]: IBCMethodEvents[M][K];
-};
-
-export type IBCDowncallReturn<M extends IBCDowncallMethod> =
-  M extends keyof IBCMethodReturns ? IBCMethodReturns[M] : void;
-
-export type IBCDowncallPacket<M extends IBCDowncallMethod> =
-  IBCMethodEvents[M] extends { packet: infer P } ? P : never;
-
-type ChannelOpenDowncallBase = {
-  hops: IBCConnectionID[];
-  order: IBCChannelOrdering;
-  version: string;
-};
-
-type ChannelOpenInitDowncall = ChannelOpenDowncallBase & {
-  packet: Pick<IBCPacket, 'destination_port' | 'source_port'>;
-};
-
-type ChannelOpenAckDowncall = ChannelOpenDowncallBase & {
-  packet: Pick<
-    IBCPacket,
-    | 'destination_port'
-    | 'source_port'
-    | 'destination_channel'
-    | 'source_channel'
-  >;
-};
-
-type SendPacketDownCall = {
-  packet: IBCPacket;
-  relativeTimeoutNs: bigint;
-};
-
-/**
- * This event is emitted when a FungibleTokenPacket is sent or received
- * by a target (e.g. a {@link LocalChainAccount}) that has a registered
- * {@link TargetApp}. It is passed through the `receiveUpcall` handler.
- *
- * For ICS-20 transfer (including `MsgTransfer`), the `packet.data` field is a
- * {@link FungibleTokenPacketData} object, and you can use
- * `JSON.parse(atob(packet.data))` to extract it.
- */
-export type VTransferIBCEvent =
-  | IBCEvent<'acknowledgementPacket', 'VTRANSFER_IBC_EVENT'>
-  | IBCEvent<'writeAcknowledgement', 'VTRANSFER_IBC_EVENT'>
-  | IBCEvent<'timeoutPacket', 'VTRANSFER_IBC_EVENT'>;