@agoric/zoe 0.26.3-dev-d756c83.0.d756c83 → 0.26.3-dev-e9efaa1.0.e9efaa1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/zoe",
-  "version": "0.26.3-dev-d756c83.0.d756c83",
+  "version": "0.26.3-dev-e9efaa1.0.e9efaa1",
   "description": "Zoe: the Smart Contract Framework for Offer Enforcement",
   "type": "module",
   "main": "./src/zoeService/zoe.js",
@@ -10,8 +10,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 --verbose",
     "test:c8": "c8 --all ${C8_OPTIONS:-} ava",
     "test:unit": "ava 'test/unitTests' -T 1m --verbose",
@@ -43,17 +43,17 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/base-zone": "0.1.1-dev-d756c83.0.d756c83",
-    "@agoric/ertp": "0.16.3-dev-d756c83.0.d756c83",
-    "@agoric/internal": "0.3.3-dev-d756c83.0.d756c83",
-    "@agoric/notifier": "0.6.3-dev-d756c83.0.d756c83",
-    "@agoric/store": "0.9.3-dev-d756c83.0.d756c83",
-    "@agoric/swingset-liveslots": "0.10.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/zone": "0.2.3-dev-d756c83.0.d756c83",
+    "@agoric/base-zone": "0.1.1-dev-e9efaa1.0.e9efaa1",
+    "@agoric/ertp": "0.16.3-dev-e9efaa1.0.e9efaa1",
+    "@agoric/internal": "0.3.3-dev-e9efaa1.0.e9efaa1",
+    "@agoric/notifier": "0.6.3-dev-e9efaa1.0.e9efaa1",
+    "@agoric/store": "0.9.3-dev-e9efaa1.0.e9efaa1",
+    "@agoric/swingset-liveslots": "0.10.3-dev-e9efaa1.0.e9efaa1",
+    "@agoric/swingset-vat": "0.32.3-dev-e9efaa1.0.e9efaa1",
+    "@agoric/time": "0.3.3-dev-e9efaa1.0.e9efaa1",
+    "@agoric/vat-data": "0.5.3-dev-e9efaa1.0.e9efaa1",
+    "@agoric/vow": "0.1.1-dev-e9efaa1.0.e9efaa1",
+    "@agoric/zone": "0.2.3-dev-e9efaa1.0.e9efaa1",
     "@endo/bundle-source": "^4.1.2",
     "@endo/captp": "^4.4.8",
     "@endo/common": "^1.2.13",
@@ -70,7 +70,7 @@
     "yargs-parser": "^21.1.1"
   },
   "devDependencies": {
-    "@agoric/kmarshal": "0.1.1-dev-d756c83.0.d756c83",
+    "@agoric/kmarshal": "0.1.1-dev-e9efaa1.0.e9efaa1",
     "@endo/init": "^1.1.12",
     "ava": "^5.3.0",
     "c8": "^10.1.3",
@@ -100,5 +100,5 @@
   "typeCoverage": {
     "atLeast": 84.77
   },
-  "gitHead": "d756c838c7eb3e3cec4a8bdf5c24b97f942b754e"
+  "gitHead": "e9efaa12254f2c9a6faffc40ade2f1d9a70b87ae"
 }

package/src/contractFacet/types.js

@@ -0,0 +1,251 @@
+             
+                        
+         
+            
+            
+        
+              
+         
+          
+                      
+                                                   
+                                      
+                                                 
+                                                   
+             
+                      
+           
+                
+           
+                    
+          
+                 
+                
+           
+             
+                           
+                                                                    
+
+/**
+ * Any passable non-thenable. Often an explanatory string.
+ */
+                                  
+                                                                              
+
+                                                                
+
+                            
+                                  
+                      
+     
+                  
+                       
+               
+                               
+  
+                                                    
+
+/**
+ * Zoe Contract Facet
+ *
+ * The Zoe interface specific to a contract instance. The Zoe Contract
+ * Facet is an API object used by running contract instances to access
+ * the Zoe state for that instance. The Zoe Contract Facet is accessed
+ * synchronously from within the contract, and usually is referred to
+ * in code as zcf.
+ */
+                                                 
+     
+                                                 
+     
+                                                       
+     
+            
+                                                                
+                 
+     
+                                                  
+     
+                                                                        
+                                        
+    
+                                                                     
+           
+     
+                                 
+                     
+                     
+               
+                                                                      
+    
+
+     
+                                                                   
+                                                                      
+                                                                      
+                                                                     
+                                                                        
+                                                                  
+                                                            
+                                             
+     
+                                     
+                                           
+                        
+                           
+                            
+                                 
+                                             
+                                                                          
+                                        
+                                           
+                                     
+                                                                          
+                                                                               
+                                            
+                                               
+                     
+                                
+                                        
+                                                         
+                             
+                                      
+                                        
+                         
+                                           
+                                                            
+                                               
+                              
+  
+
+                            
+                     
+                   
+                                    
+                                  
+  
+
+                                  
+                   
+                                      
+                             
+/**
+ * Provide a jig object for testing purposes only.
+ *
+ * The contract code provides a callback whose return result will
+ * be made available to the test that started this contract. The
+ * supplied callback will only be called in a testing context,
+ * never in production; i.e., it is only called if `testJigSetter`
+ * was supplied.
+ *
+ * If no `testFn` is supplied, then an empty jig will be used.
+ * An additional `zcf` property set to the current ContractFacet
+ * will be appended to the returned jig object (overriding any
+ * provided by the `testFn`).
+ */
+                       
+                                                              
+                               
+                                                        
+                                            
+     
+                                                              
+                                                           
+                                             
+                                                                              
+                                        
+    
+                                                      
+                                                                   
+              
+     
+                                                                        
+     
+                                                               
+                                                            
+                                                 
+                                            
+    
+                                                      
+     
+                                                                      
+  
+/**
+ * fail called with the reason for this failure, where reason is
+ * normally an instanceof Error.
+ */
+                                                     
+                                                                    
+                                          
+                    
+                                                       
+                           
+                                    
+     
+                                                                      
+                                     
+     
+                                             
+                     
+              
+                                                     
+                                         
+                                                      
+  
+                          
+                   
+                              
+  
+                                                                       
+                                                    
+                       
+     
+                                  
+      
+                         
+                                                      
+                                                  
+     
+                            
+                                                               
+           
+    
+                                                                 
+     
+                                                        
+                                                          
+                                                                                                          
+     
+                                                                      
+  
+/**
+ * API for a contract start function.
+ *
+ * CAVEAT: assumes synchronous
+ */
+                                                                       
+               
+                  
+                                              
+                                   
+                                             
+                   
+                    
+                                                                
+  
+
+/**
+ * @deprecated use the parameterized version
+ */
+                                                                          
+
+                                         
+                                       
+                                                             
+        
+                   
+     
+                                                                  
+                    
+                  
+  

package/src/types.js

@@ -0,0 +1,37 @@
+                                                  
+                                                        
+
+/**
+ * Alias for RemotableObject
+ */
+                                                          
+
+// Typing this as Capitalize<string> would be more accurate but requires
+// frequent casting. Revisit once .ts syntax is more common. Even then,
+// may not be worth the effort since Zoe 2 probably will not have keywords.
+/** Must start with a capital letter. */
+                             
+
+/**
+ * - an opaque handle for an invitation
+ */
+                                                    
+                                                               
+                                          
+          
+                                       
+  
+                                                             
+                             
+     
+                  
+                                 
+     
+                               
+     
+                           
+                       
+     
+                             
+  
+                                                           

package/src/zoeService/types.js

@@ -0,0 +1,307 @@
+             
+            
+            
+              
+         
+           
+          
+                      
+                                                   
+                                                         
+                                                             
+                                                                     
+             
+          
+                   
+                     
+         
+                      
+                     
+                                                    
+
+/**
+ * @see {@link https://github.com/sindresorhus/type-fest/blob/main/source/is-any.d.ts}
+ */
+                                                        
+
+/**
+ * Zoe provides a framework for deploying and working with smart
+ * contracts. It is accessed as a long-lived and well-trusted service
+ * that enforces offer safety for the contracts that use it. Zoe has a
+ * single `invitationIssuer` for the entirety of its lifetime. By
+ * having a reference to Zoe, a user can get the `invitationIssuer`
+ * and thus validate any `invitation` they receive from someone else.
+ *
+ * Zoe has two different facets: the public Zoe service and the
+ * contract facet (ZCF). Each contract instance has a copy of ZCF
+ * within its vat. The contract and ZCF never have direct access to
+ * the users' payments or the Zoe purses.
+ */
+                          
+     
+                                                                
+                                                               
+                                                                       
+                                                                     
+                                                                        
+                                         
+     
+                                           
+                         
+                                   
+                                                    
+               
+                                       
+                      
+               
+                         
+           
+                                                
+                                                  
+           
+                                
+                   
+                                      
+               
+    
+                         
+                       
+                                       
+                
+                            
+                  
+                     
+                                                                               
+         
+                              
+                          
+                                           
+              
+                                                                  
+                                                         
+                           
+                                   
+     
+                                                                                
+                                                                  
+     
+                                             
+                             
+                                     
+                                                           
+     
+                                                                              
+                                                                   
+     
+                                  
+                                       
+                                                    
+  
+                                                                           
+                                                 
+                               
+                                   
+  
+                          
+                                               
+                                  
+                         
+                                               
+                                 
+                                   
+                                               
+                           
+                           
+                                                           
+                                                 
+                               
+                                                           
+                           
+                                    
+                                                                     
+                                
+/**
+ * Create an installation by safely evaluating the code and
+ * registering it with Zoe. Returns an installation.
+ */
+                             
+                                
+                                   
+                           
+/**
+ * Create an installation from a Bundle ID. Returns an installation.
+ */
+                               
+                     
+                                   
+                           
+/**
+ * Verify that an alleged Installation is real, and return the Bundle ID it
+ * will use for contract code.
+ */
+                                           
+                                          
+                     
+/**
+ * To redeem an invitation, the user normally provides a proposal (their
+ * rules for the offer) as well as payments to be escrowed by Zoe.  If
+ * either the proposal or payments would be empty, indicate this by
+ * omitting that argument or passing undefined, rather than passing an
+ * empty record.
+ *
+ * The proposal has three parts: `want` and `give` are used by Zoe to
+ * enforce offer safety, and `exit` is used to specify the particular
+ * payout-liveness policy that Zoe can guarantee. `want` and `give`
+ * are objects with keywords as keys and amounts as values.
+ * `paymentKeywordRecord` is a record with keywords as keys, and the
+ * values are the actual payments to be escrowed. A payment is
+ * expected for every rule under `give`.
+ */
+                                               
+                                                                         
+                      
+                                               
+                   
+                               
+/**
+ * Zoe uses seats to access or manipulate offers. They let contracts and users
+ * interact with them. Zoe has two kinds of seats. ZCFSeats are used within
+ * contracts and with zcf methods. UserSeats represent offers external to Zoe
+ * and the contract. The party who exercises an invitation and sends the offer()
+ * message to Zoe gets a UserSeat that can check payouts' status or retrieve the
+ * result of processing the offer in the contract. This varies, but examples are
+ * a string and an invitation for another seat.
+ *
+ * Also, a UserSeat can be handed to an agent outside Zoe and the contract,
+ * letting them query or monitor the current state, access the payouts and
+ * result, and, if it's allowed for this seat, call tryExit().
+ *
+ * Since anyone can attempt to exit the seat if they have a reference to it, you
+ * should only share a UserSeat with trusted parties.
+ *
+ * UserSeat includes queries for the associated offer's current state and an
+ * operation to request that the offer exit, as follows:
+ */
+                                      
+                                             
+     
+                                                                                 
+                                                                   
+     
+                                                   
+     
+                                                                              
+                                                                               
+                                                                              
+                
+     
+                                                              
+                                    
+     
+                                                                                     
+                                                                             
+                                                                                
+                                                                                 
+                                                                               
+                                
+     
+                                     
+     
+                                                                      
+     
+                                    
+     
+                                
+                                                                            
+                                                                                 
+                                                                             
+                               
+     
+                                          
+     
+                                                                                  
+                     
+     
+                                                
+     
+                              
+                                                         
+     
+                                                                              
+  
+                                               
+                              
+                            
+                            
+                 
+  
+/**
+ * The keys are keywords, and the values are amounts. For example:
+ * { Asset: AmountMath.make(assetBrand, 5n), Price:
+ * AmountMath.make(priceBrand, 9n) }
+ */
+                                                             
+                     
+                   
+  
+                                
+                 
+  
+                              
+               
+  
+                                     
+                  
+                                               
+                                               
+    
+  
+/**
+ * The possible keys are 'waived', 'onDemand', and 'afterDeadline'.
+ * `timer` and `deadline` only are used for the `afterDeadline` key.
+ * The possible records are:
+ * `{ waived: null }`
+ * `{ onDemand: null }`
+ * `{ afterDeadline: { timer :Timer<Deadline>, deadline :Deadline } }`
+ */
+                      
+                    
+                  
+                          
+                                                                   
+                     
+     
+                                                          
+     
+     
+                   
+     
+     
+                      
+                 
+      
+/**
+ * Opaque type for a JSONable source bundle
+ */
+                                               
+                                                                        
+                                                                 
+                                 
+                             
+                                               
+                           
+                      
+                                                  
+  
+                                                                           
+                                                       
+                                            
+                               
+               
+                       
+                           
+  
+                             
+                              
+  
+                                                    

package/src/zoeService/{utils.test-d.ts → utils.test-d.js}

@@ -1,15 +1,15 @@
 import { E } from '@endo/far';
-import type { StartedInstanceKit } from './utils.js';
-import type { ZCF } from '../types-index.js';
+;                                                    
+;                                            
 
 const someContractStartFn = (
-  zcf: ZCF,
-  privateArgs: { someNumber: number; someString: string },
+  zcf     ,
+  privateArgs                                            ,
 ) => ({});
 
-type PsmInstanceKit = StartedInstanceKit<typeof someContractStartFn>;
+;                                                                    
 
-const psmInstanceKit: PsmInstanceKit = null as any;
+const psmInstanceKit                 = null       ;
 
 // @ts-expect-error missing privateArgs argument
 void E(psmInstanceKit.adminFacet).restartContract();