@agoric/internal 0.3.3-other-dev-8f8782b.0 → 0.3.3-other-dev-fbe72e7.0.fbe72e7

package/src/callback.js

@@ -1,38 +1,31 @@
 // @ts-check
+import { Fail, makeError, q } from '@endo/errors';
 import { E } from '@endo/far';
-import { isObject, isPassableSymbol } from '@endo/marshal';
+import { isPrimitive, isPassableSymbol } from '@endo/pass-style';
+import { getInterfaceMethodKeys } from '@endo/patterns';
 
-const { Fail, quote: q } = assert;
+/** @import {ERef} from '@endo/far' */
+/** @import {Callback, SyncCallback} from './types.js' */
 
 const { fromEntries } = Object;
 
 const { ownKeys: rawOwnKeys } = Reflect;
 const ownKeys =
-  /** @type {<T extends PropertyKey>(obj: {[K in T]?: unknown}) => T[]} */ (
+  /** @type {<T extends PropertyKey>(obj: { [K in T]?: unknown }) => T[]} */ (
     rawOwnKeys
   );
 
 /**
- * @template T
- * @typedef {(...args: Parameters<ReturnType<prepareAttenuator>>) => Farable<T>} MakeAttenuator
+ * @template {import('@endo/exo').Methods} T
+ * @typedef {(
+ *   ...args: Parameters<ReturnType<prepareAttenuator>>
+ * ) => import('@endo/exo').Farable<T>} MakeAttenuator
  */
 
-/**
- * @template {(...args: unknown[]) => any} I
- * @typedef {import('./types').Callback<I>} Callback
- */
-
-/**
- * @template {(...args: unknown[]) => any} I
- * @typedef {import('./types').SyncCallback<I>} SyncCallback
- */
-
-/** @template T @typedef {import('@endo/eventual-send').RemotableBrand<{}, T> & T} Farable */
-
 /**
  * @param {unknown} key
  * @returns {key is PropertyKey} FIXME: should be just `PropertyKey` but TS
- * complains it can't be used as an index type.
+ *   complains it can't be used as an index type.
  */
 const isPropertyKey = key => {
   switch (typeof key) {
@@ -48,7 +41,7 @@ const isPropertyKey = key => {
 /**
  * Synchronously call a callback.
  *
- * @template {(...args: unknown[]) => any} I
+ * @template {(...args: any[]) => any} I
  * @param {SyncCallback<I>} callback
  * @param {Parameters<I>} args
  * @returns {ReturnType<I>}
@@ -65,7 +58,7 @@ harden(callSync);
 /**
  * Eventual send to a callback.
  *
- * @template {(...args: unknown[]) => any} I
+ * @template {(...args: any[]) => any} I
  * @param {Callback<I>} callback
  * @param {Parameters<I>} args
  * @returns {Promise<Awaited<ReturnType<I>>>}
@@ -82,9 +75,9 @@ harden(callE);
 /**
  * Create a callback from a near function.
  *
- * @template {(...args: unknown[]) => any} I
+ * @template {(...args: any[]) => any} I
  * @template {(...args: [...B, ...Parameters<I>]) => ReturnType<I>} [T=I]
- * @template {unknown[]} [B=[]]
+ * @template {any[]} [B=[]]
  * @param {T} target
  * @param {B} bound
  * @returns {SyncCallback<I>}
@@ -101,17 +94,15 @@ harden(makeSyncFunctionCallback);
 /**
  * Create a callback from a potentially far function.
  *
- * @template {(...args: unknown[]) => any} I
- * @template {import('@endo/far').ERef<
- *   (...args: [...B, ...Parameters<I>]) => ReturnType<I>
- * >} [T=import('@endo/far').ERef<I>]
- * @template {unknown[]} [B=[]]
+ * @template {(...args: any[]) => any} I
+ * @template {ERef<(...args: [...B, ...Parameters<I>]) => ReturnType<I>>} [T=ERef<I>]
+ * @template {any[]} [B=[]]
  * @param {T} target
  * @param {B} bound
  * @returns {Callback<I>}
  */
 export const makeFunctionCallback = (target, ...bound) => {
-  isObject(target) ||
+  !isPrimitive(target) ||
     Fail`function callback target must be a function presence: ${target}`;
   /** @type {unknown} */
   const cb = harden({ target, bound });
@@ -122,19 +113,19 @@ harden(makeFunctionCallback);
 /**
  * Create a callback from a near method.
  *
- * @template {(...args: unknown[]) => any} I
+ * @template {(...args: any[]) => any} I
  * @template {PropertyKey} P
  * @template {{
- *   [x in P]: (...args: [...B, ...Parameters<I>]) => ReturnType<I>
+ *   [x in P]: (...args: [...B, ...Parameters<I>]) => ReturnType<I>;
  * }} [T={ [x in P]: I }]
- * @template {unknown[]} [B=[]]
+ * @template {any[]} [B=[]]
  * @param {T} target
  * @param {P} methodName
  * @param {B} bound
  * @returns {SyncCallback<I>}
  */
 export const makeSyncMethodCallback = (target, methodName, ...bound) => {
-  isObject(target) ||
+  !isPrimitive(target) ||
     Fail`sync method callback target must be an object: ${target}`;
   typeof methodName === 'string' ||
     isPassableSymbol(methodName) ||
@@ -148,19 +139,20 @@ harden(makeSyncMethodCallback);
 /**
  * Create a callback from a potentially far method.
  *
- * @template {(...args: unknown[]) => any} I
+ * @template {(...args: any[]) => any} I
  * @template {PropertyKey} P
- * @template {import('@endo/far').ERef<{
- *   [x in P]: (...args: [...B, ...Parameters<I>]) => ReturnType<I>
- * }>} [T=import('@endo/far').ERef<{ [x in P]: I }>]
- * @template {unknown[]} [B=[]]
+ * @template {ERef<{
+ *   [x in P]: (...args: [...B, ...Parameters<I>]) => ReturnType<I>;
+ * }>} [T=ERef<{ [x in P]: I }>]
+ * @template {any[]} [B=[]]
  * @param {T} target
  * @param {P} methodName
  * @param {B} bound
  * @returns {Callback<I>}
  */
 export const makeMethodCallback = (target, methodName, ...bound) => {
-  isObject(target) || Fail`method callback target must be an object: ${target}`;
+  !isPrimitive(target) ||
+    Fail`method callback target must be an object: ${target}`;
   typeof methodName === 'string' ||
     isPassableSymbol(methodName) ||
     Fail`method name must be a string or passable symbol: ${methodName}`;
@@ -175,12 +167,12 @@ harden(makeMethodCallback);
  * @returns {callback is Callback<any>}
  */
 export const isCallback = callback => {
-  if (!isObject(callback)) {
+  if (isPrimitive(callback)) {
     return false;
   }
   const { target, methodName, bound } = callback;
   return (
-    isObject(target) &&
+    !isPrimitive(target) &&
     (methodName === undefined ||
       typeof methodName === 'string' ||
       isPassableSymbol(methodName)) &&
@@ -193,11 +185,14 @@ harden(isCallback);
  * Prepare an attenuator class whose methods can be redirected via callbacks.
  *
  * @template {PropertyKey} M
- * @param {import('@agoric/zone').Zone} zone The zone in which to allocate attenuators.
+ * @param {import('@agoric/base-zone').Zone} zone The zone in which to allocate
+ *   attenuators.
  * @param {M[]} methodNames Methods to forward.
  * @param {object} opts
- * @param {InterfaceGuard} [opts.interfaceGuard] An interface guard for the
- * new attenuator.
+ * @param {import('@endo/patterns').InterfaceGuard<{
+ *   [K in M]: import('@endo/patterns').MethodGuard;
+ * }>} [opts.interfaceGuard]
+ *   An interface guard for the new attenuator.
  * @param {string} [opts.tag] A tag for the new attenuator exoClass.
  */
 export const prepareAttenuator = (
@@ -206,9 +201,11 @@ export const prepareAttenuator = (
   { interfaceGuard, tag = 'Attenuator' } = {},
 ) => {
   /**
-   * @typedef {(this: any, ...args: unknown[]) => any} Method
-   * @typedef {{ [K in M]?: Callback<any> | null}} Overrides
-   * @typedef {{ [K in M]: (this: any, ...args: unknown[]) => any }} Methods
+   * @typedef {(this: any, ...args: any[]) => any} Method
+   *
+   * @typedef {{ [K in M]?: Callback<any> | null }} Overrides
+   *
+   * @typedef {{ [K in M]: (this: any, ...args: any[]) => any }} Methods
    */
   const methods = /** @type {Methods} */ (
     fromEntries(
@@ -226,9 +223,7 @@ export const prepareAttenuator = (
             // Support both synchronous and async callbacks.
             const cb = this.state.cbs[key];
             if (!cb) {
-              const err = assert.error(
-                `unimplemented ${q(tag)} method ${q(key)}`,
-              );
+              const err = makeError(`unimplemented ${q(tag)} method ${q(key)}`);
               if (this.state.isSync) {
                 throw err;
               }
@@ -250,14 +245,13 @@ export const prepareAttenuator = (
    * and/or individual method override callbacks.
    *
    * @param {object} opts
-   * @param {unknown} [opts.target] The target for any methods that
-   * weren't specified in `opts.overrides`.
+   * @param {unknown} [opts.target] The target for any methods that weren't
+   *   specified in `opts.overrides`.
    * @param {boolean} [opts.isSync=false] Whether the target should be treated
-   * as synchronously available.
-   * @param {Overrides} [opts.overrides] Set individual
-   * callbacks for methods (whose names must be defined in the
-   * `prepareAttenuator` or `prepareGuardedAttenuator` call).  Nullish overrides
-   * mean to throw.
+   *   as synchronously available.
+   * @param {Overrides} [opts.overrides] Set individual callbacks for methods
+   *   (whose names must be defined in the `prepareAttenuator` or
+   *   `prepareGuardedAttenuator` call). Nullish overrides mean to throw.
    */
   const makeAttenuator = zone.exoClass(
     tag,
@@ -265,7 +259,7 @@ export const prepareAttenuator = (
     /**
      * @param {object} opts
      * @param {any} [opts.target]
-     * @param {boolean} [opts.isSync=false]
+     * @param {boolean} [opts.isSync]
      * @param {Overrides} [opts.overrides]
      */
     ({
@@ -305,14 +299,14 @@ harden(prepareAttenuator);
 /**
  * Prepare an attenuator whose methodNames are derived from the interfaceGuard.
  *
- * @param {import('@agoric/zone').Zone} zone
- * @param {InterfaceGuard} interfaceGuard
+ * @template {import('@endo/patterns').InterfaceGuard} G
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {G} interfaceGuard
  * @param {object} [opts]
  * @param {string} [opts.tag]
  */
 export const prepareGuardedAttenuator = (zone, interfaceGuard, opts = {}) => {
-  const { methodGuards } = interfaceGuard;
-  const methodNames = ownKeys(methodGuards);
+  const methodNames = getInterfaceMethodKeys(interfaceGuard);
   const makeAttenuator = prepareAttenuator(zone, methodNames, {
     ...opts,
     interfaceGuard,

package/src/chain-storage-paths.d.ts

@@ -1,7 +1,6 @@
 /**
- * These identify top-level paths for SwingSet chain storage
- * (and serve as prefixes).
- * To avoid collisions, they should remain synchronized with
+ * These identify top-level paths for SwingSet chain storage (and serve as
+ * prefixes). To avoid collisions, they should remain synchronized with
  * golang/cosmos/x/swingset/keeper/keeper.go
  */
 export const ACTION_QUEUE: "actionQueue";

package/src/chain-storage-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain-storage-paths.d.ts","sourceRoot":"","sources":["chain-storage-paths.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,yCAA0C;AAC1C,sDAAuD;AACvD,0DAA2D;AAC3D,sCAAuC;AACvC,8BAA+B;AAC/B,gCAAiC;AACjC,gCAAiC;AACjC,iCAAkC;AAClC,uCAAwC"}
+{"version":3,"file":"chain-storage-paths.d.ts","sourceRoot":"","sources":["chain-storage-paths.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,2BAA4B,aAAa,CAAC;AAC1C,kCAAmC,mBAAmB,CAAC;AACvD,oCAAqC,qBAAqB,CAAC;AAC3D,yBAA0B,YAAY,CAAC;AACvC,qBAAsB,QAAQ,CAAC;AAC/B,sBAAuB,SAAS,CAAC;AACjC,sBAAuB,SAAS,CAAC;AACjC,qBAAsB,WAAW,CAAC;AAClC,0BAA2B,YAAY,CAAC"}

package/src/chain-storage-paths.js

@@ -1,9 +1,8 @@
 // @jessie-check
 
 /**
- * These identify top-level paths for SwingSet chain storage
- * (and serve as prefixes).
- * To avoid collisions, they should remain synchronized with
+ * These identify top-level paths for SwingSet chain storage (and serve as
+ * prefixes). To avoid collisions, they should remain synchronized with
  * golang/cosmos/x/swingset/keeper/keeper.go
  */
 export const ACTION_QUEUE = 'actionQueue';

package/src/chain-utils.d.ts

@@ -0,0 +1,27 @@
+export function makeInitMsg(initAction: any): InitMsg;
+export type NatString = `${bigint}`;
+export type BlockInfo = {
+    blockHeight: number;
+    /**
+     * POSIX Seconds Since the Epoch
+     */
+    blockTime: number;
+    params: JsonSafe<ParamsSDKType>;
+};
+/**
+ * cosmosInitAction fields that are subject to consensus. See cosmosInitAction
+ * in {@link  ../../../golang/cosmos/app/app.go}.
+ */
+export type InitMsg = BlockInfo & {
+    type: typeof _ActionType.AG_COSMOS_INIT;
+    chainID: string;
+    isBootstrap?: boolean;
+    supplyCoins: {
+        denom: string;
+        amount: NatString;
+    }[];
+};
+import type { ParamsSDKType } from '@agoric/cosmic-proto/swingset/swingset.js';
+import type { JsonSafe } from '@agoric/cosmic-proto/json-safe';
+import * as _ActionType from './action-types.js';
+//# sourceMappingURL=chain-utils.d.ts.map

package/src/chain-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-utils.d.ts","sourceRoot":"","sources":["chain-utils.js"],"names":[],"mappings":"AA2CO,wCAHI,GAAG,GACD,OAAO,CAoBnB;wBA/Ca,GAAG,MAAM,EAAE;;iBASX,MAAM;;;;eACN,MAAM;YACN,SAAS,aAAa,CAAC;;;;;;sBAIxB,SAAS,GAAG;IACpB,IAAI,EAAE,OAAO,WAAW,CAAC,cAAc,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,SAAS,CAAA;KAAE,EAAE,CAAC;CACrD;mCAjB4B,2CAA2C;8BAChD,gCAAgC;6BAN9B,mBAAmB"}

package/src/chain-utils.js

@@ -0,0 +1,62 @@
+/**
+ * @file Types and utilities for supporting blockchain functionality without
+ *   risking import cycles.
+ *
+ *   TODO: Integrate (or integrate with) any/all of:
+ *
+ *   - ./action-types.js
+ *   - ./chain-storage-paths.js
+ *   - ./config.js
+ *   - ../../cosmic-proto (if comfortable co-residing with generated code)
+ */
+
+import * as _ActionType from './action-types.js';
+
+/** @typedef {`${bigint}`} NatString */
+
+/**
+ * @import {ParamsSDKType} from '@agoric/cosmic-proto/swingset/swingset.js'
+ * @import {JsonSafe} from '@agoric/cosmic-proto/json-safe'
+ */
+
+/**
+ * @typedef {object} BlockInfo
+ * @property {number} blockHeight
+ * @property {number} blockTime POSIX Seconds Since the Epoch
+ * @property {JsonSafe<ParamsSDKType>} params
+ */
+
+/**
+ * @typedef {BlockInfo & {
+ *   type: typeof _ActionType.AG_COSMOS_INIT;
+ *   chainID: string;
+ *   isBootstrap?: boolean;
+ *   supplyCoins: { denom: string; amount: NatString }[];
+ * }} InitMsg
+ *   cosmosInitAction fields that are subject to consensus. See cosmosInitAction
+ *   in {@link ../../../golang/cosmos/app/app.go}.
+ */
+
+/**
+ * @param {any} initAction
+ * @returns {InitMsg}
+ */
+export const makeInitMsg = initAction => {
+  const {
+    type,
+    blockHeight,
+    blockTime,
+    chainID,
+    params,
+    // NB: resolvedConfig is independent of consensus and MUST NOT be included
+    supplyCoins,
+  } = initAction;
+  return {
+    type,
+    blockHeight,
+    blockTime,
+    chainID,
+    params,
+    supplyCoins,
+  };
+};

package/src/cli-utils.d.ts

@@ -0,0 +1,2 @@
+export function toCLIOptions(record: Record<string, undefined | boolean | string | string[]>): string[];
+//# sourceMappingURL=cli-utils.d.ts.map

package/src/cli-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-utils.d.ts","sourceRoot":"","sources":["cli-utils.js"],"names":[],"mappings":"AAUO,qCAJI,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC,GAErD,MAAM,EAAE,CAYjB"}

package/src/cli-utils.js

@@ -0,0 +1,21 @@
+/**
+ * Convert a string-keyed object into an array of CLI options, using each key as
+ * the name of a GNU-style long option `--${key}`, ignoring each key with an
+ * undefined value and converting boolean values into no-argument `--${key}` or
+ * `--no-${key}` options.
+ *
+ * @param {Record<string, undefined | boolean | string | string[]>} record -
+ *   e.g. { color: 'blue' }
+ * @returns {string[]} - e.g. ['--color', 'blue']
+ */
+export const toCLIOptions = record =>
+  Object.entries(record).flatMap(([key, value]) => {
+    if (value === undefined) return [];
+    if (value === true) return [`--${key}`];
+    if (value === false) return [`--no-${key}`];
+    if (Array.isArray(value)) {
+      // Represent as a repeated option.
+      return value.flatMap(v => [`--${key}`, v]);
+    }
+    return [`--${key}`, value];
+  });

package/src/config.d.ts

@@ -1,24 +1,34 @@
+/**
+ * Event source ids used by the bridge device.
+ */
+export type BridgeId = (typeof BridgeId)[keyof typeof BridgeId];
 export namespace BridgeId {
-    const BANK: string;
-    const CORE: string;
-    const DIBC: string;
-    const STORAGE: string;
-    const PROVISION: string;
-    const PROVISION_SMART_WALLET: string;
-    const WALLET: string;
+    let BANK: "bank";
+    let CORE: "core";
+    let DIBC: "dibc";
+    let STORAGE: "storage";
+    let PROVISION: "provision";
+    let PROVISION_SMART_WALLET: "provisionWallet";
+    let VLOCALCHAIN: "vlocalchain";
+    let VTRANSFER: "vtransfer";
+    let WALLET: "wallet";
+}
+export namespace CosmosInitKeyToBridgeId {
+    let vbankPort: "bank";
+    let vibcPort: "dibc";
 }
 export namespace WalletName {
-    const depositFacet: string;
+    let depositFacet: "depositFacet";
 }
 export namespace VBankAccount {
     namespace reserve {
-        const module: string;
-        const address: string;
+        let module: "vbank/reserve";
+        let address: "agoric1ae0lmtzlgrcnla9xjkpaarq5d5dfez63h3nucl";
     }
     namespace provision {
-        const module_1: string;
+        let module_1: "vbank/provision";
         export { module_1 as module };
-        const address_1: string;
+        let address_1: "agoric1megzytg65cyrgzs6fvzxgrcqvwwl7ugpt62346";
         export { address_1 as address };
     }
 }

package/src/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["config.js"],"names":[],"mappings":""}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["config.js"],"names":[],"mappings":";;;uBAkBU,CAAC,OAAO,QAAQ,EAAE,MAAM,OAAO,QAAQ,CAAC"}

package/src/config.js

@@ -4,34 +4,47 @@
 /**
  * @file
  *
- * Some of this config info may make more sense in a particular package. However
- * due to https://github.com/Agoric/agoric-sdk/issues/4620 and our lax package
- * dependency graph, sometimes rational placements cause type resolution errors.
+ *   Some of this config info may make more sense in a particular package. However
+ *   due to https://github.com/Agoric/agoric-sdk/issues/4620 and our lax package
+ *   dependency graph, sometimes rational placements cause type resolution
+ *   errors.
  *
- * So as a work-around some constants that need access from more than one package are placed here.
+ *   So as a work-around some constants that need access from more than one
+ *   package are placed here.
  */
 
 /**
  * Event source ids used by the bridge device.
+ *
+ * @enum {(typeof BridgeId)[keyof typeof BridgeId]}
  */
-export const BridgeId = {
+export const BridgeId = /** @type {const} */ ({
   BANK: 'bank',
   CORE: 'core',
   DIBC: 'dibc',
   STORAGE: 'storage',
   PROVISION: 'provision',
   PROVISION_SMART_WALLET: 'provisionWallet',
+  VLOCALCHAIN: 'vlocalchain',
+  VTRANSFER: 'vtransfer',
   WALLET: 'wallet',
-};
+});
 harden(BridgeId);
 
-export const WalletName = {
-  depositFacet: 'depositFacet',
+/** @satisfies {Record<string, BridgeId>} */
+export const CosmosInitKeyToBridgeId = {
+  vbankPort: 'bank',
+  vibcPort: 'dibc',
 };
+harden(CosmosInitKeyToBridgeId);
+
+export const WalletName = /** @type {const} */ ({
+  depositFacet: 'depositFacet',
+});
 harden(WalletName);
 
 // defined in golang/cosmos/x/vbank
-export const VBankAccount = {
+export const VBankAccount = /** @type {const} */ ({
   reserve: {
     module: 'vbank/reserve',
     address: 'agoric1ae0lmtzlgrcnla9xjkpaarq5d5dfez63h3nucl',
@@ -40,5 +53,5 @@ export const VBankAccount = {
     module: 'vbank/provision',
     address: 'agoric1megzytg65cyrgzs6fvzxgrcqvwwl7ugpt62346',
   },
-};
+});
 harden(VBankAccount);

package/src/debug.d.ts

@@ -1,2 +1,2 @@
-export function makeTracer(name: string, enable?: boolean | 'verbose'): (..._args: any[]) => void;
+export function makeTracer(name: string, enable?: boolean | "verbose"): (..._args: any[]) => void;
 //# sourceMappingURL=debug.d.ts.map

package/src/errors.d.ts

@@ -0,0 +1,2 @@
+export function NonNullish<T>(val: T | null | undefined, optDetails?: string): T;
+//# sourceMappingURL=errors.d.ts.map

package/src/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["errors.js"],"names":[],"mappings":"AAQO,2BALM,CAAC,OACH,CAAC,GAAG,IAAI,GAAG,SAAS,eACpB,MAAM,GACJ,CAAC,CAQb"}

package/src/errors.js

@@ -0,0 +1,16 @@
+import { q } from '@endo/errors';
+
+/**
+ * @template T
+ * @param {T | null | undefined} val
+ * @param {string} [optDetails]
+ * @returns {T}
+ */
+export const NonNullish = (val, optDetails = `unexpected ${q(val)}`) => {
+  if (val != null) {
+    // This `!= null` idiom checks that `val` is neither `null` nor `undefined`.
+    return val;
+  }
+  assert.fail(optDetails);
+};
+harden(NonNullish);

package/src/hex.d.ts

@@ -0,0 +1,15 @@
+export function makePortableHexCodec(): HexCodec;
+export function makeBufferishHexCodec(Bufferish: BufferishConstructor): HexCodec;
+export const encodeHex: (buf: Uint8Array) => string;
+export const decodeHex: (hex: string) => Uint8Array;
+export type HexCodec = {
+    encodeHex: (buf: Uint8Array) => string;
+    decodeHex: (hex: string) => Uint8Array;
+};
+/**
+ * is the portion of the Node.js Buffer API we need for hex conversion.
+ */
+export type BufferishConstructor = Pick<BufferConstructor, "from" | "isBuffer"> & {
+    prototype: Pick<Buffer, "toString"> & Uint8Array;
+};
+//# sourceMappingURL=hex.d.ts.map

package/src/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["hex.js"],"names":[],"mappings":"AAsCO,wCAFM,QAAQ,CAyBpB;AAgBM,iDAJI,oBAAoB,GAElB,QAAQ,CAoBpB;8BA7FmB,UAAU,KAAK,MAAM;8BACrB,MAAM,KAAK,UAAU;;eAD3B,CAAC,GAAG,EAAE,UAAU,KAAK,MAAM;eAC3B,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU;;;;;mCA6D5B,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,UAAU,CAAC,GAAG;IACvD,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,UAAU,CAAC;CAClD"}