fix(xdr): throw on legacy union construction at the call site

Author: quietbits

CHANGELOG.md

@@ -5,6 +5,13 @@ A breaking change will get clearly marked in this log.
 ## Unreleased
 
 ### Fixed
+* The legacy `new xdr.SomeUnion(discriminant, value)` form throws a `TypeError` naming the arm factory to call instead, on all 115 generated union types ([#1640](https://github.com/stellar/js-stellar-sdk/issues/1640)). Unions are abstract base classes exported as values, and `abstract` is erased at runtime, so the pre-v17 call built a base instance that silently discarded both arguments — `Object.keys(m)` was `[]` and `m.type` was `undefined`. It only failed once something serialized it, with `TypeError: this.toXdrObject is not a function` thrown from inside the SDK, naming neither the union nor the call that created it; a `new` in a module-level constant surfaced as the whole module failing at import. TypeScript already rejected the form (`TS2511: Cannot create an instance of an abstract class`), so this reaches plain JavaScript and TypeScript run without a type-check pass. `xdr.Int64` / `xdr.Uint64` / `xdr.Int32` / `xdr.Uint32` have guarded their equivalent legacy form since 17.0.0-rc.1; unions now match.
+
+  ```diff
+  -new xdr.TransactionMeta(3, transactionMetaV3);
+  +xdr.TransactionMeta.v3(transactionMetaV3);
+  ```
+
 * `equals()` on XDR values is now callable from TypeScript on union types like `xdr.ScVal`, `xdr.TransactionEnvelope`, and `xdr.Memo` — which is what the SDK's accessors return ([#1630](https://github.com/stellar/js-stellar-sdk/issues/1630)). The parameter was typed as polymorphic `this`, which reduces to `never` on a union, so every call failed with TS2345 even though the runtime worked. The parameter is now `XdrValue`, so comparing two different XDR types compiles and returns `false`.
 
 * `Keypair.verify` and `Keypair.verifyMessage` throw a `TypeError` for arguments whose type they don't accept, instead of returning `false` ([#1649](https://github.com/stellar/js-stellar-sdk/pull/1649)). Both previously swallowed every error and reported `false`, so a caller mistake was indistinguishable from an invalid signature. `verify` requires `data` to be a `Uint8Array` and `signature` to be either a `Uint8Array` or an `xdr.Signature`; `verifyMessage` takes the same `signature` and a `message` that is a string or a `Uint8Array`. Anything else now throws — a hex/base64 signature string, a plain array of byte values, the `xdr.DecoratedSignature` that `tx.signatures[0]` holds, or a `message` that is neither string nor bytes. A well-formed signature that doesn't match still returns `false`. Accepting an `xdr.Signature` — what `DecoratedSignature.signature` holds — means `kp.verify(tx.hash(), tx.signatures[0].signature)` works again. `authorizeEntry` likewise rejects a signer result it would have passed on unchecked — a callback returning none of its three shapes, a non-bytes `signature`, a non-string `publicKey`, or a `signatureScVal` that isn't an `xdr.ScVal`.

docs/XDR_MIGRATION.md

@@ -177,6 +177,16 @@ xdr.TransactionMeta.v2(transactionMetaV2);
 xdr.ExtensionPoint.v0();
 ```
 
+The legacy form throws a `TypeError` naming a factory to use instead, so a call
+site TypeScript can't reach — plain JavaScript, or TypeScript run without a
+type-check pass — fails at the `new` rather than later, inside serialization:
+
+```text
+TypeError: new xdr.TransactionMeta(...) is not supported: XDR unions are built
+from per-variant factories. Call xdr.TransactionMeta.operations(...) (or another
+arm factory) instead.
+```
+
 ### Narrowing helpers
 
 Two helpers ship on the `xdr` namespace for narrowing a union to a specific

src/xdr/generated/account-entry-ext.ts

@@ -36,6 +36,19 @@ export type AccountEntryExtVariantName = "v0" | "v1";
 abstract class AccountEntryExtBase extends XdrValue {
   abstract readonly type: AccountEntryExtVariantName;
 
+  constructor() {
+    super();
+    // `new.target`, not an unconditional throw: every arm subclass reaches
+    // this constructor through `super()`, void arms via an implicit one
+    if (new.target === AccountEntryExtBase) {
+      throw new TypeError(
+        "new xdr.AccountEntryExt(...) is not supported: XDR unions are built from " +
+          "per-variant factories. Call xdr.AccountEntryExt.v0() " +
+          "(or another arm factory) instead.",
+      );
+    }
+  }
+
   static readonly schema: XdrType<AccountEntryExtWire> = union(
     "AccountEntryExt",
     {

src/xdr/generated/account-entry-extension-v1-ext.ts

@@ -36,6 +36,19 @@ export type AccountEntryExtensionV1ExtVariantName = "v0" | "v2";
 abstract class AccountEntryExtensionV1ExtBase extends XdrValue {
   abstract readonly type: AccountEntryExtensionV1ExtVariantName;
 
+  constructor() {
+    super();
+    // `new.target`, not an unconditional throw: every arm subclass reaches
+    // this constructor through `super()`, void arms via an implicit one
+    if (new.target === AccountEntryExtensionV1ExtBase) {
+      throw new TypeError(
+        "new xdr.AccountEntryExtensionV1Ext(...) is not supported: XDR unions are built from " +
+          "per-variant factories. Call xdr.AccountEntryExtensionV1Ext.v0() " +
+          "(or another arm factory) instead.",
+      );
+    }
+  }
+
   static readonly schema: XdrType<AccountEntryExtensionV1ExtWire> = union(
     "AccountEntryExtensionV1Ext",
     {

src/xdr/generated/account-entry-extension-v2-ext.ts

@@ -36,6 +36,19 @@ export type AccountEntryExtensionV2ExtVariantName = "v0" | "v3";
 abstract class AccountEntryExtensionV2ExtBase extends XdrValue {
   abstract readonly type: AccountEntryExtensionV2ExtVariantName;
 
+  constructor() {
+    super();
+    // `new.target`, not an unconditional throw: every arm subclass reaches
+    // this constructor through `super()`, void arms via an implicit one
+    if (new.target === AccountEntryExtensionV2ExtBase) {
+      throw new TypeError(
+        "new xdr.AccountEntryExtensionV2Ext(...) is not supported: XDR unions are built from " +
+          "per-variant factories. Call xdr.AccountEntryExtensionV2Ext.v0() " +
+          "(or another arm factory) instead.",
+      );
+    }
+  }
+
   static readonly schema: XdrType<AccountEntryExtensionV2ExtWire> = union(
     "AccountEntryExtensionV2Ext",
     {

src/xdr/generated/account-merge-result.ts

@@ -53,6 +53,19 @@ export type AccountMergeResultVariantName =
 abstract class AccountMergeResultBase extends XdrValue {
   abstract readonly type: AccountMergeResultVariantName;
 
+  constructor() {
+    super();
+    // `new.target`, not an unconditional throw: every arm subclass reaches
+    // this constructor through `super()`, void arms via an implicit one
+    if (new.target === AccountMergeResultBase) {
+      throw new TypeError(
+        "new xdr.AccountMergeResult(...) is not supported: XDR unions are built from " +
+          "per-variant factories. Call xdr.AccountMergeResult.accountMergeSuccess(...) " +
+          "(or another arm factory) instead.",
+      );
+    }
+  }
+
   static readonly schema: XdrType<AccountMergeResultWire> = union(
     "AccountMergeResult",
     {

src/xdr/generated/allow-trust-result.ts

@@ -44,6 +44,19 @@ export type AllowTrustResultVariantName =
 abstract class AllowTrustResultBase extends XdrValue {
   abstract readonly type: AllowTrustResultVariantName;
 
+  constructor() {
+    super();
+    // `new.target`, not an unconditional throw: every arm subclass reaches
+    // this constructor through `super()`, void arms via an implicit one
+    if (new.target === AllowTrustResultBase) {
+      throw new TypeError(
+        "new xdr.AllowTrustResult(...) is not supported: XDR unions are built from " +
+          "per-variant factories. Call xdr.AllowTrustResult.allowTrustSuccess() " +
+          "(or another arm factory) instead.",
+      );
+    }
+  }
+
   static readonly schema: XdrType<AllowTrustResultWire> = union(
     "AllowTrustResult",
     {

src/xdr/generated/asset-code.ts

@@ -34,6 +34,19 @@ export type AssetCodeVariantName =
 abstract class AssetCodeBase extends XdrValue {
   abstract readonly type: AssetCodeVariantName;
 
+  constructor() {
+    super();
+    // `new.target`, not an unconditional throw: every arm subclass reaches
+    // this constructor through `super()`, void arms via an implicit one
+    if (new.target === AssetCodeBase) {
+      throw new TypeError(
+        "new xdr.AssetCode(...) is not supported: XDR unions are built from " +
+          "per-variant factories. Call xdr.AssetCode.assetTypeCreditAlphanum4(...) " +
+          "(or another arm factory) instead.",
+      );
+    }
+  }
+
   static readonly schema: XdrType<AssetCodeWire> = union("AssetCode", {
     switchOn: AssetType.schema,
     cases: [

src/xdr/generated/asset.ts

@@ -39,6 +39,19 @@ export type AssetVariantName =
 abstract class AssetBase extends XdrValue {
   abstract readonly type: AssetVariantName;
 
+  constructor() {
+    super();
+    // `new.target`, not an unconditional throw: every arm subclass reaches
+    // this constructor through `super()`, void arms via an implicit one
+    if (new.target === AssetBase) {
+      throw new TypeError(
+        "new xdr.Asset(...) is not supported: XDR unions are built from " +
+          "per-variant factories. Call xdr.Asset.assetTypeNative() " +
+          "(or another arm factory) instead.",
+      );
+    }
+  }
+
   static readonly schema: XdrType<AssetWire> = union("Asset", {
     switchOn: AssetType.schema,
     cases: [

src/xdr/generated/authenticated-message.ts

@@ -31,6 +31,19 @@ export type AuthenticatedMessageVariantName = "v0";
 abstract class AuthenticatedMessageBase extends XdrValue {
   abstract readonly type: AuthenticatedMessageVariantName;
 
+  constructor() {
+    super();
+    // `new.target`, not an unconditional throw: every arm subclass reaches
+    // this constructor through `super()`, void arms via an implicit one
+    if (new.target === AuthenticatedMessageBase) {
+      throw new TypeError(
+        "new xdr.AuthenticatedMessage(...) is not supported: XDR unions are built from " +
+          "per-variant factories. Call xdr.AuthenticatedMessage.v0(...) " +
+          "(or another arm factory) instead.",
+      );
+    }
+  }
+
   static readonly schema: XdrType<AuthenticatedMessageWire> = union(
     "AuthenticatedMessage",
     {