@agoric/vats 0.15.2-dev-7ffae88.0 → 0.15.2-dev-c5284e4.0

package/src/localchain.d.ts

@@ -0,0 +1,22 @@
+export const LocalChainAccountI: import("@endo/patterns").InterfaceGuard<{
+    getAddress: import("@endo/patterns").MethodGuard;
+    executeTx: import("@endo/patterns").MethodGuard;
+    allBalances: import("@endo/patterns").MethodGuard;
+}>;
+export const LocalChainI: import("@endo/patterns").InterfaceGuard<{
+    createAccount: import("@endo/patterns").MethodGuard;
+    query: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareLocalChainTools(zone: import('@agoric/base-zone').Zone): {
+    makeLocalChain: (system: import("./types.js").ScopedBridgeManager) => import("@endo/exo/src/exo-makers.js").Guarded<{
+        createAccount(): Promise<import("@endo/exo/src/exo-makers.js").Guarded<{
+            getAddress(): Promise<string>;
+            allBalances(): Promise<any>;
+            executeTx(messages: any): Promise<any>;
+        }>>;
+        query(messages: any): Promise<any>;
+    }>;
+};
+export type LocalChainTools = ReturnType<typeof prepareLocalChainTools>;
+export type LocalChain = ReturnType<LocalChainTools['makeLocalChain']>;
+//# sourceMappingURL=localchain.d.ts.map

package/src/localchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AAKA;;;;GAMG;AA+CH;;;GAGG;AAmCI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;;;;;;;EAM3C;8BAGa,WAAW,6BAA6B,CAAC;yBACzC,WAAW,eAAe,CAAC,gBAAgB,CAAC,CAAC"}

package/src/localchain.js

@@ -0,0 +1,106 @@
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+
+const { Fail } = assert;
+
+export const LocalChainAccountI = M.interface('LocalChainAccount', {
+  getAddress: M.callWhen().returns(M.string()),
+  executeTx: M.callWhen(M.arrayOf(M.record())).returns(M.arrayOf(M.record())),
+  // An example of a high-level query.  TODO: Move this functionality to a higher
+  // layer that implements the Orchestration API.
+  allBalances: M.callWhen().returns(M.record()),
+});
+
+/** @param {import('@agoric/base-zone').Zone} zone */
+const prepareLocalChainAccount = zone =>
+  zone.exoClass(
+    'LocalChainAccount',
+    LocalChainAccountI,
+    /**
+     * @param {import('./types.js').ScopedBridgeManager} system
+     * @param {string} address
+     * @param {{ query: (messages: any[]) => Promise<any> }} chain
+     */
+    (system, address, chain) => ({ system, address, chain }),
+    {
+      // Information that the account creator needs.
+      async getAddress() {
+        return this.state.address;
+      },
+      async allBalances() {
+        // We make a balance request, scoped to our own address.
+        const { address, chain } = this.state;
+        const res = await chain.query([
+          {
+            '@type': '/cosmos.bank.v1beta1.QueryAllBalancesRequest',
+            address,
+          },
+        ]);
+        if (res[0].error) {
+          throw Fail`query failed: ${res[0].error}`;
+        }
+        return res[0].reply;
+      },
+      async executeTx(messages) {
+        const { system, address } = this.state;
+        const obj = {
+          type: 'VLOCALCHAIN_EXECUTE_TX',
+          // This address is the only one that `VLOCALCHAIN_EXECUTE_TX` will
+          // accept as a signer for the transaction.  If the messages have other
+          // addresses in signer positions, the transaction will be aborted.
+          address,
+          messages,
+        };
+        return E(system).toBridge(obj);
+      },
+    },
+  );
+
+export const LocalChainI = M.interface('LocalChain', {
+  createAccount: M.callWhen().returns(M.remotable('LocalChainAccount')),
+  query: M.callWhen(M.arrayOf(M.record())).returns(M.arrayOf(M.record())),
+});
+
+/**
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {ReturnType<typeof prepareLocalChainAccount>} createAccount
+ */
+const prepareLocalChain = (zone, createAccount) =>
+  zone.exoClass(
+    'LocalChain',
+    LocalChainI,
+    /** @param {import('./types.js').ScopedBridgeManager} system */
+    system => ({ system }),
+    {
+      async createAccount() {
+        const { system } = this.state;
+        // Allocate a fresh address that doesn't correspond with a public key,
+        // and follows the ICA guidelines to help reduce collisions.  See
+        // x/vlocalchain/keeper/keeper.go AllocateAddress for the use of the app
+        // hash and block data hash.
+        const address = await E(system).toBridge({
+          type: 'VLOCALCHAIN_ALLOCATE_ADDRESS',
+        });
+        return createAccount(system, address, this.self);
+      },
+      async query(messages) {
+        const { system } = this.state;
+        return E(system).toBridge({
+          type: 'VLOCALCHAIN_QUERY',
+          messages,
+        });
+      },
+    },
+  );
+
+/** @param {import('@agoric/base-zone').Zone} zone */
+export const prepareLocalChainTools = zone => {
+  const createAccount = prepareLocalChainAccount(zone);
+  const makeLocalChain = prepareLocalChain(zone, createAccount);
+
+  return harden({ makeLocalChain });
+};
+harden(prepareLocalChainTools);
+
+/** @typedef {ReturnType<typeof prepareLocalChainTools>} LocalChainTools */
+/** @typedef {ReturnType<LocalChainTools['makeLocalChain']>} LocalChain */

package/src/proposals/localchain-proposal.d.ts

@@ -0,0 +1,405 @@
+export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, }, produce: { localchainVat, localchain, localchainBridgeManager }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
+    vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
+}, {}, {
+    loadVat: VatLoader<unknown>;
+    loadCriticalVat: VatLoader<unknown>;
+}> & {
+    zone: import("@agoric/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/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/zone").Zone;
+                consume: {
+                    economicCommitteeCreatorFacet: Promise<import("@agoric/governance/src/committee").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("../core/basic-behaviors").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("../core/basic-behaviors").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: {
+                    walletFactory: string;
+                    reserve: string;
+                    centralSupply: string;
+                    mintHolder: 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;
+                    econCommitteeCharter: string;
+                    priceAggregator: string;
+                };
+                instance: {
+                    walletFactory: string;
+                    reserve: string;
+                    provisionPool: string;
+                    auctioneer: string;
+                    feeDistributor: string;
+                    VaultFactory: string;
+                    Pegasus: 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").NameAdmin>, log?: {
+                (...data: any[]): void;
+                (message?: any, ...optionalParams: any[]): void;
+            } | undefined) => PromiseSpaceOf<any, {}, {}>;
+            makeWellKnownSpaces: (parentAdmin: ERef<import("../types").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").NameHub;
+                agoricNamesAdmin: import("../types").NameAdmin;
+                spaces: WellKnownSpaces;
+            }>;
+            makeMyAddressNameAdminKit: (address: string) => {
+                nameHub: import("../types").NameHub;
+                myAddressNameAdmin: import("../types").MyAddressNameAdmin;
+            };
+            makeVatSpace: (svc: ERef<import("@endo/exo/src/exo-makers").Guarded<{
+                waitForBundleCap(bundleID: any): any;
+                getBundleCap(bundleID: any): any;
+                getNamedBundleCap(name: any): any;
+                getBundleIDByName(name: any): any;
+                createMeter(remaining: any, threshold: any): any;
+                createUnlimitedMeter(_context: any): any;
+                createVat(bundleOrBundleCap: any, options?: {}): Promise<{
+                    adminNode: any;
+                    root: any;
+                }>;
+                createVatByName(bundleName: any, options?: {}): Promise<{
+                    adminNode: any;
+                    root: any;
+                }>;
+            }>>, criticalVatKey: unknown, log?: ((...args: any) => void) | undefined, label?: string | undefined) => {
+                space: {
+                    consume: {
+                        agoricNames: Promise<{
+                            getNameHub: () => import("../types").NameHub;
+                            getNameHubKit: () => import("../types").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").NameHub;
+                            getNameHubKit: () => import("../types").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").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").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").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").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport").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").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport").RecorderKit<T>;
+                        } & import("@endo/eventual-send").RemotableBrand<{}, {
+                            getBoard: () => import("@endo/exo/src/exo-makers").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").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").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").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport").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").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport").RecorderKit<T>;
+                        }>>;
+                    };
+                };
+                durableStore: any;
+            };
+        };
+    };
+} & {
+    consume: {
+        loadCriticalVat: VatLoader<any>;
+        bridgeManager: import('../types').BridgeManager;
+        localchainBridgeManager: import('../types').ScopedBridgeManager;
+    };
+    produce: {
+        localchain: Producer<any>;
+        localchainVat: Producer<any>;
+        localchainBridgeManager: Producer<any>;
+    };
+}, options: {
+    options: {
+        localchainRef: VatSourceRef;
+    };
+}): Promise<void>;
+export function addLocalChainToClient({ consume: { client, localchain } }: BootstrapPowers & {
+    consume: {
+        localchain: import('../localchain.js').LocalChain;
+    };
+}, _options: object): Promise<void>;
+export function getManifestForLocalChain(_powers: any, { localchainRef }: {
+    localchainRef: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                loadCriticalVat: boolean;
+                bridgeManager: string;
+                localchainBridgeManager: string;
+                client?: undefined;
+                localchain?: undefined;
+            };
+            produce: {
+                localchain: string;
+                localchainVat: string;
+                localchainBridgeManager: string;
+            };
+        } | {
+            consume: {
+                client: string;
+                localchain: string;
+                loadCriticalVat?: undefined;
+                bridgeManager?: undefined;
+                localchainBridgeManager?: undefined;
+            };
+            produce?: undefined;
+        };
+    };
+    options: {
+        localchainRef: any;
+    };
+};
+export type LocalChainVats = {
+    localchain: ERef<import('../vat-localchain.js').LocalChainVat>;
+};
+//# sourceMappingURL=localchain-proposal.d.ts.map

package/src/proposals/localchain-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AAwBO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAjBiB,UAAU,GAAG,CAAC;uBAChB,OAAO,UAAU,EAAE,aAAa;iCACtB,OAAO,UAAU,EAAE,mBAAmB;;aAExD;QACb,UAAgB,EAAE,SAAS,GAAG,CAAC,CAAC;QAChC,aAAmB,EAAE,SAAS,GAAG,CAAC,CAAC;QACnC,uBAA6B,EAAE,SAAS,GAAG,CAAC,CAAC;KACxC;;;uBAGsB,YAAY;;kBAqDvC;AAUM,2EAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBL;6BA7FW;IACZ,UAAc,EAAE,KAAK,OAAO,sBAAsB,EAAE,aAAa,CAAC,CAAC;CAChE"}

package/src/proposals/localchain-proposal.js

@@ -0,0 +1,114 @@
+// @ts-check
+import { E } from '@endo/far';
+import { BridgeId as BRIDGE_ID } from '@agoric/internal';
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     loadCriticalVat: VatLoader<any>;
+ *     bridgeManager: import('../types').BridgeManager;
+ *     localchainBridgeManager: import('../types').ScopedBridgeManager;
+ *   };
+ *   produce: {
+ *     localchain: Producer<any>;
+ *     localchainVat: Producer<any>;
+ *     localchainBridgeManager: Producer<any>;
+ *   };
+ * }} powers
+ * @param {object} options
+ * @param {{ localchainRef: VatSourceRef }} options.options
+ *
+ * @typedef {{
+ *   localchain: ERef<import('../vat-localchain.js').LocalChainVat>;
+ * }} LocalChainVats
+ */
+export const setupLocalChainVat = async (
+  {
+    consume: {
+      loadCriticalVat,
+      bridgeManager: bridgeManagerP,
+      localchainBridgeManager: localchainBridgeManagerP,
+    },
+    produce: { localchainVat, localchain, localchainBridgeManager },
+  },
+  options,
+) => {
+  const bridgeManager = await bridgeManagerP;
+  if (!bridgeManager) {
+    // The sim-chain doesn't have a bridgeManager, so we can't set up the
+    // localchain vat.
+    console.error('No bridgeManager, skipping setupLocalChainVat');
+    return;
+  }
+
+  const { localchainRef } = options.options;
+  /** @type {LocalChainVats} */
+  const vats = {
+    localchain: E(loadCriticalVat)('localchain', localchainRef),
+  };
+  // don't proceed if loadCriticalVat fails
+  await Promise.all(Object.values(vats));
+
+  localchainVat.reset();
+  localchainVat.resolve(vats.localchain);
+  /** @type {import('../types').ScopedBridgeManager} */
+  let scopedManager;
+  try {
+    scopedManager = await E(bridgeManager).register(BRIDGE_ID.VLOCALCHAIN);
+    localchainBridgeManager.reset();
+    localchainBridgeManager.resolve(scopedManager);
+  } catch (e) {
+    console.error('Failed to register', BRIDGE_ID.VLOCALCHAIN, 'reason:', e);
+    scopedManager = await localchainBridgeManagerP;
+    console.info(
+      'Successfully retrieved scopedManager for',
+      BRIDGE_ID.VLOCALCHAIN,
+    );
+  }
+
+  const newLocalChain = await E(vats.localchain).makeLocalChain(scopedManager);
+  localchain.reset();
+  localchain.resolve(newLocalChain);
+};
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     localchain: import('../localchain.js').LocalChain;
+ *   };
+ * }} powers
+ * @param {object} _options
+ */
+export const addLocalChainToClient = async (
+  { consume: { client, localchain } },
+  _options,
+) => {
+  return E(client).assignBundle([_a => ({ localchain })]);
+};
+
+export const getManifestForLocalChain = (_powers, { localchainRef }) => ({
+  manifest: {
+    [setupLocalChainVat.name]: {
+      consume: {
+        loadCriticalVat: true,
+        bridgeManager: 'bridge',
+        localchainBridgeManager: 'localchain',
+      },
+      produce: {
+        localchain: 'localchain',
+        localchainVat: 'localchain',
+        localchainBridgeManager: 'localchain',
+      },
+    },
+
+    [addLocalChainToClient.name]: {
+      consume: {
+        client: 'provisioning',
+        localchain: 'localchain',
+      },
+    },
+  },
+  options: {
+    localchainRef,
+  },
+});