@agoric/orchestration 0.2.0-upgrade-18a-dev-2899fb9.0 → 0.2.0-upgrade-19-dev-0754752.0

package/tools/protobuf-decoder.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Decodes a protobuf message from the given buffer.
+ *
+ * @param {Buffer} buffer
+ */
+export function decodeProtobuf(buffer: Buffer): {
+    value: {};
+    bytesRead: number;
+};
+/**
+ * Decodes a protobuf message from the given base64-encoded data.
+ *
+ * @param {string} base64String
+ */
+export function decodeProtobufBase64(base64String: string): {
+    value: {};
+    bytesRead: number;
+};
+//# sourceMappingURL=protobuf-decoder.d.ts.map

package/tools/protobuf-decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protobuf-decoder.d.ts","sourceRoot":"","sources":["protobuf-decoder.js"],"names":[],"mappings":"AA8HA;;;;GAIG;AACH,uCAFW,MAAM;;;EAchB;AACD;;;;GAIG;AACH,mDAFW,MAAM;;;EAKhB"}

package/tools/protobuf-decoder.js

@@ -0,0 +1,153 @@
+/* eslint-env node */
+/* eslint-disable -- generated by Sonnet, easier to leave alone */
+
+const WIRE_TYPES = {
+  VARINT: 0,
+  FIXED64: 1,
+  LENGTH_DELIMITED: 2,
+  START_GROUP: 3,
+  END_GROUP: 4,
+  FIXED32: 5,
+};
+
+function decodeVarint(buffer, offset) {
+  let result = 0n;
+  let shift = 0;
+  let byte;
+
+  do {
+    if (offset >= buffer.length) {
+      throw new Error('Buffer overflow while decoding varint');
+    }
+    byte = buffer[offset];
+    result |= BigInt(byte & 0x7f) << BigInt(shift);
+    shift += 7;
+    offset++;
+  } while (byte & 0x80);
+
+  return { value: result, bytesRead: shift / 7 };
+}
+
+function decodeFixed32(buffer, offset) {
+  if (offset + 4 > buffer.length) {
+    throw new Error('Buffer overflow while decoding fixed32');
+  }
+  return {
+    value: buffer.readUInt32LE(offset),
+    bytesRead: 4,
+  };
+}
+
+function decodeFixed64(buffer, offset) {
+  if (offset + 8 > buffer.length) {
+    throw new Error('Buffer overflow while decoding fixed64');
+  }
+  const low = buffer.readUInt32LE(offset);
+  const high = buffer.readUInt32LE(offset + 4);
+  return {
+    value: BigInt(high) * 2n ** 32n + BigInt(low),
+    bytesRead: 8,
+  };
+}
+
+function decodeString(buffer, offset, length) {
+  if (offset + length > buffer.length) {
+    throw new Error('Buffer overflow while decoding string');
+  }
+  return {
+    value: buffer.toString('utf8', offset, offset + length),
+    bytesRead: length,
+  };
+}
+
+function decodeField(buffer, offset) {
+  const tag = decodeVarint(buffer, offset);
+  offset += tag.bytesRead;
+
+  const fieldNumber = Number(tag.value >> 3n);
+  const wireType = Number(tag.value & 0x7n);
+
+  let value;
+  let bytesRead;
+
+  switch (wireType) {
+    case WIRE_TYPES.VARINT:
+      ({ value, bytesRead } = decodeVarint(buffer, offset));
+      break;
+    case WIRE_TYPES.FIXED64:
+      ({ value, bytesRead } = decodeFixed64(buffer, offset));
+      break;
+    case WIRE_TYPES.LENGTH_DELIMITED:
+      const length = decodeVarint(buffer, offset);
+      offset += length.bytesRead;
+      // Try to decode as a nested message first
+      try {
+        ({ value, bytesRead } = decodeProtobuf(
+          buffer.slice(offset, offset + Number(length.value)),
+        ));
+      } catch (e) {
+        // If it fails, decode as a string
+        ({ value, bytesRead } = decodeString(
+          buffer,
+          offset,
+          Number(length.value),
+        ));
+      }
+      bytesRead += length.bytesRead;
+      break;
+    case WIRE_TYPES.FIXED32:
+      ({ value, bytesRead } = decodeFixed32(buffer, offset));
+      break;
+    default:
+      throw new Error(`Unsupported wire type: ${wireType}`);
+  }
+
+  return {
+    fieldNumber,
+    wireType,
+    value,
+    bytesRead: tag.bytesRead + bytesRead,
+  };
+}
+
+function getFieldName(fieldNumber, wireType) {
+  const typePrefix =
+    wireType === WIRE_TYPES.LENGTH_DELIMITED
+      ? 'subMessage'
+      : wireType === WIRE_TYPES.VARINT
+        ? 'int'
+        : wireType === WIRE_TYPES.FIXED32
+          ? 'fixed32'
+          : wireType === WIRE_TYPES.FIXED64
+            ? 'fixed64'
+            : 'string';
+  return `${typePrefix}_${fieldNumber}`;
+}
+
+/**
+ * Decodes a protobuf message from the given buffer.
+ *
+ * @param {Buffer} buffer
+ */
+export function decodeProtobuf(buffer) {
+  let offset = 0;
+  const message = {};
+
+  while (offset < buffer.length) {
+    const field = decodeField(buffer, offset);
+    const fieldName = getFieldName(field.fieldNumber, field.wireType);
+    message[fieldName] = field.value;
+    offset += field.bytesRead;
+  }
+
+  return { value: message, bytesRead: offset };
+}
+/**
+ * Decodes a protobuf message from the given base64-encoded data.
+ *
+ * @param {string} base64String
+ */
+export function decodeProtobufBase64(base64String) {
+  const buffer = Buffer.from(base64String, 'base64');
+  return decodeProtobuf(buffer);
+}

package/src/proposals/init-chain-info.d.ts

@@ -1,12 +0,0 @@
-export function initChainInfo({ consume: { agoricNamesAdmin, chainStorage: chainStorageP }, }: BootstrapPowers): Promise<void>;
-export function getManifestForChainInfo(): {
-    manifest: {
-        [x: string]: {
-            consume: {
-                agoricNamesAdmin: boolean;
-                chainStorage: boolean;
-            };
-        };
-    };
-};
-//# sourceMappingURL=init-chain-info.d.ts.map

package/src/proposals/init-chain-info.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init-chain-info.d.ts","sourceRoot":"","sources":["init-chain-info.js"],"names":[],"mappings":"AA2EO,+FAFI,eAAe,iBAYzB;AAGM;;;;;;;;;EASL"}

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

@@ -1,33 +0,0 @@
-export function setupOrchestrationVat({ consume: { loadCriticalVat, portAllocator: portAllocatorP }, produce: { orchestrationVat, ...produce }, }: BootstrapPowers & {
-    consume: {
-        portAllocator: PortAllocator;
-    };
-    produce: {
-        orchestrationVat: Producer<any>;
-    };
-}, { options }: {
-    options: {
-        orchestrationRef: VatSourceRef;
-    };
-}): Promise<void>;
-export function getManifestForOrchestration(_powers: any, { orchestrationRef }: {
-    orchestrationRef: any;
-}): {
-    manifest: {
-        [x: string]: {
-            consume: {
-                loadCriticalVat: boolean;
-                portAllocator: string;
-            };
-            produce: {
-                cosmosInterchainService: string;
-                orchestrationVat: string;
-            };
-        };
-    };
-    options: {
-        orchestrationRef: any;
-    };
-};
-import type { PortAllocator } from '@agoric/network';
-//# sourceMappingURL=orchestration-proposal.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"orchestration-proposal.d.ts","sourceRoot":"","sources":["orchestration-proposal.js"],"names":[],"mappings":"AAoBO,mJAVI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,aAAa,EAAE,aAAa,CAAC;KAC9B,CAAC;IACF,OAAO,EAAE;QACP,gBAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACjC,CAAC;CACH,eACO;IAAE,OAAO,EAAE;QAAE,gBAAgB,EAAE,YAAY,CAAA;KAAE,CAAA;CAAE,iBAgCzD;AAEM;;;;;;;;;;;;;;;;;;EAgBL;mCA9D8B,iBAAiB"}

package/src/proposals/revise-chain-info.d.ts

@@ -1,21 +0,0 @@
-export function reviseChainInfo({ consume: { agoricNamesAdmin } }: BootstrapPowers, { options: { chainInfo } }: {
-    options: {
-        chainInfo: Record<string, CosmosChainInfo>;
-    };
-}): Promise<void>;
-export function getManifestForReviseChains(_powers: any, { chainInfo }: {
-    chainInfo: any;
-}): {
-    manifest: {
-        [x: string]: {
-            consume: {
-                agoricNamesAdmin: boolean;
-            };
-        };
-    };
-    options: {
-        chainInfo: any;
-    };
-};
-import type { CosmosChainInfo } from '../types.js';
-//# sourceMappingURL=revise-chain-info.d.ts.map

package/src/proposals/revise-chain-info.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"revise-chain-info.d.ts","sourceRoot":"","sources":["revise-chain-info.js"],"names":[],"mappings":"AAeO,mEAHI,eAAe,8BACf;IAAE,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;KAAE,CAAA;CAAE,iBAgBrE;AAGM;;;;;;;;;;;;;EAWL;qCAtCiC,aAAa"}

package/src/proposals/start-auto-stake-it.d.ts

@@ -1,52 +0,0 @@
-export function startAutoStakeIt({ consume: { agoricNames, board, chainStorage, chainTimerService, cosmosInterchainService, localchain, startUpgradable, }, installation: { consume: { [contractName]: installation }, }, instance: { produce: { [contractName]: produceInstance }, }, }: BootstrapPowers, { options: { chainInfo, assetInfo } }: {
-    options: {
-        chainInfo: Record<string, CosmosChainInfo>;
-        assetInfo: [Denom, DenomDetail & {
-            brandKey?: string;
-        }][];
-    };
-}): Promise<void>;
-export function getManifest({ restoreRef }: {
-    restoreRef: any;
-}, { installKeys, options }: {
-    installKeys: any;
-    options: any;
-}): {
-    manifest: {
-        [x: string]: {
-            consume: {
-                agoricNames: boolean;
-                board: boolean;
-                chainStorage: boolean;
-                chainTimerService: boolean;
-                cosmosInterchainService: boolean;
-                localchain: boolean;
-                startUpgradable: boolean;
-            };
-            installation: {
-                consume: {
-                    autoAutoStakeIt: boolean;
-                };
-            };
-            instance: {
-                produce: {
-                    autoAutoStakeIt: boolean;
-                };
-            };
-        };
-    };
-    installations: {
-        autoAutoStakeIt: any;
-    };
-    options: any;
-};
-/**
- * @import {AutoStakeItSF} from '@agoric/orchestration/src/examples/auto-stake-it.contract.js';
- * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
- */
-declare const contractName: "autoAutoStakeIt";
-import type { CosmosChainInfo } from '@agoric/orchestration';
-import type { Denom } from '@agoric/orchestration';
-import type { DenomDetail } from '@agoric/orchestration';
-export {};
-//# sourceMappingURL=start-auto-stake-it.d.ts.map

package/src/proposals/start-auto-stake-it.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-auto-stake-it.d.ts","sourceRoot":"","sources":["start-auto-stake-it.js"],"names":[],"mappings":"AA4BO,0RARI,eAAe,yCACf;IACN,OAAO,EAAE;QACP,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QAC3C,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,EAAE,CAAC;KAC3D,CAAC;CACH,iBAoDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BN;AAhGD;;;GAGG;AAEH,4BAAqB,iBAAiB,CAAC;qCAHe,uBAAuB;2BAAvB,uBAAuB;iCAAvB,uBAAuB"}

package/src/proposals/start-basic-flows.d.ts

@@ -1,73 +0,0 @@
-export function startBasicFlows({ consume: { agoricNames, board, chainStorage, chainTimerService, cosmosInterchainService, localchain, startUpgradable, }, installation: { consume: { [contractName]: installation }, }, instance: { produce: { [contractName]: produceInstance }, }, issuer: { consume: { BLD, IST }, }, }: BootstrapPowers & {
-    installation: {
-        consume: {
-            basicFlows: Installation<BasicFlowsSF>;
-        };
-    };
-    instance: {
-        produce: {
-            basicFlows: Producer<Instance>;
-        };
-    };
-    issuer: {
-        consume: {
-            BLD: Issuer<"nat">;
-            IST: Issuer<"nat">;
-            USDC: Issuer<"nat">;
-        };
-    };
-}, { options: { chainInfo, assetInfo } }: {
-    options: {
-        chainInfo: Record<string, CosmosChainInfo>;
-        assetInfo: [Denom, DenomDetail & {
-            brandKey?: string;
-        }][];
-    };
-}): Promise<void>;
-export function getManifestForContract({ restoreRef }: {
-    restoreRef: any;
-}, { installKeys, options }: {
-    installKeys: any;
-    options: any;
-}): {
-    manifest: {
-        [x: string]: {
-            consume: {
-                agoricNames: boolean;
-                board: boolean;
-                chainStorage: boolean;
-                chainTimerService: boolean;
-                cosmosInterchainService: boolean;
-                localchain: boolean;
-                startUpgradable: boolean;
-            };
-            installation: {
-                consume: {
-                    basicFlows: boolean;
-                };
-            };
-            instance: {
-                produce: {
-                    basicFlows: boolean;
-                };
-            };
-            issuer: {
-                consume: {
-                    BLD: boolean;
-                    IST: boolean;
-                };
-            };
-        };
-    };
-    installations: {
-        basicFlows: any;
-    };
-    options: any;
-};
-import type { BasicFlowsSF } from '../examples/basic-flows.contract.js';
-declare const contractName: "basicFlows";
-import type { CosmosChainInfo } from '@agoric/orchestration';
-import type { Denom } from '@agoric/orchestration';
-import type { DenomDetail } from '@agoric/orchestration';
-export {};
-//# sourceMappingURL=start-basic-flows.d.ts.map

package/src/proposals/start-basic-flows.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-basic-flows.d.ts","sourceRoot":"","sources":["start-basic-flows.js"],"names":[],"mappings":"AAgDO,6TA1BI,eAAe,GAAG;IACxB,YAAY,EAAE;QACZ,OAAO,EAAE;YACP,UAAU,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC;SACxC,CAAC;KACH,CAAC;IACF,QAAQ,EAAE;QACR,OAAO,EAAE;YACP,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;SAChC,CAAC;KACH,CAAC;IACF,MAAM,EAAE;QACN,OAAO,EAAE;YACP,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YACnB,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YACnB,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;SACrB,CAAC;KACH,CAAC;CACH,yCACO;IACN,OAAO,EAAE;QACP,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QAC3C,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,EAAE,CAAC;KAC3D,CAAC;CACH,iBAsDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCN;kCA9H8B,qCAAqC;AAIpE,4BAAqB,YAAY,CAAC;qCALoB,uBAAuB;2BAAvB,uBAAuB;iCAAvB,uBAAuB"}

package/src/proposals/start-send-anywhere.d.ts

@@ -1,105 +0,0 @@
-export function startSendAnywhere({ consume: { agoricNames, board, chainStorage, chainTimerService, cosmosInterchainService, localchain, startUpgradable, }, installation: { consume: { sendAnywhere }, }, instance: { produce: { sendAnywhere: produceInstance }, }, issuer: { consume: { BLD, IST }, }, }: BootstrapPowers & {
-    installation: {
-        consume: {
-            sendAnywhere: Installation<(zcf: ZCF<Record<string, unknown>>, privateArgs: import("@agoric/orchestration").OrchestrationPowers & {
-                marshaller: Marshaller;
-                chainInfo?: Record<string, Readonly<{
-                    bech32Prefix?: string;
-                    chainId: string;
-                    connections?: Record<string, import("@agoric/orchestration").IBCConnectionInfo>;
-                    icqEnabled?: boolean;
-                    pfmEnabled?: boolean;
-                    stakingTokens?: Readonly<Array<{
-                        denom: string;
-                    }>>;
-                }>>;
-                assetInfo?: [Denom, DenomDetail & {
-                    brandKey?: string;
-                }][];
-            }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
-                publicFacet: import("@endo/exo").Guarded<{
-                    makeSendInvitation(): Promise<Invitation<import("@agoric/vow").Vow<void>, {
-                        chainName: string;
-                        destAddr: string;
-                    }>>;
-                }>;
-                creatorFacet: import("@endo/exo").Guarded<{
-                    registerChain(chainName: string, chainInfo: Readonly<{
-                        bech32Prefix?: string;
-                        chainId: string;
-                        connections?: Record<string, import("@agoric/orchestration").IBCConnectionInfo>;
-                        icqEnabled?: boolean;
-                        pfmEnabled?: boolean;
-                        stakingTokens?: Readonly<Array<{
-                            denom: string;
-                        }>>;
-                    }>, connectionInfo: import("@agoric/orchestration").IBCConnectionInfo): Promise<void>;
-                    registerAsset(denom: Denom, detail: DenomDetail): Promise<void>;
-                }>;
-            }>>;
-        };
-    };
-    instance: {
-        produce: {
-            sendAnywhere: Producer<Instance>;
-        };
-    };
-    issuer: {
-        consume: {
-            BLD: Issuer<"nat">;
-            IST: Issuer<"nat">;
-        };
-    };
-}, { options: { chainInfo, assetInfo } }: {
-    options: {
-        chainInfo: Record<string, CosmosChainInfo>;
-        assetInfo: [Denom, DenomDetail & {
-            brandKey?: string;
-        }][];
-    };
-}): Promise<void>;
-export function getManifest({ restoreRef }: {
-    restoreRef: any;
-}, { installationRef, options }: {
-    installationRef: any;
-    options: any;
-}): {
-    manifest: {
-        [x: string]: {
-            consume: {
-                agoricNames: boolean;
-                board: boolean;
-                chainStorage: boolean;
-                chainTimerService: boolean;
-                cosmosInterchainService: boolean;
-                localchain: boolean;
-                startUpgradable: boolean;
-            };
-            installation: {
-                consume: {
-                    sendAnywhere: boolean;
-                };
-            };
-            instance: {
-                produce: {
-                    sendAnywhere: boolean;
-                };
-            };
-            issuer: {
-                consume: {
-                    BLD: boolean;
-                    IST: boolean;
-                };
-            };
-        };
-    };
-    installations: {
-        sendAnywhere: any;
-    };
-    options: any;
-};
-import type { Denom } from '@agoric/orchestration';
-import type { DenomDetail } from '@agoric/orchestration';
-import type { Installation } from '@agoric/zoe/src/zoeService/utils.js';
-import type { CosmosChainInfo } from '@agoric/orchestration';
-//# sourceMappingURL=start-send-anywhere.d.ts.map

package/src/proposals/start-send-anywhere.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-send-anywhere.d.ts","sourceRoot":"","sources":["start-send-anywhere.js"],"names":[],"mappings":"AA2CO,6SAzBI,eAAe,GAAG;IACxB,YAAY,EAAE;QACZ,OAAO,EAAE;YACP,YAAY,EAAE;;;;;;;;;;;;;4BA6BM,CAAC;;;;;;;;;;;;;;;;;;;;;;eA7Bc,CAAC;SACrC,CAAC;KACH,CAAC;IACF,QAAQ,EAAE;QACR,OAAO,EAAE;YACP,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;SAClC,CAAC;KACH,CAAC;IACF,MAAM,EAAE;QACN,OAAO,EAAE;YACP,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YACnB,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;SACpB,CAAC;KACH,CAAC;CACH,yCACO;IACN,OAAO,EAAE;QACP,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QAC3C,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,EAAE,CAAC;KAC3D,CAAC;CACH,iBA2EH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BN;2BA1IqD,uBAAuB;iCAAvB,uBAAuB;kCAD9C,qCAAqC;qCACd,uBAAuB"}

package/src/proposals/start-stakeAtom.d.ts

@@ -1,142 +0,0 @@
-export function startStakeAtom({ consume: { agoricNames, board, chainStorage, chainTimerService: timer, cosmosInterchainService, startUpgradable, }, installation: { consume: { stakeIca }, }, instance: { produce: { stakeAtom: produceInstance }, }, }: BootstrapPowers & {
-    installation: {
-        consume: {
-            stakeIca: Installation<(zcf: ZCF<StakeIcaTerms>, privateArgs: {
-                agoricNames: import("@agoric/internal").Remote<import("@agoric/vats").NameHub>;
-                cosmosInterchainService: import("../types.js").CosmosInterchainService;
-                storageNode: StorageNode;
-                marshaller: Marshaller;
-                timer: import("@agoric/time").TimerService;
-            }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
-                publicFacet: import("@endo/exo").Guarded<{
-                    makeAccount(): Promise<import("@endo/exo").Guarded<{
-                        asContinuingOffer(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>;
-                        getPublicTopics(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<Record<string, import("@agoric/zoe/src/contractSupport/topics.js").ResolvedPublicTopic<unknown>>>>;
-                        getAddress(): import("@agoric/async-flow").HostInterface<import("../orchestration-api.js").ChainAddress>;
-                        delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
-                        redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
-                        withdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
-                        getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
-                        getBalances(): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
-                        send(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
-                        sendAll(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg[]): import("@agoric/vow").Vow<void>;
-                        transfer(destination: import("../orchestration-api.js").ChainAddress, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
-                        transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
-                        withdrawRewards(): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
-                        undelegate(delegations: {
-                            amount: import("../orchestration-api.js").AmountArg;
-                            delegator?: import("../orchestration-api.js").ChainAddress;
-                            validator: import("../cosmos-api.js").CosmosValidatorAddress;
-                        }[]): import("@agoric/vow").Vow<void>;
-                        deactivate(): import("@agoric/vow").Vow<void>;
-                        reactivate(): import("@agoric/vow").Vow<void>;
-                        getDelegation(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../cosmos-api.js").CosmosDelegationResponse>>;
-                        getDelegations(): import("@agoric/vow").Vow<{
-                            delegator: {
-                                chainId: string;
-                                value: string;
-                                encoding: "bech32" | "ethereum";
-                            };
-                            validator: {
-                                chainId: string;
-                                value: `${string}valoper${string}`;
-                                encoding: "bech32";
-                            };
-                            amount: {
-                                denom: import("../orchestration-api.js").Denom;
-                                value: bigint;
-                            };
-                        }[]>;
-                        getUnbondingDelegation(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").UnbondingDelegation>>;
-                        getUnbondingDelegations(): import("@agoric/vow").Vow<{
-                            delegatorAddress: string;
-                            validatorAddress: string;
-                            entries: {
-                                creationHeight: bigint;
-                                completionTime: {
-                                    seconds: bigint;
-                                    nanos: number;
-                                };
-                                initialBalance: string;
-                                balance: string;
-                            }[];
-                        }[]>;
-                        getRedelegations(): import("@agoric/vow").Vow<{
-                            redelegation: {
-                                delegatorAddress: string;
-                                validatorSrcAddress: string;
-                                validatorDstAddress: string;
-                                entries: {
-                                    creationHeight: bigint;
-                                    completionTime: {
-                                        seconds: bigint;
-                                        nanos: number;
-                                    };
-                                    initialBalance: string;
-                                    sharesDst: string;
-                                }[];
-                            };
-                            entries: {
-                                redelegationEntry: {
-                                    creationHeight: bigint;
-                                    completionTime: {
-                                        seconds: bigint;
-                                        nanos: number;
-                                    };
-                                    initialBalance: string;
-                                    sharesDst: string;
-                                };
-                                balance: string;
-                            }[];
-                        }[]>;
-                        getReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
-                        getRewards(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../cosmos-api.js").CosmosRewardsResponse>>;
-                        executeEncodedTx(msgs: {
-                            $typeUrl?: "/google.protobuf.Any" | string | undefined;
-                            typeUrl: string;
-                            value: string;
-                        }[], opts?: Partial<Omit<import("@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js").TxBody, "messages">> | undefined): import("@agoric/vow").Vow<string>;
-                    }>>;
-                    makeAccountInvitationMaker(): Promise<Invitation<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult, undefined>>;
-                }>;
-            }>>;
-        };
-    };
-}): Promise<void>;
-export function getManifestForStakeAtom({ restoreRef }: {
-    restoreRef: any;
-}, { installKeys, ...options }: {
-    [x: string]: any;
-    installKeys: any;
-}): {
-    manifest: {
-        [x: string]: {
-            consume: {
-                agoricNames: boolean;
-                board: boolean;
-                chainStorage: boolean;
-                chainTimerService: boolean;
-                cosmosInterchainService: boolean;
-                startUpgradable: boolean;
-            };
-            installation: {
-                consume: {
-                    stakeIca: boolean;
-                };
-            };
-            instance: {
-                produce: {
-                    stakeAtom: boolean;
-                };
-            };
-        };
-    };
-    installations: {
-        stakeIca: any;
-    };
-    options: {
-        [x: string]: any;
-    };
-};
-import type { StakeIcaTerms } from '../examples/stake-ica.contract';
-//# sourceMappingURL=start-stakeAtom.d.ts.map

package/src/proposals/start-stakeAtom.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-stakeAtom.d.ts","sourceRoot":"","sources":["start-stakeAtom.js"],"names":[],"mappings":"AAyBO,0PAVI,eAAe,GAAG;IACxB,YAAY,EAAE;QACZ,OAAO,EAAE;YACP,QAAQ,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA2D,CAClD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBA4DH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCAzG4C,gCAAgC"}