@bitgo/public-types 5.96.2 → 6.0.0

package/src/schema/transactionRequest/intents/solCloseAssociatedTokenAccountIntent.ts

@@ -1,21 +1,110 @@
 import * as t from "io-ts";
+import type { Address } from "./address";
 import { BaseIntent } from "./baseIntent";
 import { intentTypes } from "./intentType";
+import { RecipientEntry } from "./recipientEntry";
 import { SolBuildOptions } from "./solBuildOptions";
 
+/**
+ * One close-ATA recipient row: ATA in `address.address`, zero placeholder amount,
+ * no token payload. Narrower than {@link RecipientEntry} for compile-time use
+ * when you annotate with this type after a successful decode.
+ *
+ * **Address typing:** {@link Address} is `t.partial` in io-ts, so
+ * `t.TypeOf<typeof RecipientEntry>["address"]` still allows a missing inner
+ * `address`. The refinement rejects non-strings at **runtime**, but io-ts does
+ * not narrow `TypeOf` on refinements—so `decode(...).right` alone will not show
+ * `address.address` as required. Use this named type (via
+ * {@link SolCloseAssociatedTokenAccountIntent}) for the stricter contract; do
+ * not widen back to plain `t.TypeOf<typeof SolCloseAssociatedTokenAccountIntent>`
+ * if you need the guarantee on `address.address`.
+ *
+ * `amount.value` must be the **exact string** `"0"`. The refinement uses string
+ * equality (not numeric parsing), so `"0.0"`, `"0.00"`, `"00"`, `"-0"`, `"0x0"`,
+ * etc. are rejected. Construct close-ATA placeholders with the literal `"0"`.
+ *
+ * `amount.symbol` follows {@link RecipientEntry} / `Amount`: any string
+ * (including `""`); it is not validated as a ticker and is ignored for asset extraction.
+ */
+export type SolCloseAssociatedTokenAccountRecipient = {
+  // Intersection tightens Address.address from string | undefined to required string.
+  address: Address & { address: string };
+  amount: { value: "0"; symbol: string };
+  /**
+   * Matches {@link RecipientEntry} / `optionalString` (`string | undefined`).
+   * Note: the underlying codec is `t.partial({ data: optionalString })`, so the
+   * key may also be absent at runtime; in TS the three states (absent,
+   * `undefined`, `string`) collapse to `string | undefined` here.
+   */
+  data?: string | undefined;
+};
+
+function isSolCloseAssociatedTokenAccountRecipient(
+  recipient: RecipientEntry,
+): recipient is SolCloseAssociatedTokenAccountRecipient {
+  if (recipient.amount.value !== "0") {
+    return false;
+  }
+  const recipientRecord = recipient as Record<string, unknown>;
+  // RecipientEntry’s codec does not declare token fields; io-ts still accepts
+  // extra keys, and values widened from richer recipient shapes may carry them.
+  if ("tokenName" in recipientRecord || "tokenData" in recipientRecord) {
+    return false;
+  }
+  const addressFields = recipient.address as { address?: unknown };
+  if (typeof addressFields?.address !== "string") {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Internal io-ts refinement for one close-ATA recipient row (not exported).
+ *
+ * io-ts does not propagate refinement predicates into `TypeOf`, so
+ * `decode(...).right` is still typed as {@link RecipientEntry}. For the narrowed
+ * row shape after validation, use {@link SolCloseAssociatedTokenAccountRecipient}
+ * (see {@link SolCloseAssociatedTokenAccountIntent}’s exported type, which
+ * overrides `recipients` accordingly).
+ */
+const solCloseAssociatedTokenAccountRecipientEntry = t.refinement(
+  RecipientEntry,
+  isSolCloseAssociatedTokenAccountRecipient,
+  "SolCloseAssociatedTokenAccountRecipientEntry",
+);
+
+const solCloseAssociatedTokenAccountRecipients = t.refinement(
+  t.array(solCloseAssociatedTokenAccountRecipientEntry),
+  (recipients) => recipients.length > 0,
+  "SolCloseAssociatedTokenAccountRecipients",
+);
+
 /**
  * @title SOL Close Associated Token Account Intent
+ *
+ * After `decode`, prefer annotating or threading values as the exported
+ * {@link SolCloseAssociatedTokenAccountIntent} **type alias** (below), not raw
+ * `t.TypeOf<typeof SolCloseAssociatedTokenAccountIntent>` from io-ts alone, so
+ * `recipients` rows keep {@link SolCloseAssociatedTokenAccountRecipient} narrowing
+ * (see codec / refinement limitations in that type’s docblock).
  */
 export const SolCloseAssociatedTokenAccountIntent = t.intersection([
   BaseIntent,
   SolBuildOptions,
   t.type({
     intentType: intentTypes.closeAssociatedTokenAccount,
-    accountAddress: t.string,
-    destinationAddress: t.string,
+    recipients: solCloseAssociatedTokenAccountRecipients,
   }),
 ]);
 
-export type SolCloseAssociatedTokenAccountIntent = t.TypeOf<
-  typeof SolCloseAssociatedTokenAccountIntent
->;
+/**
+ * Intent shape with narrowed `recipients`; use this after `decode` instead of
+ * relying only on `t.TypeOf<typeof SolCloseAssociatedTokenAccountIntent>` from
+ * the codec so recipient `address.address` and `amount.value` typing match runtime rules.
+ */
+export type SolCloseAssociatedTokenAccountIntent = Omit<
+  t.TypeOf<typeof SolCloseAssociatedTokenAccountIntent>,
+  "recipients"
+> & {
+  recipients: SolCloseAssociatedTokenAccountRecipient[];
+};

package/src/schema/transactionRequest/transactionState.ts

@@ -15,6 +15,9 @@ export const TransactionState = t.keyof(
     ecdsaMPCv2Round1: 1,
     ecdsaMPCv2Round2: 1,
     ecdsaMPCv2Round3: 1,
+    eddsaMPCv2Round1: 1,
+    eddsaMPCv2Round2: 1,
+    eddsaMPCv2Round3: 1,
     readyToCombineShares: 1,
     signed: 1,
     held: 1,

package/src/utils/getAssetsFromIntent.ts

@@ -5,6 +5,17 @@ import {
   BaseIntentWithTokenName,
   BaseIntentWithAmount,
 } from "../schema/transactionRequest/intents/baseIntent";
+import { intentTypes } from "../schema/transactionRequest/intents/intentType";
+
+/**
+ * `intentType` values for intents that decode as `BaseIntentWithRecipients`
+ * but use `recipients[].amount.symbol` as a non-asset placeholder (do not extract).
+ * Extend this set when adding similar intents; a schema-driven marker would be
+ * a larger refactor.
+ */
+const INTENT_TYPES_SKIP_RECIPIENT_AMOUNT_SYMBOL_AS_ASSET = new Set<string>([
+  intentTypes.closeAssociatedTokenAccount.value,
+]);
 
 /**
  * Extracts all asset-related strings from a transaction intent
@@ -34,10 +45,16 @@ export function getAssetsFromIntent(intent: unknown): string[] {
   // Extracts: symbol from amount field
   const recipientsDecoded = BaseIntentWithRecipients.decode(intent);
   if (isRight(recipientsDecoded)) {
-    const data = recipientsDecoded.right;
-    for (const recipient of data.recipients) {
-      if (recipient.amount?.symbol) {
-        assetStrings.add(recipient.amount.symbol);
+    const intentType = (intent as Record<string, unknown>)["intentType"];
+    const skipRecipientAmountSymbol =
+      typeof intentType === "string" &&
+      INTENT_TYPES_SKIP_RECIPIENT_AMOUNT_SYMBOL_AS_ASSET.has(intentType);
+    if (!skipRecipientAmountSymbol) {
+      const data = recipientsDecoded.right;
+      for (const recipient of data.recipients) {
+        if (recipient.amount?.symbol) {
+          assetStrings.add(recipient.amount.symbol);
+        }
       }
     }
   }