@agoric/vats 0.15.2-dev-247cc9b.0 → 0.15.2-dev-db4d0ea.0

package/src/core/startWalletFactory.d.ts

@@ -1,403 +1,4 @@
-export function startWalletFactory({ vatParameters: { chainStorageEntries }, consume: { agoricNames, bankManager, board, walletBridgeManager: walletBridgeManagerP, provisionWalletBridgeManager: provisionWalletBridgeManagerP, chainStorage, namesByAddressAdmin: namesByAddressAdminP, econCharterKit, startUpgradable, startGovernedUpgradable, }, produce: { client, walletFactoryStartResult, provisionPoolStartResult }, installation: { consume: { walletFactory, provisionPool }, }, instance: { produce: instanceProduce }, brand: { consume: { [Stable.symbol]: feeBrandP }, }, issuer: { consume: { [Stable.symbol]: feeIssuerP }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-    vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-}, {}, {
-    loadVat: VatLoader<unknown>;
-    loadCriticalVat: VatLoader<unknown>;
-}> & {
-    zone: import("@agoric/base-zone").Zone;
-    devices: SoloDevices | ChainDevices;
-    vats: SwingsetVats;
-    vatPowers: {
-        [prop: string]: any;
-        D: DProxy<any>;
-    };
-    vatParameters: BootstrapVatParams;
-    runBehaviors: (manifest: unknown) => Promise<unknown>;
-    modules: {
-        behaviors: {
-            bridgeCoreEval: (allPowers: BootstrapPowers) => Promise<void>;
-            makeProvisioner: ({ consume: { clientCreator, loadCriticalVat }, vats: { comms, vattp }, produce: { provisioning }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & {
-                consume: {
-                    loadCriticalVat: ERef<VatLoader<ProvisioningVat>>;
-                };
-            }) => Promise<void>;
-            noProvisioner: ({ produce: { provisioning } }: BootstrapPowers) => Promise<void>;
-            bridgeProvisioner: ({ consume: { provisioning: provisioningP, provisionBridgeManager: provisionBridgeManagerP, provisionWalletBridgeManager: provisionWalletBridgeManagerP, }, }: BootstrapPowers) => Promise<void>;
-            setupClientManager: ({ produce: { client, clientCreator: clientCreatorP } }: BootstrapSpace, { template, }?: {
-                template?: Record<string, unknown> | undefined;
-            }) => Promise<void>;
-            startTimerService: ({ devices: { timer: timerDevice }, vats: { timer: timerVat }, consume: { client }, produce: { chainTimerService: produceTimer }, brand: { produce: { timer }, }, }: BootstrapPowers) => Promise<void>;
-            makeBridgeManager: ({ consume: { loadCriticalVat }, devices: { bridge }, produce: { bridgeManager: bridgeManagerP, provisionBridgeManager, provisionWalletBridgeManager, walletBridgeManager, }, }: BootDevices<ChainDevices> & WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & {
-                consume: {
-                    loadCriticalVat: ERef<VatLoader<ChainStorageVat>>;
-                };
-            }) => Promise<void>;
-            makeChainStorage: ({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP }, produce: { chainStorage: chainStorageP, storageBridgeManager: storageBridgeManagerP, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & {
-                consume: {
-                    loadCriticalVat: ERef<VatLoader<ChainStorageVat>>;
-                };
-            }) => Promise<void>;
-            produceHighPrioritySendersManager: ({ consume: { loadCriticalVat, storageBridgeManager: storageBridgeManagerP }, produce: { highPrioritySendersManager: managerP }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & {
-                consume: {
-                    loadCriticalVat: ERef<VatLoader<ChainStorageVat>>;
-                };
-            }) => Promise<void>;
-            publishAgoricNamesToChainStorage: ({ consume: { chainStorage: rootP }, namedVat: { consume: { agoricNames, board: vatBoard }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & NamedVatPowers) => Promise<void>;
-            publishAgoricNames: ({ consume: { agoricNamesAdmin, board, chainStorage: rootP } }: BootstrapPowers, { options: { agoricNamesOptions } }?: {
-                options?: {
-                    agoricNamesOptions?: {
-                        topLevel?: string[] | undefined;
-                    } | undefined;
-                } | undefined;
-            }) => Promise<void>;
-            connectChainFaucet: ({ consume: { client } }: BootstrapPowers) => Promise<void>;
-            makeVatsFromBundles: ({ vats, devices, consume: { vatStore }, produce: { vatAdminSvc, loadVat, loadCriticalVat }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any) => Promise<void>;
-            produceDiagnostics: ({ produce }: Pick<ChainBootstrapSpace, "produce">) => Promise<void>;
-            produceStartUpgradable: ({ zone, consume: { diagnostics, zoe }, produce, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & {
-                zone: import("@agoric/base-zone").Zone;
-            }) => Promise<void>;
-            produceStartGovernedUpgradable: ({ zone, consume: { chainTimerService, diagnostics, economicCommitteeCreatorFacet, zoe, }, produce, installation: { consume: { contractGovernor }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & {
-                zone: import("@agoric/base-zone").Zone;
-                consume: {
-                    economicCommitteeCreatorFacet: Promise<import("@agoric/governance/src/committee.js").CommitteeElectorateCreatorFacet>;
-                };
-            }) => Promise<void>;
-            buildZoe: ({ consume: { vatAdminSvc, loadCriticalVat, client }, produce: { zoe, feeMintAccess }, brand: { produce: { Invitation: invitationBrand }, }, issuer: { produce: { Invitation: invitationIssuer }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & {
-                consume: {
-                    loadCriticalVat: ERef<VatLoader<import("./basic-behaviors.js").ZoeVat>>;
-                };
-            }) => Promise<void>;
-            startPriceAuthorityRegistry: ({ consume: { loadCriticalVat, client }, produce, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & {
-                consume: {
-                    loadCriticalVat: ERef<VatLoader<import("./basic-behaviors.js").PriceAuthorityVat>>;
-                };
-            }) => Promise<void>;
-            makeOracleBrands: ({ namedVat: { consume: { agoricNames }, }, oracleBrand: { produce: { USD }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & NamedVatPowers) => Promise<void>;
-            produceBoard: ({ consume: { client }, produce: { board: pBoard }, namedVat: { consume: { board: vatBoard }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & NamedVatPowers) => Promise<void>;
-            makeBoard: ({ consume: { loadCriticalVat, client }, produce: { board: { resolve: resolveBoard }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & {
-                consume: {
-                    loadCriticalVat: ERef<VatLoader<BoardVat>>;
-                };
-            }) => Promise<void>;
-            produceNamesByAddress: ({ consume: { agoricNames, provisioning: provisioningOptP, client }, produce: { namesByAddress, namesByAddressAdmin }, }: BootstrapPowers) => Promise<void>;
-            makeAddressNameHubs: ({ consume: { agoricNames: agoricNamesP, client }, produce, }: BootstrapSpace) => Promise<void>;
-            makeClientBanks: ({ consume: { namesByAddressAdmin, client, bankManager, walletFactoryStartResult, }, }: BootstrapSpace) => Promise<void>;
-            installBootContracts: ({ consume: { vatAdminSvc, zoe }, installation: { produce: { centralSupply, mintHolder }, }, }: BootstrapSpace) => Promise<void>;
-            mintInitialSupply: ({ vatParameters: { argv: { bootMsg }, }, consume: { feeMintAccess: feeMintAccessP, zoe }, produce: { initialSupply }, installation: { consume: { centralSupply }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & {
-                vatParameters: {
-                    argv: {
-                        bootMsg?: {
-                            type: string;
-                            chainID: string;
-                            storagePort: number;
-                            supplyCoins: {
-                                denom: string;
-                                amount: string;
-                            }[];
-                            swingsetPort: number;
-                            vbankPort: number;
-                            vibcPort: number;
-                        } | undefined;
-                    };
-                };
-            }) => Promise<void>;
-            addBankAssets: ({ consume: { agoricNamesAdmin, initialSupply, bridgeManager: bridgeManagerP, loadCriticalVat, startUpgradable, zoe, }, produce: { bankManager, bldIssuerKit }, installation: { consume: { mintHolder }, }, issuer: { produce: produceIssuer }, brand: { produce: produceBrand }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & {
-                consume: {
-                    loadCriticalVat: ERef<VatLoader<BankVat>>;
-                };
-            }) => Promise<void>;
-        };
-        utils: {
-            agoricNamesReserved: {
-                issuer: {
-                    IST: string;
-                    BLD: string;
-                    Invitation: string;
-                    AUSD: string;
-                };
-                installation: {
-                    reserve: string;
-                    centralSupply: string;
-                    mintHolder: string;
-                    walletFactory: string;
-                    provisionPool: string;
-                    auctioneer: string;
-                    feeDistributor: string;
-                    contractGovernor: string;
-                    committee: string;
-                    noActionElectorate: string;
-                    binaryVoteCounter: string;
-                    VaultFactory: string;
-                    liquidate: string;
-                    Pegasus: string;
-                    psm: string;
-                    scaledPriceAuthority: string;
-                    stakeBld: string;
-                    econCommitteeCharter: string;
-                    priceAggregator: string;
-                };
-                instance: {
-                    reserve: string;
-                    walletFactory: string;
-                    provisionPool: string;
-                    auctioneer: string;
-                    feeDistributor: string;
-                    VaultFactory: string;
-                    Pegasus: string;
-                    stakeBld: string;
-                    econCommitteeCharter: string;
-                    economicCommittee: string;
-                    VaultFactoryGovernor: string;
-                    reserveGovernor: string;
-                };
-                oracleBrand: {
-                    USD: string;
-                };
-                uiConfig: {
-                    VaultFactory: string;
-                };
-            };
-            feeIssuerConfig: FeeIssuerConfig;
-            addRemote: (addr: string, { vats: { comms, vattp } }: {
-                vats: {
-                    vattp: VattpVat;
-                    comms: CommsVatRoot;
-                };
-            }) => Promise<void>;
-            callProperties: (builders: ((...args: any[]) => Record<string, unknown>)[], ...args: unknown[]) => Record<string, unknown>;
-            extract: (template: string | true | Record<string, any>, specimen: unknown, path?: string[] | undefined) => any;
-            extractPowers: (permit: string | true | Record<string, any>, allPowers: unknown) => any;
-            runModuleBehaviors: ({ allPowers, behaviors, manifest, makeConfig, }: {
-                allPowers: unknown;
-                behaviors: Record<string, unknown>;
-                manifest: Record<string, Record<string, unknown>>;
-                makeConfig: (name: string, permit: Record<string, unknown>) => unknown;
-            }) => Promise<any[]>;
-            makePromiseSpaceForNameHub: (nameAdmin: ERef<import("../types.js").NameAdmin>, log?: {
-                (...data: any[]): void;
-                (message?: any, ...optionalParams: any[]): void;
-            } | undefined) => PromiseSpaceOf<any, {}, {}>;
-            makeWellKnownSpaces: (parentAdmin: ERef<import("../types.js").NameAdmin>, log?: {
-                (...data: any[]): void;
-                (message?: any, ...optionalParams: any[]): void;
-            } | undefined, kinds?: string[] | undefined) => Promise<WellKnownSpaces>;
-            makeAgoricNamesAccess: (log?: {
-                (...data: any[]): void;
-                (message?: any, ...optionalParams: any[]): void;
-            } | undefined, reserved?: Record<string, Record<string, unknown>>) => Promise<{
-                agoricNames: import("../types.js").NameHub;
-                agoricNamesAdmin: import("../types.js").NameAdmin;
-                spaces: WellKnownSpaces;
-            }>;
-            makeMyAddressNameAdminKit: (address: string) => {
-                nameHub: import("../types.js").NameHub;
-                myAddressNameAdmin: import("../types.js").MyAddressNameAdmin;
-            };
-            makeVatSpace: (svc: ERef<import("@endo/exo/src/exo-makers.js").Guarded<{
-                waitForBundleCap(bundleID: any): any;
-                getBundleCap(bundleID: any): any;
-                getNamedBundleCap(name: any): any;
-                getBundleIDByName(name: any): any;
-                createMeter(remaining: any, threshold: any): import("@agoric/swingset-liveslots").KindFacet<{
-                    addRemaining({ state }: {
-                        state: any;
-                    }, delta: any): void;
-                    setThreshold({ state }: {
-                        state: any;
-                    }, newThreshold: any): void;
-                    get: ({ state }: {
-                        state: any;
-                    }) => any;
-                    getNotifier: ({ _self }: {
-                        _self: any;
-                    }) => never;
-                }>;
-                createUnlimitedMeter(_context: any): import("@agoric/swingset-liveslots").KindFacet<{
-                    addRemaining(_context: any, _delta: any): void;
-                    setThreshold(_context: any, _newThreshold: any): void;
-                    get: () => {
-                        remaining: string;
-                        threshold: number;
-                    };
-                    getNotifier: ({ _self }: {
-                        _self: any;
-                    }) => never;
-                }>;
-                createVat(bundleOrBundleCap: any, options?: {}): Promise<{
-                    adminNode: import("@agoric/swingset-liveslots").KindFacet<{
-                        terminateWithFailure({ state }: {
-                            state: any;
-                        }, reason: any): void;
-                        done({ state }: {
-                            state: any;
-                        }): any;
-                        upgrade({ state }: {
-                            state: any;
-                        }, bundlecap: any, options: any): Promise<any>;
-                        changeOptions({ state }: {
-                            state: any;
-                        }, options: any): void;
-                    }>;
-                    root: any;
-                }>;
-                createVatByName(bundleName: any, options?: {}): Promise<{
-                    adminNode: import("@agoric/swingset-liveslots").KindFacet<{
-                        terminateWithFailure({ state }: {
-                            state: any;
-                        }, reason: any): void;
-                        done({ state }: {
-                            state: any;
-                        }): any;
-                        upgrade({ state }: {
-                            state: any;
-                        }, bundlecap: any, options: any): Promise<any>;
-                        changeOptions({ state }: {
-                            state: any;
-                        }, options: any): void;
-                    }>;
-                    root: any;
-                }>;
-            }>>, criticalVatKey: unknown, log?: ((...args: any) => void) | undefined, label?: string | undefined) => {
-                space: {
-                    consume: {
-                        agoricNames: Promise<{
-                            getNameHub: () => import("../types.js").NameHub;
-                            getNameHubKit: () => import("../types.js").NameHubKit;
-                            publishNameHubs: (nameStorage: ERef<StorageNode>, vatBoard: ERef<BoardVat>, kinds: string[]) => Promise<void>;
-                            provideInertBrand: (keyword: string, displayInfo: DisplayInfo<AssetKind>) => any;
-                        } & import("@endo/eventual-send").RemotableBrand<{}, {
-                            getNameHub: () => import("../types.js").NameHub;
-                            getNameHubKit: () => import("../types.js").NameHubKit;
-                            publishNameHubs: (nameStorage: ERef<StorageNode>, vatBoard: ERef<BoardVat>, kinds: string[]) => Promise<void>;
-                            provideInertBrand: (keyword: string, displayInfo: DisplayInfo<AssetKind>) => any;
-                        }>>;
-                        board: Promise<{
-                            getBoard: () => import("@endo/exo/src/exo-makers.js").Guarded<{
-                                getId(value: any): string;
-                                getValue(id: string): any;
-                                lookup(...path: string[]): Promise<any>;
-                                has(val: any): boolean;
-                                ids(): string[];
-                                getPublishingMarshaller(): import("@endo/exo/src/exo-makers.js").Guarded<{
-                                    toCapData(val: any): import("@endo/marshal").CapData<string>;
-                                    fromCapData(data: any): any;
-                                    serialize(data: any): import("@endo/marshal").CapData<string>;
-                                    unserialize(data: any): any;
-                                }>;
-                                getReadonlyMarshaller(): import("@endo/exo/src/exo-makers.js").Guarded<{
-                                    toCapData(val: any): import("@endo/marshal").CapData<string | null>;
-                                    fromCapData(data: any): any;
-                                    serialize(data: any): import("@endo/marshal").CapData<string | null>;
-                                    unserialize(data: any): any;
-                                }>;
-                            }>;
-                            makePublishingRecorderKit: <T>(storageNode: StorageNode | (import("@endo/eventual-send").DataOnly<StorageNode> & import("@endo/eventual-send").RemotableBrand<import("@endo/eventual-send").DataOnly<StorageNode>, StorageNode>), valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
-                            makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | (import("@endo/eventual-send").DataOnly<StorageNode> & import("@endo/eventual-send").RemotableBrand<import("@endo/eventual-send").DataOnly<StorageNode>, StorageNode>), valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
-                        } & import("@endo/eventual-send").RemotableBrand<{}, {
-                            getBoard: () => import("@endo/exo/src/exo-makers.js").Guarded<{
-                                getId(value: any): string;
-                                getValue(id: string): any;
-                                lookup(...path: string[]): Promise<any>;
-                                has(val: any): boolean;
-                                ids(): string[];
-                                getPublishingMarshaller(): import("@endo/exo/src/exo-makers.js").Guarded<{
-                                    toCapData(val: any): import("@endo/marshal").CapData<string>;
-                                    fromCapData(data: any): any;
-                                    serialize(data: any): import("@endo/marshal").CapData<string>;
-                                    unserialize(data: any): any;
-                                }>;
-                                getReadonlyMarshaller(): import("@endo/exo/src/exo-makers.js").Guarded<{
-                                    toCapData(val: any): import("@endo/marshal").CapData<string | null>;
-                                    fromCapData(data: any): any;
-                                    serialize(data: any): import("@endo/marshal").CapData<string | null>;
-                                    unserialize(data: any): any;
-                                }>;
-                            }>;
-                            makePublishingRecorderKit: <T>(storageNode: StorageNode | (import("@endo/eventual-send").DataOnly<StorageNode> & import("@endo/eventual-send").RemotableBrand<import("@endo/eventual-send").DataOnly<StorageNode>, StorageNode>), valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
-                            makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | (import("@endo/eventual-send").DataOnly<StorageNode> & import("@endo/eventual-send").RemotableBrand<import("@endo/eventual-send").DataOnly<StorageNode>, StorageNode>), valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
-                        }>>;
-                    };
-                };
-                durableStore: MapStore<K, V>;
-            };
-        };
-    };
-} & ChainStorageVatParams & PromiseSpaceOf<{
+export function startWalletFactory({ vatParameters: { chainStorageEntries }, consume: { agoricNames, bankManager, board, walletBridgeManager: walletBridgeManagerP, provisionWalletBridgeManager: provisionWalletBridgeManagerP, chainStorage, namesByAddressAdmin: namesByAddressAdminP, econCharterKit, startUpgradable, startGovernedUpgradable, }, produce: { client, walletFactoryStartResult, provisionPoolStartResult }, installation: { consume: { walletFactory, provisionPool }, }, instance: { produce: instanceProduce }, brand: { consume: { [Stable.symbol]: feeBrandP }, }, issuer: { consume: { [Stable.symbol]: feeIssuerP }, }, }: BootstrapPowers & ChainStorageVatParams & PromiseSpaceOf<{
     economicCommitteeCreatorFacet: import('@agoric/governance/src/committee.js').CommitteeElectorateCreatorFacet;
     econCharterKit: {
         creatorFacet: Awaited<ReturnType<typeof import("@agoric/inter-protocol/src/econCommitteeCharter.js")['start']>>['creatorFacet'];
@@ -405,7 +6,7 @@ export function startWalletFactory({ vatParameters: { chainStorageEntries }, con
     };
     walletBridgeManager: import('../types.js').ScopedBridgeManager;
     provisionWalletBridgeManager: import('../types.js').ScopedBridgeManager;
-}, {}, {}>, { options: { perAccountInitialValue } }?: {
+}>, { options: { perAccountInitialValue } }?: {
     options?: {
         perAccountInitialValue?: bigint | undefined;
     } | undefined;

package/src/core/startWalletFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"startWalletFactory.d.ts","sourceRoot":"","sources":["startWalletFactory.js"],"names":[],"mappings":"AAiFO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAlB+B,OAAO,qCAAqC,EAAE,+BAA+B;oBAC5F;QACtB,YAAoB,EAAE,QACtB,WACA,oEAAyE,OAAO,CAAC,CACtE,CACF,CAAC,cAAc,CAAC,CAAC;QAC1B,UAAkB,EAAE,UAAU,CAAC;KACxB;yBACoB,OAAO,aAAa,EAAE,mBAAmB;kCAChC,OAAO,aAAa,EAAE,mBAAmB;;;;;8BAwL7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCE;AAEK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWN;uCAjSY,QAAQ,WAAW,2BAA2B,CAAC,CAAC;uBAftC,gCAAgC;AASvD;;;;;;;GAOG;AAEH,2CARW,KAAK,UAAU,CAAC,QAChB,aACV,OAAW,2CAA2C,EAAE,KAAK,CAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKkE"}
+{"version":3,"file":"startWalletFactory.d.ts","sourceRoot":"","sources":["startWalletFactory.js"],"names":[],"mappings":"AAiFO,qnBArBI,eAAe,GACzB,qBAAyB,GACzB,eAAmB;IACnB,6BAAmC,EAAE,OAAO,qCAAqC,EAAE,+BAA+B,CAAC;IACnH,cAAoB,EAAE;QACtB,YAAoB,EAAE,QACtB,WACA,oEAAyE,OAAO,CAAC,CACtE,CACF,CAAC,cAAc,CAAC,CAAC;QAC1B,UAAkB,EAAE,UAAU,CAAC;KACxB,CAAC;IACR,mBAAyB,EAAE,OAAO,aAAa,EAAE,mBAAmB,CAAC;IACrE,4BAAkC,EAAE,OAAO,aAAa,EAAE,mBAAmB,CAAC;CACzE,CAAC;;;;8BAuLN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCE;AAEK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWN;uCAjSY,QAAQ,WAAW,2BAA2B,CAAC,CAAC;uBAftC,gCAAgC;AASvD;;;;;;;GAOG;AAEH,mEAPW,aACV,OAAW,2CAA2C,EAAE,KAAK,CAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKkE"}

package/src/core/utils.d.ts

@@ -62,7 +62,7 @@ export function addRemote(addr: string, { vats: { comms, vattp } }: {
         comms: CommsVatRoot;
     };
 }): Promise<void>;
-export function callProperties(builders: ((...args: any[]) => Record<string, unknown>)[], ...args: unknown[]): Record<string, unknown>;
+export function callProperties(builders: ((...args: any) => Record<string, unknown>)[], ...args: unknown[]): Record<string, unknown>;
 export function extract(template: true | string | Record<string, any>, specimen: unknown, path?: string[] | undefined): any;
 export function extractPowers(permit: true | string | Record<string, any>, allPowers: unknown): any;
 export function runModuleBehaviors({ allPowers, behaviors, manifest, makeConfig, }: {
@@ -71,11 +71,11 @@ export function runModuleBehaviors({ allPowers, behaviors, manifest, makeConfig,
     manifest: Record<string, Record<string, unknown>>;
     makeConfig: (name: string, permit: Record<string, unknown>) => unknown;
 }): Promise<any[]>;
-export function makePromiseSpaceForNameHub(nameAdmin: ERef<import('../types.js').NameAdmin>, log?: {
+export function makePromiseSpaceForNameHub(nameAdmin: ERef<import("../types.js").NameAdmin>, log?: {
     (...data: any[]): void;
     (message?: any, ...optionalParams: any[]): void;
 } | undefined): PromiseSpaceOf<any, {}, {}>;
-export function makeWellKnownSpaces(parentAdmin: ERef<import('../types.js').NameAdmin>, log?: {
+export function makeWellKnownSpaces(parentAdmin: ERef<import("../types.js").NameAdmin>, log?: {
     (...data: any[]): void;
     (message?: any, ...optionalParams: any[]): void;
 } | undefined, kinds?: string[] | undefined): Promise<WellKnownSpaces>;
@@ -91,7 +91,71 @@ export function makeMyAddressNameAdminKit(address: string): {
     nameHub: import("../types.js").NameHub;
     myAddressNameAdmin: import("../types.js").MyAddressNameAdmin;
 };
-export function makeVatSpace(svc: ERef<ReturnType<Awaited<VatAdminVat>['createVatAdminService']>>, criticalVatKey: unknown, log?: ((...args: any) => void) | undefined, label?: string | undefined): {
+export function makeVatSpace(svc: ERef<import("@endo/exo/src/exo-makers.js").Guarded<{
+    waitForBundleCap(bundleID: any): any;
+    getBundleCap(bundleID: any): any;
+    getNamedBundleCap(name: any): any;
+    getBundleIDByName(name: any): any;
+    createMeter(remaining: any, threshold: any): import("@agoric/swingset-liveslots").KindFacet<{
+        addRemaining({ state }: {
+            state: any;
+        }, delta: any): void;
+        setThreshold({ state }: {
+            state: any;
+        }, newThreshold: any): void;
+        get: ({ state }: {
+            state: any;
+        }) => any;
+        getNotifier: ({ _self }: {
+            _self: any;
+        }) => never;
+    }>;
+    createUnlimitedMeter(_context: any): import("@agoric/swingset-liveslots").KindFacet<{
+        addRemaining(_context: any, _delta: any): void;
+        setThreshold(_context: any, _newThreshold: any): void;
+        get: () => {
+            remaining: string;
+            threshold: number;
+        };
+        getNotifier: ({ _self }: {
+            _self: any;
+        }) => never;
+    }>;
+    createVat(bundleOrBundleCap: any, options?: {}): Promise<{
+        adminNode: import("@agoric/swingset-liveslots").KindFacet<{
+            terminateWithFailure({ state }: {
+                state: any;
+            }, reason: any): void;
+            done({ state }: {
+                state: any;
+            }): any;
+            upgrade({ state }: {
+                state: any;
+            }, bundlecap: any, options: any): Promise<any>;
+            changeOptions({ state }: {
+                state: any;
+            }, options: any): void;
+        }>;
+        root: any;
+    }>;
+    createVatByName(bundleName: any, options?: {}): Promise<{
+        adminNode: import("@agoric/swingset-liveslots").KindFacet<{
+            terminateWithFailure({ state }: {
+                state: any;
+            }, reason: any): void;
+            done({ state }: {
+                state: any;
+            }): any;
+            upgrade({ state }: {
+                state: any;
+            }, bundlecap: any, options: any): Promise<any>;
+            changeOptions({ state }: {
+                state: any;
+            }, options: any): void;
+        }>;
+        root: any;
+    }>;
+}>>, criticalVatKey: unknown, log?: ((...args: any) => void) | undefined, label?: string | undefined): {
     space: {
         consume: {
             agoricNames: Promise<{

package/src/core/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DG;AAEH,8BAA8B;AAC9B,8BADW,eAAe,CAKxB;AAQK,gCAHI,MAAM,8BACN;IAAE,IAAI,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,YAAY,CAAA;KAAE,CAAA;CAAE,iBAK5D;AAQM,8DAJkB,OAAO,MAAM,EAAE,OAAO,CAAC,cAClC,OAAO,KACR,OAAO,MAAM,EAAE,OAAO,CAAC,CAG0B;AAWvD,kCALI,IAAI,GAAG,MAAM,GAAG,OAAO,MAAM,EAAE,GAAG,CAAC,YAEnC,OAAO,oCAkCjB;AAQM,sCAJI,IAAI,GAAG,MAAM,GAAG,OAAO,MAAM,EAAE,GAAG,CAAC,aAEnC,OAAO,OAYjB;AAUM;eALI,OAAO;eACP,OAAO,MAAM,EAAE,OAAO,CAAC;cACvB,OAAO,MAAM,EAAE,OAAO,MAAM,EAAE,OAAO,CAAC,CAAC;uBAChC,MAAM,UAAU,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO;mBAwBpE;AASM,sDAHI,KAAK,OAAO,aAAa,EAAE,SAAS,CAAC;;;4CAyB/C;AAOM,iDAJI,KAAK,OAAO,aAAa,EAAE,SAAS,CAAC;;;uEAsB/C;AAoBM;;;0BAXI,OAAO,MAAM,EAAE,OAAO,MAAM,EAAE,OAAO,CAAC,CAAC;iBAMhC,OAAO,aAAa,EAAE,OAAO;sBACxB,OAAO,aAAa,EAAE,SAAS;YACzC,eAAe;GAuB3B;AAMM,mDAFI,MAAM;;;EAgBhB;AAaM,kCAVI,KAAK,WAAW,QAAQ,WAAW,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,kBAC/D,OAAO,mBACG,GAAG,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDhC;;;;+BApDY,OAAO,sBAAsB,EAAE,gBAAgB;uBAG/C,SAAS,MAAM,EAAE,gBAAgB,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DG;AAEH,8BAA8B;AAC9B,8BADW,eAAe,CAKxB;AAQK,gCAHI,MAAM,8BACN;IAAE,IAAI,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,YAAY,CAAA;KAAE,CAAA;CAAE,iBAK5D;AAQM,yCAJI,CAAC,CAAC,GAAG,IAAI,KAAA,KAAK,OAAO,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,WACrC,OAAO,KACR,OAAO,MAAM,EAAE,OAAO,CAAC,CAG0B;AAWvD,kCALI,IAAI,GAAG,MAAM,GAAG,OAAO,MAAM,EAAE,GAAG,CAAC,YAEnC,OAAO,oCAkCjB;AAQM,sCAJI,IAAI,GAAG,MAAM,GAAG,OAAO,MAAM,EAAE,GAAG,CAAC,aAEnC,OAAO,OAYjB;AAUM;IALkB,SAAS,EAAvB,OAAO;IACuB,SAAS,EAAvC,OAAO,MAAM,EAAE,OAAO,CAAC;IACuB,QAAQ,EAAtD,OAAO,MAAM,EAAE,OAAO,MAAM,EAAE,OAAO,CAAC,CAAC;IAC0B,UAAU,EAA3E,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO;mBAwBpE;AASM;;;4CAsBN;AAOM;;;uEAkBN;AAoBM;;;0BAXI,OAAO,MAAM,EAAE,OAAO,MAAM,EAAE,OAAO,CAAC,CAAC,GAKrC,QAAQ;IACpB,WAAe,EAAE,OAAO,aAAa,EAAE,OAAO,CAAC;IAC/C,gBAAoB,EAAE,OAAO,aAAa,EAAE,SAAS,CAAC;IACtD,MAAU,EAAE,eAAe,CAAC;CACzB,CAAC,CAsBJ;AAMM,mDAFI,MAAM;;;EAgBhB;AAaM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBATI,OAAO,mBACG,GAAG,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDhC;;;;+BApDY,OAAO,sBAAsB,EAAE,gBAAgB;uBAG/C,SAAS,MAAM,EAAE,gBAAgB,CAAC"}

package/src/localchain.d.ts

@@ -74,8 +74,8 @@ export function prepareLocalChainTools(zone: import('@agoric/base-zone').Zone):
     }>;
 };
 export type Proto3Jsonable = {
-    [x: string]: unknown;
     '@type': string;
+    [x: string]: unknown;
 };
 export type LocalChainPowers = {
     system: import('./types.js').ScopedBridgeManager;

package/src/localchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AAoCA;;;;GAMG;AAqDH;;;;GAIG;AAEH;;;;GAIG;AAEH;;GAEG;AAiGI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;YAzEpC;;;;eAIG;;;;YAgBH;;;;;eAKG;;;gBAlGL;;;;;;mBAMG;iCADQ,OAAO;gBAYlB;;;mBAGG;oCAFQ,cAAc,EAAE,GACd,QAAQ,cAAc,EAAE,CAAC;;YAwFpC;;;;;;;eAOG;2BAFQ,cAAc,GACZ,QAAQ,cAAc,CAAC;YAapC;;;;;;;eAOG;gCAFQ,cAAc,EAAE,GACd,QAAQ;gBAAE,KAAK,CAAC,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,cAAc,CAAA;aAAE,EAAE,CAAC;;;EAoBxE;;;aA1Ma,MAAM;;+BAMP;IACZ,MAAU,EAAE,OAAO,YAAY,EAAE,mBAAmB,CAAC;IACrD,WAAe,EAAE,OAAO,eAAe,EAAE,WAAW,CAAC;CAClD;yBAES,SACZ,MAAU,gBAAgB,EAC1B,gBAAoB,CAAC,MAAM,gBAAgB,CAAC,CACzC;gCAyES,QACZ,WAAe,QAAQ,WAAW,+BAA+B,CAAC,CAAC,CAAC,CACjE;8BAoHU,WAAW,6BAA6B,CAAC;4BACzC,WAAW,eAAe,CAAC,gBAAgB,CAAC,CAAC;yBAC7C,aAAa,CAAC,QAAQ,CAAC;AA5KrC,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC;;;;;;OAMG;qBADQ,OAAO;IAYlB;;;OAGG;wBAFQ,cAAc,EAAE,GACd,QAAQ,cAAc,EAAE,CAAC;GAgBzC"}
+{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AAoCA;;;;GAMG;AAqDH;;;;GAIG;AAEH;;;;GAIG;AAEH;;GAEG;AAiGI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;YAzEpC;;;;eAIG;;;;YAgBH;;;;;eAKG;;;gBAlGL;;;;;;mBAMG;iCADQ,OAAO;gBAYlB;;;mBAGG;oCAFQ,cAAc,EAAE,GACd,QAAQ,cAAc,EAAE,CAAC;;YAwFpC;;;;;;;eAOG;2BAFQ,cAAc,GACZ,QAAQ,cAAc,CAAC;YAapC;;;;;;;eAOG;gCAFQ,cAAc,EAAE,GACd,QAAQ;gBAAE,KAAK,CAAC,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,cAAc,CAAA;aAAE,EAAE,CAAC;;;EAoBxE;6BA3MY;IACZ,OAAW,EAAE,MAAM,CAAC;IACpB,CAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;+BAIS;IACZ,MAAU,EAAE,OAAO,YAAY,EAAE,mBAAmB,CAAC;IACrD,WAAe,EAAE,OAAO,eAAe,EAAE,WAAW,CAAC;CAClD;yBAES,SACZ,MAAU,gBAAgB,EAC1B,gBAAoB,CAAC,MAAM,gBAAgB,CAAC,CACzC;gCAyES,QACZ,WAAe,QAAQ,WAAW,+BAA+B,CAAC,CAAC,CAAC,CACjE;8BAoHU,WAAW,6BAA6B,CAAC;4BACzC,WAAW,eAAe,CAAC,gBAAgB,CAAC,CAAC;yBAC7C,aAAa,CAAC,QAAQ,CAAC;AA5KrC,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC;;;;;;OAMG;qBADQ,OAAO;IAYlB;;;OAGG;wBAFQ,cAAc,EAAE,GACd,QAAQ,cAAc,EAAE,CAAC;GAgBzC"}

package/src/nameHub.d.ts

@@ -20,7 +20,13 @@ export namespace NameHubIKit {
 }
 export function prepareMixinMyAddress(zone: import('@agoric/zone').Zone): (nameAdmin: import('./types.js').NameAdmin, address: string) => import("@endo/exo/src/exo-makers.js").Farable<import("./types.js").MyAddressNameAdmin>;
 export function prepareNameHubKit(zone: import('@agoric/zone').Zone): () => import('./types.js').NameHubKit;
-export function makeNameHubKit(): import('./types.js').NameHubKit;
+/**
+ * Make two facets of a node in a name hierarchy: the nameHub is read access and
+ * the nameAdmin is write access.
+ *
+ * @returns {import('./types.js').NameHubKit}
+ */
+export const makeNameHubKit: () => import('./types.js').NameHubKit;
 export type NonPrimitive = {
     [key: string]: any;
 };

package/src/nameHub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nameHub.d.ts","sourceRoot":"","sources":["nameHub.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AA8CO,4CADK,OAAO,cAAc,EAAE,IAAI,eA4B1B,OAAO,YAAY,EAAE,SAAS,WAC9B,MAAM,4FAalB;AA4CM,wCAFI,OAAO,cAAc,EAAE,IAAI,SAcnB,OAAO,YAAY,EAAE,UAAU,CA0NjD;AA1NY,kCAAM,OAAO,YAAY,EAAE,UAAU,CAAA"}
+{"version":3,"file":"nameHub.d.ts","sourceRoot":"","sources":["nameHub.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AA8CO,4CADK,OAAO,cAAc,EAAE,IAAI,eA4B1B,OAAO,YAAY,EAAE,SAAS,WAC9B,MAAM,4FAalB;AA4CM,wCAFI,OAAO,cAAc,EAAE,IAAI,SAcnB,OAAO,YAAY,EAAE,UAAU,CA0NjD;AAED;;;;;GAKG;AACH,mCAlOmB,OAAO,YAAY,EAAE,UAAU,CAkOc;2BAvRlD;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE"}

package/src/priceAuthorityRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"priceAuthorityRegistry.d.ts","sourceRoot":"","sources":["priceAuthorityRegistry.js"],"names":[],"mappings":"AA4CO,uDAHI,OAAO,kBAAkB,EAAE,OAAO,GAChC,sBAAsB,CA4KlC;;YAtMa,MAAM,IAAI;;;;;;iCAMf,KAAK,cAAc,CAAC,WACf,KAAK,YACJ,KAAK,UACP,OAAO,KACZ,QAAQ,OAAO,CAAC;;;;;;;;oBAQV,cAAc;gBACd,2BAA2B"}
+{"version":3,"file":"priceAuthorityRegistry.d.ts","sourceRoot":"","sources":["priceAuthorityRegistry.js"],"names":[],"mappings":"AA4CO,uDAHI,OAAO,kBAAkB,EAAE,OAAO,GAChC,sBAAsB,CA4KlC;;YAtMa,MAAM,IAAI;;;;;;gEAOV,KAAK,YACJ,KAAK,UACP,OAAO,KACZ,QAAQ,OAAO,CAAC;;;;;;;;oBAQV,cAAc;gBACd,2BAA2B"}