@bitgo/public-types 2.20.0 → 2.21.0

package/src/schema/transactions/coinSpecific.ts

@@ -0,0 +1,59 @@
+import * as t from "io-ts";
+import {
+  optionalStringOrNumber,
+  optionalString,
+  optionalNumber,
+  optionalStringArray,
+  optionalBoolean,
+  optionalUnknown,
+} from "../../utils";
+
+const BaseBuildParams = {
+  type: t.string,
+  nonce: optionalNumber,
+  memo: t.partial({
+    type: optionalString,
+    value: optionalString,
+  }),
+  comment: optionalString,
+  ledgerSequenceDelta: optionalNumber,
+  lastLedgerSequence: optionalNumber,
+  feeRate: optionalStringOrNumber,
+  messageKey: optionalString,
+  previewPendingTxs: optionalBoolean,
+  pendingApprovalId: optionalString,
+  sequenceId: optionalString,
+};
+
+const ConsolidateBuildParams = {
+  ...BaseBuildParams,
+  consolidateId: optionalString,
+  senderAddress: optionalString,
+};
+
+// Coin Specific Build Params
+export const CoinSpecificBuildParams = {
+  avaxp: {
+    locktime: optionalNumber,
+    sourceChain: optionalString,
+    destinationChain: optionalString,
+    unspents: optionalStringArray,
+  },
+  dot: {
+    ...ConsolidateBuildParams,
+    sequenceId: optionalString,
+    senderAddressIndex: optionalNumber,
+    nonce: optionalNumber,
+    proxyType: optionalString,
+    forceProxyType: optionalString,
+    owner: optionalUnknown,
+    delay: optionalUnknown,
+    index: optionalUnknown,
+    validityWindow: optionalUnknown,
+    version: optionalUnknown,
+    referenceBlock: optionalUnknown,
+  },
+  sol: {
+    tokenName: optionalString,
+  },
+};

package/src/schema/transactions/index.ts

@@ -0,0 +1 @@
+export * from "./sendTransactions";

package/src/schema/transactions/sendTransactions.ts

@@ -0,0 +1,245 @@
+import * as t from "io-ts";
+import {
+  Optional,
+  optionalString,
+  optionalBoolean,
+  optionalNumber,
+  optionalStringOrNumber,
+  optionalUnknown,
+} from "../../utils";
+import { CoinSpecificBuildParams } from "./coinSpecific";
+
+const recipient = t.partial({
+  address: t.string,
+  amount: t.union([t.string, t.number]),
+  feeLimit: optionalString,
+  data: optionalString,
+  memo: optionalString,
+  tokenName: optionalString,
+});
+export type TransactionRecipient = t.TypeOf<typeof recipient>;
+const recipients = t.array(recipient);
+
+const eip1559 = t.partial({
+  maxPriorityFeePerGas: optionalString,
+  maxFeePerGas: optionalString,
+});
+
+const lightningPaymentRequest = t.intersection([
+  t.type({
+    invoice: t.string,
+  }),
+  t.partial({
+    amount: t.number,
+    sequenceId: t.string,
+    feeLimit: t.number,
+    feeLimitRatio: t.number,
+  }),
+]);
+export type LightningPaymentRequest = t.TypeOf<typeof lightningPaymentRequest>;
+
+const halfSigned = t.partial({
+  txHex: optionalString,
+  recipients: Optional(recipients),
+  eip1559: Optional(eip1559),
+  isBatch: optionalBoolean,
+  expireTime: optionalNumber,
+  contractSequenceId: optionalNumber,
+  nextContractSequenceId: optionalNumber,
+  operationHash: optionalString,
+  signedChildPsbt: optionalString,
+  signature: optionalString,
+  lightningPaymentRequest: Optional(lightningPaymentRequest),
+});
+export type HalfSignedTransaction = t.TypeOf<typeof halfSigned>;
+
+export const memo = t.partial({
+  type: optionalString,
+  value: optionalString,
+});
+
+const feeOptions = {
+  amount: optionalStringOrNumber,
+  unit: Optional(
+    t.union([t.literal("baseUnit"), t.literal("cpu"), t.literal("ram")]),
+  ),
+  formula: Optional(
+    t.union([
+      t.literal("fixed"),
+      t.literal("feeRate"),
+      t.literal("perKB"),
+      t.literal("custom"),
+    ]),
+  ),
+  type: Optional(
+    t.union([t.literal("base"), t.literal("max"), t.literal("tip")]),
+  ),
+};
+
+export const txSendBody = {
+  comment: optionalString,
+  consolidateId: optionalString,
+  halfSigned: Optional(halfSigned),
+  invoice: optionalString,
+  memo: Optional(memo),
+  otp: optionalString,
+  recipients: Optional(recipients),
+  suppressBroadcast: optionalBoolean,
+  txHex: optionalString,
+  txRequestId: optionalString,
+  videoApprovers: Optional(t.array(t.string)),
+
+  numBlocks: optionalNumber,
+  feeRate: optionalNumber,
+  maxFeeRate: optionalNumber,
+  minConfirms: optionalNumber,
+  enforceMinConfirmsForChange: optionalBoolean,
+  targetWalletUnspents: optionalNumber,
+  message: optionalString,
+  minValue: optionalStringOrNumber,
+  maxValue: optionalStringOrNumber,
+  sequenceId: optionalStringOrNumber,
+  lastLedgerSequence: optionalNumber,
+  ledgerSequenceDelta: optionalNumber,
+  gasPrice: optionalNumber,
+  noSplitChange: optionalBoolean,
+  unspents: t.array(t.string),
+  changeAddress: optionalString,
+  instant: optionalBoolean,
+  transferId: optionalNumber,
+  gasLimit: optionalNumber,
+  custodianTransactionId: optionalString,
+
+  cpfpTxIds: Optional(t.array(t.string)),
+  cpfpFeeRate: optionalNumber,
+  noCpfpFeeRate: optionalBoolean,
+  maxFee: optionalNumber,
+  noMaxFee: optionalBoolean,
+
+  /// all other props from wp whitelist
+  feeMultiplier: optionalNumber,
+  addressType: optionalString,
+  changeAddressType: optionalString,
+  strategy: optionalString,
+  strategyAllowFallback: optionalBoolean,
+  fee: t.union([optionalString, t.partial(feeOptions)]),
+  timeBounds: Optional(
+    t.partial({
+      minTime: optionalStringOrNumber,
+      maxTime: optionalStringOrNumber,
+    }),
+  ),
+  idfSignedTimestamp: optionalString,
+  idfVersion: optionalNumber,
+  idfUserId: optionalString,
+  hopParams: t.partial({
+    gasPriceMax: optionalNumber,
+    paymentId: optionalString,
+    userReqSig: optionalString,
+  }),
+  validFromBlock: optionalNumber,
+  validToBlock: optionalNumber,
+  type: optionalString,
+  trustlines: t.partial({
+    token: optionalString,
+    action: optionalString,
+    limit: optionalString,
+  }),
+  reservation: t.partial({
+    expireTime: optionalString,
+    pendingApprovalId: optionalString,
+  }),
+  delayMs: optionalNumber,
+  messageKey: optionalString,
+  senderAddress: optionalString,
+  startTime: optionalString,
+  nonParticipation: optionalBoolean,
+  keyregTxBase64: optionalString,
+  closeRemainderTo: optionalString,
+  stateProofKey: optionalString,
+  contractName: optionalString,
+  functionName: optionalString,
+  eip1559: Optional(eip1559),
+  maxChangeOutputs: optionalNumber,
+  smallestChangeSplitSize: optionalNumber,
+  emergency: optionalBoolean,
+  sourceChain: optionalString,
+  destinationChain: optionalString,
+  txFormat: optionalString,
+  previewPendingTxs: optionalBoolean,
+  pendingApprovalId: optionalString,
+  stakingOptions: optionalUnknown,
+  unstakingOptions: optionalUnknown,
+  refundOptions: optionalUnknown,
+  stakingParams: t.partial({
+    actionType: optionalString,
+    validator: optionalString,
+    coin: optionalString,
+    amount: optionalString,
+  }),
+  isReplaceableByFee: optionalBoolean,
+  rbfTxIds: Optional(t.array(t.string)),
+};
+
+export const TxSendBody = t.exact(
+  t.intersection([
+    t.partial(txSendBody, "TxSendBody"),
+    t.partial(CoinSpecificBuildParams.avaxp),
+    t.partial(CoinSpecificBuildParams.dot),
+    t.partial(CoinSpecificBuildParams.sol),
+  ]),
+);
+export type TxSendBody = t.TypeOf<typeof TxSendBody>;
+
+const entry = t.partial({
+  address: t.string,
+  wallet: t.string,
+  value: t.number,
+  valueString: t.string,
+  isChange: t.boolean,
+  isPayGo: t.boolean,
+});
+const historyItem = t.partial({
+  date: t.string,
+  action: t.string,
+  user: t.string,
+});
+
+export const TxSendResponse = t.partial({
+  baseValue: t.number,
+  baseValueString: t.string,
+  coin: t.string,
+  coinSpecific: t.record(t.string, t.unknown),
+  createdTime: t.string,
+  date: t.string,
+  enterprise: t.string,
+  entries: t.array(entry),
+  feeString: t.string,
+  height: t.number,
+  heightId: t.string,
+  history: t.array(historyItem),
+  id: t.string,
+  instant: t.boolean,
+  intendedValueString: t.string,
+  isFee: t.boolean,
+  isReward: t.boolean,
+  metadata: t.record(t.string, t.unknown),
+  payGoFee: t.number,
+  payGoFeeString: t.string,
+  signedDate: t.string,
+  signedTime: t.string,
+  state: t.string,
+  tags: t.array(t.string),
+  txid: t.string,
+  txidType: t.string,
+  txRequestId: t.string,
+  type: t.string,
+  usd: t.number,
+  usdRate: t.number,
+  value: t.number,
+  valueString: t.string,
+  vSize: t.number,
+  wallet: t.string,
+  walletType: t.string,
+});
+export type TxSendResponse = t.TypeOf<typeof TxSendResponse>;

package/src/schema/wallet/index.ts

@@ -0,0 +1 @@
+export * from "./wallet";

package/src/schema/wallet/wallet.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+
+export const WalletUser = t.type({
+  user: t.string,
+  permissions: t.array(t.string),
+});
+
+export type WalletUser = t.TypeOf<typeof WalletUser>;

package/src/schema/webhook/addWalletWebhookRequest.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+import { NonEmptyString, NumberFromString } from "io-ts-types";
+import { Optional } from "../../utils/optional";
+import { TransactionRequestState } from "../transactionRequest/transactionRequestState";
+import { TransactionState } from "../transactionRequest/transactionState";
+import { WalletWebhookType } from "./webhookType";
+
+export const AddWalletWebhookRequestBody = {
+  type: WalletWebhookType,
+  url: NonEmptyString,
+  label: Optional(t.string),
+  numConfirmations: t.union([t.number, NumberFromString, t.undefined]),
+  allToken: Optional(t.boolean),
+  listenToFailureStates: Optional(t.boolean),
+  txRequestStates: Optional(t.array(TransactionRequestState)),
+  txRequestTransactionStates: Optional(t.array(TransactionState)),
+};
+export const AddWalletWebhookRequestBodyC = t.type({
+  ...AddWalletWebhookRequestBody,
+});
+
+export type AddWalletWebhookRequestBody = t.TypeOf<
+  typeof AddWalletWebhookRequestBodyC
+>;

package/src/schema/webhook/enterpriseWebhooks.ts

@@ -0,0 +1,44 @@
+import { EnterpriseWebhookType } from "./webhookType";
+import { NonEmptyString } from "io-ts-types";
+import { Optional, optionalString, optionalStringOrNumber } from "../../utils";
+import * as t from "io-ts";
+import { Webhook } from "./webhook";
+
+export const AddEnterpriseWebhookRequestBody = {
+  type: EnterpriseWebhookType,
+  url: NonEmptyString,
+  label: Optional(t.string),
+};
+export const AddEnterpriseWebhookRequestBodyC = t.type({
+  ...AddEnterpriseWebhookRequestBody,
+});
+
+export type AddEnterpriseWebhookRequestBody = t.TypeOf<
+  typeof AddEnterpriseWebhookRequestBodyC
+>;
+
+export const ListEnterpriseWebhooksRequestBody = {
+  type: Optional(EnterpriseWebhookType),
+  limit: optionalStringOrNumber,
+  prevId: optionalString,
+};
+
+export const ListEnterpriseWebhooksRequestBodyC = t.type({
+  ...ListEnterpriseWebhooksRequestBody,
+});
+
+export type ListEnterpriseWebhooksRequestBody = t.TypeOf<
+  typeof ListEnterpriseWebhooksRequestBodyC
+>;
+
+export const ListEnterpriseWebhooksResponse = t.intersection([
+  t.type({
+    webhooks: t.array(Webhook),
+  }),
+  t.partial({
+    nextBatchPrevId: Optional(t.union([t.string, t.undefined])),
+  }),
+]);
+export type ListEnterpriseWebhooksResponse = t.TypeOf<
+  typeof ListEnterpriseWebhooksResponse
+>;

package/src/schema/webhook/index.ts

@@ -0,0 +1,7 @@
+export * from "./enterpriseWebhooks";
+export * from "./addWalletWebhookRequest";
+export * from "./webhook";
+export * from "./webhookNotification";
+export * from "./webhookScope";
+export * from "./webhookState";
+export * from "./webhookType";

package/src/schema/webhook/webhook.ts

@@ -0,0 +1,35 @@
+import * as t from "io-ts";
+import { DateFromISOString } from "io-ts-types";
+import { TransactionRequestState } from "../transactionRequest/transactionRequestState";
+import { TransactionState } from "../transactionRequest/transactionState";
+import { WebhookState } from "./webhookState";
+import { WebhookType } from "./webhookType";
+import { WebhookScope } from "./webhookScope";
+
+export const Webhook = t.intersection([
+  t.type({
+    id: t.string,
+    created: DateFromISOString,
+    coin: t.string,
+    url: t.string,
+    version: t.number,
+    state: WebhookState,
+    successiveFailedAttempts: t.number,
+    listenToFailureStates: t.boolean,
+  }),
+  t.partial({
+    label: t.string,
+    walletId: t.string,
+    enterpriseId: t.string,
+    organizationId: t.string,
+    scope: WebhookScope,
+    userId: t.string,
+    type: WebhookType,
+    numConfirmations: t.number,
+    lastAttempt: DateFromISOString,
+    failingSince: DateFromISOString,
+    allToken: t.boolean,
+    txRequestStates: t.array(TransactionRequestState),
+    txRequestTransactionStates: t.array(TransactionState),
+  }),
+]);

package/src/schema/webhook/webhookNotification.ts

@@ -0,0 +1,33 @@
+import * as t from "io-ts";
+import { DateFromISOString } from "io-ts-types";
+
+export const WebhookNotification = t.intersection([
+  t.type({
+    id: t.string,
+  }),
+  t.partial({
+    type: t.string,
+    wallet: t.string,
+    url: t.string,
+    hash: t.string,
+    coin: t.string,
+    coinChain: t.string,
+    transfer: t.string,
+    state: t.string,
+    simulation: t.boolean,
+    retries: t.number,
+    webhook: t.string,
+    updatedAt: DateFromISOString,
+    nextAttempt: DateFromISOString,
+    version: t.number,
+    allowBlockedHosts: t.boolean,
+    heightToConfirm: t.number,
+    payload: t.string,
+    response: t.partial({
+      code: t.unknown,
+      type: t.string,
+      body: t.string,
+      error: t.string,
+    }),
+  }),
+]);

package/src/schema/webhook/webhookScope.ts

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+
+export enum WebhookScopeEnum {
+  "wallet" = "wallet",
+  "enterprise" = "enterprise",
+  "organization" = "organization",
+}
+
+export const WebhookScope = t.keyof(WebhookScopeEnum, "WebhookScope");
+export type WebhookScope = t.TypeOf<typeof WebhookScope>;

package/src/schema/webhook/webhookState.ts

@@ -0,0 +1,9 @@
+import * as t from "io-ts";
+
+export enum WebhookStateEnum {
+  "active" = "active",
+  "suspended" = "suspended",
+}
+
+export const WebhookState = t.keyof(WebhookStateEnum, "WebhookState");
+export type WebhookState = t.TypeOf<typeof WebhookState>;

package/src/schema/webhook/webhookType.ts

@@ -0,0 +1,56 @@
+import * as t from "io-ts";
+
+export enum WebhookTypeEnum {
+  // Webhook for txRequest.state changes
+  "txRequest" = "txRequest",
+  // Webhook for any txRequest.transactions[].state changes
+  "txRequestTransaction" = "txRequestTransaction",
+  "transfer" = "transfer",
+  "transaction" = "transaction",
+  "transactionRemoved" = "transactionRemoved",
+  "transactionExpire" = "transactionExpire",
+  "pendingapproval" = "pendingapproval",
+  "block" = "block",
+  "admin" = "admin",
+  "address_confirmation" = "address_confirmation",
+  "lowFee" = "lowFee",
+
+  // Specific to User Webhooks
+  "wallet_confirmation" = "wallet_confirmation",
+
+  "wireWithdrawal" = "wireWithdrawal",
+  "bankAccount" = "bankAccount",
+}
+
+export const WebhookType = t.keyof(WebhookTypeEnum, "WebhookType");
+export type WebhookType = t.TypeOf<typeof WebhookType>;
+
+export enum WalletWebhookTypeEnum {
+  "txRequest" = "txRequest",
+  "txRequestTransaction" = "txRequestTransaction",
+  "transfer" = "transfer",
+  "transaction" = "transaction",
+  "transactionRemoved" = "transactionRemoved",
+  "transactionExpire" = "transactionExpire",
+  "pendingapproval" = "pendingapproval",
+  "block" = "block",
+  "admin" = "admin",
+  "address_confirmation" = "address_confirmation",
+  "lowFee" = "lowFee",
+  "wireWithdrawal" = "wireWithdrawal",
+}
+
+export const WalletWebhookType = t.keyof(
+  WalletWebhookTypeEnum,
+  "WalletWebhookType",
+);
+export type WalletWebhookType = t.TypeOf<typeof WalletWebhookType>;
+
+export enum EnterpriseWebhookTypeEnum {
+  "bankAccount" = "bankAccount",
+}
+export const EnterpriseWebhookType = t.keyof(
+  EnterpriseWebhookTypeEnum,
+  "EnterpriseWebhookType",
+);
+export type EnterpriseWebhookType = t.TypeOf<typeof EnterpriseWebhookType>;

package/src/utils/arrayFromSingle.ts

@@ -0,0 +1,19 @@
+import * as t from "io-ts";
+import { pipe } from "fp-ts/function";
+import { chain } from "fp-ts/lib/Either";
+
+export function arrayFromSingle<C extends t.Mixed>(
+  codec: C,
+  name: string = `ArrayFromSingle<${codec.name}>`,
+) {
+  return new t.Type(
+    name,
+    t.array(codec).is,
+    (u, c) =>
+      pipe(
+        codec.validate(u, c),
+        chain((as) => t.array(codec).validate([as], c)),
+      ),
+    t.identity,
+  );
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from "./optional";
+export * from "./primitives";
+export * from "./arrayFromSingle";
+export * from "./minMaxArray";

package/src/utils/minMaxArray.ts

@@ -0,0 +1,27 @@
+import * as t from "io-ts";
+
+export interface IMinMaxArray<T> extends Array<T> {
+  readonly minMaxArray: unique symbol;
+}
+
+/**
+ * A helper that creates an array codec that limits the length of the array between [min, max]
+ * @param codec
+ * @param {min, max}
+ */
+export const minMaxArray = <C extends t.Mixed>(
+  codec: C,
+  {
+    min,
+    max,
+  }: {
+    min?: number;
+    max?: number;
+  } = {},
+) =>
+  t.brand(
+    t.array(codec),
+    (n: C[]): n is t.Branded<C[], IMinMaxArray<C>> =>
+      (!min || min <= n.length) && (!max || n.length <= max),
+    "minMaxArray",
+  );

package/src/utils/optional.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+
+export function Optional<T>(type: t.Type<T>) {
+  return t.union([type, t.undefined]);
+}

package/src/utils/primitives.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { Optional } from "./optional";
+
+export const optionalString = Optional(t.string);
+export const optionalStringArray = Optional(t.array(t.string));
+export const optionalBoolean = Optional(t.boolean);
+export const optionalNumber = Optional(t.number);
+export const optionalStringOrNumber = Optional(t.union([t.string, t.number]));
+export const optionalUnknown = Optional(
+  t.intersection([t.unknown, t.partial({})]),
+);

package/dist/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/src/schema/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/src/schema/keyGen/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/schema/keyGen/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC"}

package/dist/src/schema/keyGen/keyGenState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keyGenState.d.ts","sourceRoot":"","sources":["../../../../src/schema/keyGen/keyGenState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAC3B,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAExE,eAAO,MAAM,eAAe;;;;CAE3B,CAAC;AACF,eAAO,MAAM,WAAW;;;;EAA2B,CAAC;AACpD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/src/schema/keyGen/keyGenType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keyGenType.d.ts","sourceRoot":"","sources":["../../../../src/schema/keyGen/keyGenType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAE3B,oBAAY,cAAc;IACxB,KAAK,UAAU;CAChB;AACD,eAAO,MAAM,UAAU,iCAA0B,CAAC;AAClD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/src/schema/mpcv2/common/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/schema/mpcv2/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gCAAgC,CAAC"}

package/dist/src/schema/mpcv2/common/mpcv2BroadcastMessage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mpcv2BroadcastMessage.d.ts","sourceRoot":"","sources":["../../../../../src/schema/mpcv2/common/mpcv2BroadcastMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAG3B,eAAO,MAAM,qBAAqB;;;;EAOjC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE3E,eAAO,MAAM,mCAAmC;;;;;;IAK9C,CAAC;AAEH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,MAAM,CACxD,OAAO,mCAAmC,CAC3C,CAAC"}

package/dist/src/schema/mpcv2/common/mpcv2P2PMessage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mpcv2P2PMessage.d.ts","sourceRoot":"","sources":["../../../../../src/schema/mpcv2/common/mpcv2P2PMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAG3B,eAAO,MAAM,eAAe;;;;;EAQ3B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/src/schema/mpcv2/common/mpcv2PartyFromStringOrNumber.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mpcv2PartyFromStringOrNumber.d.ts","sourceRoot":"","sources":["../../../../../src/schema/mpcv2/common/mpcv2PartyFromStringOrNumber.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAK3B,eAAO,MAAM,4BAA4B,yGAGxC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CACjD,OAAO,4BAA4B,CACpC,CAAC"}

package/dist/src/schema/mpcv2/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/schema/mpcv2/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}

package/dist/src/schema/mpcv2/keyGen/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/schema/mpcv2/keyGen/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC"}

package/dist/src/schema/mpcv2/keyGen/keygenRound.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keygenRound.d.ts","sourceRoot":"","sources":["../../../../../src/schema/mpcv2/keyGen/keygenRound.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAI3B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;EAKnC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,wBAAwB,CAChC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;EAKpC,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,yBAAyB,CACjC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;EAMnC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,wBAAwB,CAChC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAKpC,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,yBAAyB,CACjC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;EAMnC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,wBAAwB,CAChC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;EAIpC,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,yBAAyB,CACjC,CAAC"}

package/dist/src/schema/mpcv2/keyGen/mpcv2KeyGenState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mpcv2KeyGenState.d.ts","sourceRoot":"","sources":["../../../../../src/schema/mpcv2/keyGen/mpcv2KeyGenState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAE3B,oBAAY,oBAAoB;IAC9B,UAAU,aAAa;IACvB,UAAU,aAAa;IACvB,UAAU,aAAa;CACxB;AACD,eAAO,MAAM,gBAAgB,uCAG5B,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/src/schema/mpcv2/signing/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/schema/mpcv2/signing/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC"}