@pancakeswap/swap-sdk-evm 1.2.1 → 1.2.2

package/dist/abis/B20.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Base B20 Asset ABI fragments (Coinbase's `IB20Asset`).
+ *
+ * B20's ASSET variant has the same cosmetic display multiplier as ERC-8056, under different names.
+ * Probed on Base mainnet 2026-07-28: `multiplier()` / `WAD_PRECISION()` / `toScaledBalance()` work;
+ * `uiMultiplier()`, the pending getters and ALL of `supportsInterface()` revert. ERC-8056
+ * conformance exists in base-std (PR #173) but is not deployed.
+ *
+ * https://docs.base.org/base-chain/specs/upgrades/beryl/b20
+ */
+export declare const b20AssetAbi: readonly [{
+    readonly type: "function";
+    readonly name: "multiplier";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "WAD_PRECISION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "toScaledBalance";
+    readonly inputs: readonly [{
+        readonly name: "rawBalance";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "toRawBalance";
+    readonly inputs: readonly [{
+        readonly name: "scaledBalance";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "rawBalance";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "scaledBalanceOf";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "UIMultiplierUpdated";
+    readonly inputs: readonly [{
+        readonly name: "oldMultiplier";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "newMultiplier";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "effectiveAtTimestamp";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "MultiplierUpdateCancelled";
+    readonly inputs: readonly [{
+        readonly name: "cancelledMultiplier";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "cancelledEffectiveAt";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}];
+//# sourceMappingURL=B20.d.ts.map

package/dist/abis/B20.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"B20.d.ts","sourceRoot":"","sources":["../../src/abis/B20.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4Dd,CAAA"}

package/dist/b20.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Base B20 — extension module for the scaled-UI subsystem.
+ *
+ * Owns everything B20-specific: address recognition, precompile addresses, revert decoding.
+ * Nothing outside this file and its ABI sibling needs to know B20 exists.
+ *
+ * Detection is by address prefix, not ERC-165: `supportsInterface` REVERTS on live B20 tokens for
+ * every id including ERC-165's own, so the probe could only ever answer "no". Addresses are
+ * self-describing instead — `[10-byte prefix][1-byte variant][9-byte keccak(deployer, salt)]` —
+ * so the variant is recoverable with zero RPC.
+ *
+ * https://docs.base.org/base-chain/specs/upgrades/beryl/b20
+ */
+import { ChainId } from '@pancakeswap/chains';
+import type { Address } from 'viem';
+/** Detection is gated on these so a `0xb2000…` vanity address elsewhere can't be mistaken for B20. */
+export declare const B20_SUPPORTED_CHAIN_IDS: readonly [ChainId.BASE, ChainId.BASE_SEPOLIA];
+export type B20SupportedChainId = (typeof B20_SUPPORTED_CHAIN_IDS)[number];
+/** The 10-byte prefix shared by every B20 token, lowercase, without `0x`. */
+export declare const B20_ADDRESS_PREFIX: "b2000000000000000000";
+/** Encoded in address byte `[10]`. */
+export declare enum B20Variant {
+    ASSET = 0,
+    STABLECOIN = 1
+}
+export declare const B20_FACTORY_ADDRESS: "0xB20f000000000000000000000000000000000000";
+export declare const B20_ACTIVATION_REGISTRY_ADDRESS: "0x8453000000000000000000000000000000000001";
+export declare const B20_POLICY_REGISTRY_ADDRESS: "0x8453000000000000000000000000000000000002";
+export declare function isB20SupportedChainId(chainId?: number): chainId is B20SupportedChainId;
+/** Chain-agnostic. Verified equivalent to the factory's own `isB20()` over 24 cases. */
+export declare function isB20Address(address?: string | null): boolean;
+export declare function getB20Variant(address?: string | null): B20Variant | undefined;
+/** Only the ASSET variant carries a multiplier, so a B20 stablecoin must not be treated as scaled. */
+export declare function isB20AssetToken(chainId?: number, address?: string | null): boolean;
+export declare const isB20AssetAddress: (chainId: number | undefined, address: Address | undefined) => boolean;
+/**
+ * B20 raises ABI-encoded custom errors, and a swap reverts through the router — whose ABI doesn't
+ * declare them — so viem can't name them and only the bare 4-byte selector survives. Matching it is
+ * the only reliable hook. `PausableFeature` is an enum, hence `uint8`. Verified against `IB20.sol`.
+ */
+export declare const B20_ERROR_SELECTORS: {
+    readonly '0xa43fec12': "PolicyForbids";
+    readonly '0xfd8c4245': "ContractPaused";
+    readonly '0xcccad523': "PolicyNotFound";
+    readonly '0xcdd98a4a': "UnsupportedPolicyType";
+    readonly '0xf58f733a': "SupplyCapExceeded";
+    readonly '0x6f12f3dc': "InvalidMultiplier";
+};
+export type B20ErrorName = (typeof B20_ERROR_SELECTORS)[keyof typeof B20_ERROR_SELECTORS];
+export declare const B20_PAUSABLE_FEATURES: readonly ["TRANSFER", "MINT", "BURN"];
+export type B20PausableFeature = (typeof B20_PAUSABLE_FEATURES)[number];
+export type B20RevertMatch = {
+    name: B20ErrorName;
+    /** Only for `ContractPaused`, when the revert data carried a decodable feature. */
+    feature?: B20PausableFeature;
+};
+/**
+ * Scan an error payload for a known B20 custom error. Takes a flattened string so it stays
+ * dependency-free; returns `undefined` so callers keep their generic handling.
+ */
+export declare function matchB20RevertError(input?: string | null): B20RevertMatch | undefined;
+//# sourceMappingURL=b20.d.ts.map

package/dist/b20.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"b20.d.ts","sourceRoot":"","sources":["../src/b20.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,sGAAsG;AACtG,eAAO,MAAM,uBAAuB,+CAAgD,CAAA;AAEpF,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE1E,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,EAAG,sBAA+B,CAAA;AAEjE,sCAAsC;AACtC,oBAAY,UAAU;IACpB,KAAK,IAAI;IACT,UAAU,IAAI;CACf;AAED,eAAO,MAAM,mBAAmB,EAAG,4CAAqD,CAAA;AACxF,eAAO,MAAM,+BAA+B,EAAG,4CAAqD,CAAA;AACpG,eAAO,MAAM,2BAA2B,EAAG,4CAAqD,CAAA;AAShG,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,IAAI,mBAAmB,CAEtF;AAED,wFAAwF;AACxF,wBAAgB,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAI7D;AAED,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,UAAU,GAAG,SAAS,CAW7E;AAED,sGAAsG;AACtG,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAElF;AAED,eAAO,MAAM,iBAAiB,YAAa,MAAM,GAAG,SAAS,WAAW,OAAO,GAAG,SAAS,KAAG,OAC3D,CAAA;AAMnC;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;CAOtB,CAAA;AAEV,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAA;AAEzF,eAAO,MAAM,qBAAqB,uCAAwC,CAAA;AAC1E,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvE,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,YAAY,CAAA;IAClB,mFAAmF;IACnF,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAC7B,CAAA;AAID;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,cAAc,GAAG,SAAS,CAkBrF"}

package/dist/constants.d.ts

@@ -67,7 +67,7 @@ export declare const NATIVE: {
         decimals: number;
     };
     56: {
-        readonly name: "Binance Chain Native Token";
+        readonly name: "Binance Chain";
         readonly symbol: "BNB";
         readonly decimals: 18;
     };
@@ -107,7 +107,7 @@ export declare const NATIVE: {
         readonly decimals: 18;
     };
     204: {
-        readonly name: "Binance Chain Native Token";
+        readonly name: "Binance Chain";
         readonly symbol: "BNB";
         readonly decimals: 18;
     };

package/dist/index.d.ts

@@ -3,7 +3,9 @@ export * from './entities';
 export * from './abis/ERC20';
 export * from './abis/ERC165';
 export * from './abis/ScaledUIAmount';
+export * from './abis/B20';
 export * from './utils';
 export * from './ether';
 export * from './scaledUIAmount';
+export * from './b20';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,uBAAuB,CAAA;AACrC,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,uBAAuB,CAAA;AACrC,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,cAAc,kBAAkB,CAAA;AAChC,cAAc,OAAO,CAAA"}

package/dist/index.js

@@ -269,7 +269,7 @@ var WNATIVE = {
 };
 var ETHER = { name: "Ether", symbol: "ETH", decimals: 18 };
 var BNB = {
-  name: "Binance Chain Native Token",
+  name: "Binance Chain",
   symbol: "BNB",
   decimals: 18
 };
@@ -278,7 +278,7 @@ var NATIVE = {
   [chains.ChainId.GOERLI]: { name: "Goerli Ether", symbol: "GOR", decimals: 18 },
   [chains.ChainId.BSC]: BNB,
   [chains.ChainId.BSC_TESTNET]: {
-    name: "Binance Chain Native Token",
+    name: "Binance Chain",
     symbol: "tBNB",
     decimals: 18
   },
@@ -294,7 +294,7 @@ var NATIVE = {
   [chains.ChainId.LINEA_TESTNET]: ETHER,
   [chains.ChainId.OPBNB]: BNB,
   [chains.ChainId.OPBNB_TESTNET]: {
-    name: "Binance Chain Native Token",
+    name: "Binance Chain",
     symbol: "tBNB",
     decimals: 18
   },
@@ -462,6 +462,67 @@ var scaledUIAmountAbi = [
     ]
   }
 ];
+
+// src/abis/B20.ts
+var b20AssetAbi = [
+  {
+    type: "function",
+    name: "multiplier",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WAD_PRECISION",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  // B20 does NOT claim the ERC-8056 Conversion extension id (0x57854fc3) — it keeps these native
+  // names unaliased, so detect them by ABI, never by `supportsInterface`.
+  {
+    type: "function",
+    name: "toScaledBalance",
+    inputs: [{ name: "rawBalance", type: "uint256" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "toRawBalance",
+    inputs: [{ name: "scaledBalance", type: "uint256" }],
+    outputs: [{ name: "rawBalance", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "scaledBalanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  // Post-#173 shapes, verbatim from base-std. The DEPLOYED precompile predates them and the
+  // Coinbase doc calls its event `MultiplierUpdated` with an unverified arg list — probe the real
+  // topic0 before indexing multiplier history.
+  {
+    type: "event",
+    name: "UIMultiplierUpdated",
+    inputs: [
+      { name: "oldMultiplier", type: "uint256", indexed: false },
+      { name: "newMultiplier", type: "uint256", indexed: false },
+      { name: "effectiveAtTimestamp", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "MultiplierUpdateCancelled",
+    inputs: [
+      { name: "cancelledMultiplier", type: "uint256", indexed: false },
+      { name: "cancelledEffectiveAt", type: "uint256", indexed: false }
+    ]
+  }
+];
 var _Ether = class extends swapSdkCore.NativeCurrency {
   constructor(chainId) {
     super(chainId, 18, "ETH", "Ether");
@@ -483,13 +544,147 @@ var _Ether = class extends swapSdkCore.NativeCurrency {
 };
 var Ether = _Ether;
 Ether._etherCache = {};
+var B20_SUPPORTED_CHAIN_IDS = [chains.ChainId.BASE, chains.ChainId.BASE_SEPOLIA];
+var B20_ADDRESS_PREFIX = "b2000000000000000000";
+var B20Variant = /* @__PURE__ */ ((B20Variant2) => {
+  B20Variant2[B20Variant2["ASSET"] = 0] = "ASSET";
+  B20Variant2[B20Variant2["STABLECOIN"] = 1] = "STABLECOIN";
+  return B20Variant2;
+})(B20Variant || {});
+var B20_FACTORY_ADDRESS = "0xB20f000000000000000000000000000000000000";
+var B20_ACTIVATION_REGISTRY_ADDRESS = "0x8453000000000000000000000000000000000001";
+var B20_POLICY_REGISTRY_ADDRESS = "0x8453000000000000000000000000000000000002";
+var HEX_ADDRESS_LENGTH = 40;
+var VARIANT_NIBBLE_START = B20_ADDRESS_PREFIX.length;
+var VARIANT_NIBBLE_END = VARIANT_NIBBLE_START + 2;
+var stripHexPrefix = (address) => (address.startsWith("0x") || address.startsWith("0X") ? address.slice(2) : address).toLowerCase();
+function isB20SupportedChainId(chainId) {
+  return B20_SUPPORTED_CHAIN_IDS.includes(chainId);
+}
+function isB20Address(address) {
+  if (!address)
+    return false;
+  const hex = stripHexPrefix(address);
+  return hex.length === HEX_ADDRESS_LENGTH && hex.startsWith(B20_ADDRESS_PREFIX);
+}
+function getB20Variant(address) {
+  if (!isB20Address(address))
+    return void 0;
+  switch (stripHexPrefix(address).slice(VARIANT_NIBBLE_START, VARIANT_NIBBLE_END)) {
+    case "00":
+      return 0 /* ASSET */;
+    case "01":
+      return 1 /* STABLECOIN */;
+    default:
+      return void 0;
+  }
+}
+function isB20AssetToken(chainId, address) {
+  return isB20SupportedChainId(chainId) && getB20Variant(address) === 0 /* ASSET */;
+}
+var isB20AssetAddress = (chainId, address) => isB20AssetToken(chainId, address);
+var B20_ERROR_SELECTORS = {
+  "0xa43fec12": "PolicyForbids",
+  // (bytes32 policyScope, uint64 policyId)
+  "0xfd8c4245": "ContractPaused",
+  // (PausableFeature feature)
+  "0xcccad523": "PolicyNotFound",
+  // (uint64 policyId)
+  "0xcdd98a4a": "UnsupportedPolicyType",
+  // (bytes32 policyScope)
+  "0xf58f733a": "SupplyCapExceeded",
+  // ()
+  "0x6f12f3dc": "InvalidMultiplier"
+  // ()
+};
+var B20_PAUSABLE_FEATURES = ["TRANSFER", "MINT", "BURN"];
+var SELECTOR_PATTERN = /0x[0-9a-fA-F]{8}/g;
+function matchB20RevertError(input) {
+  if (!input)
+    return void 0;
+  const matches = input.match(SELECTOR_PATTERN);
+  if (!matches)
+    return void 0;
+  for (const candidate of matches) {
+    const name = B20_ERROR_SELECTORS[candidate.toLowerCase()];
+    if (!name)
+      continue;
+    if (name !== "ContractPaused")
+      return { name };
+    const dataMatch = input.match(new RegExp(`${candidate}([0-9a-fA-F]{64})`, "i"));
+    const featureIndex = dataMatch ? Number.parseInt(dataMatch[1], 16) : Number.NaN;
+    const feature = B20_PAUSABLE_FEATURES[featureIndex];
+    return feature ? { name, feature } : { name };
+  }
+  return void 0;
+}
 var SCALED_UI_AMOUNT_INTERFACE_ID = "0xa60bf13d";
 var SCALED_UI_AMOUNT_BALANCES_INTERFACE_ID = "0xd890fd71";
+var DIALECTS = {
+  erc8056: {
+    // Deliberately no `multiplier()` fallback: it's a generic name that leverage/rebasing tokens
+    // use for unrelated values, so reading it off an arbitrary token would corrupt displayed
+    // amounts. Safe in the b20 dialect only because that's gated on a verified B20 address.
+    multiplierFns: ["uiMultiplier"],
+    pendingFns: ["newUIMultiplier", "effectiveAt"]
+  },
+  b20: {
+    // `multiplier()` first — the only getter that resolves today. `uiMultiplier()` is kept for
+    // forward-compat: it starts working as an alias once base-std #173 reaches mainnet.
+    multiplierFns: ["multiplier", "uiMultiplier"],
+    pendingFns: ["newUIMultiplier", "effectiveAt"]
+  }
+};
+var ABI_BY_FN = {
+  uiMultiplier: scaledUIAmountAbi,
+  newUIMultiplier: scaledUIAmountAbi,
+  effectiveAt: scaledUIAmountAbi,
+  multiplier: b20AssetAbi
+};
+function resolveScaledUIDialect(chainId, address) {
+  return isB20AssetToken(chainId, address) ? "b20" : "erc8056";
+}
+function buildScaledUIAmountReads(params) {
+  const { address, chainId, dialect } = params;
+  const spec = DIALECTS[dialect];
+  return [...spec.multiplierFns, ...spec.pendingFns].map((functionName) => ({
+    address,
+    abi: ABI_BY_FN[functionName],
+    functionName,
+    ...chainId === void 0 ? {} : { chainId }
+  }));
+}
+var asBigInt = (entry) => entry?.status === "success" && typeof entry.result === "bigint" ? entry.result : void 0;
 var IDENTITY_SCALED_UI_AMOUNT_METADATA = {
   enabled: false,
   multiplier: swapSdkCore.SCALED_UI_DENOMINATOR
 };
-async function probeIsScaledUIAmount(client, address) {
+function parseScaledUIAmountReads(results, dialect) {
+  const spec = DIALECTS[dialect];
+  const multiplierCount = spec.multiplierFns.length;
+  let multiplier;
+  for (let i = 0; i < multiplierCount; i++) {
+    const candidate = asBigInt(results[i]);
+    if (candidate !== void 0 && candidate !== 0n) {
+      multiplier = candidate;
+      break;
+    }
+  }
+  if (multiplier === void 0)
+    return IDENTITY_SCALED_UI_AMOUNT_METADATA;
+  const pendingIndex = (fn) => {
+    const offset = spec.pendingFns.indexOf(fn);
+    return offset === -1 ? -1 : multiplierCount + offset;
+  };
+  const newMultiplier = asBigInt(results[pendingIndex("newUIMultiplier")]);
+  const effectiveAtRaw = asBigInt(results[pendingIndex("effectiveAt")]);
+  const effectiveAt = effectiveAtRaw !== void 0 ? Number(effectiveAtRaw) : void 0;
+  const hasPending = newMultiplier !== void 0 && effectiveAt !== void 0 && newMultiplier !== multiplier && effectiveAt > 0;
+  return hasPending ? { enabled: true, multiplier, newMultiplier, effectiveAt } : { enabled: true, multiplier };
+}
+async function probeIsScaledUIAmount(client, address, chainId) {
+  if (isB20AssetToken(chainId ?? client.chain?.id, address))
+    return true;
   try {
     const result = await client.readContract({
       address,
@@ -502,28 +697,13 @@ async function probeIsScaledUIAmount(client, address) {
     return false;
   }
 }
-async function fetchScaledUIAmountMetadata(client, address) {
+async function fetchScaledUIAmountMetadata(client, address, chainId) {
+  const dialect = resolveScaledUIDialect(chainId ?? client.chain?.id, address);
   const results = await client.multicall({
-    contracts: [
-      { address, abi: scaledUIAmountAbi, functionName: "uiMultiplier" },
-      { address, abi: scaledUIAmountAbi, functionName: "newUIMultiplier" },
-      { address, abi: scaledUIAmountAbi, functionName: "effectiveAt" }
-    ],
+    contracts: buildScaledUIAmountReads({ address, dialect }),
     allowFailure: true
   });
-  const [activeRes, pendingMRes, pendingTsRes] = results;
-  if (activeRes.status !== "success") {
-    return IDENTITY_SCALED_UI_AMOUNT_METADATA;
-  }
-  const multiplier = activeRes.result;
-  if (multiplier === 0n) {
-    return IDENTITY_SCALED_UI_AMOUNT_METADATA;
-  }
-  const newMultiplier = pendingMRes.status === "success" ? pendingMRes.result : void 0;
-  const effectiveAtRaw = pendingTsRes.status === "success" ? pendingTsRes.result : void 0;
-  const effectiveAt = effectiveAtRaw !== void 0 ? Number(effectiveAtRaw) : void 0;
-  const hasPending = newMultiplier !== void 0 && effectiveAt !== void 0 && newMultiplier !== multiplier && effectiveAt > 0;
-  return hasPending ? { enabled: true, multiplier, newMultiplier, effectiveAt } : { enabled: true, multiplier };
+  return parseScaledUIAmountReads(results, dialect);
 }
 
 Object.defineProperty(exports, 'SCALED_UI_DENOMINATOR', {
@@ -546,6 +726,14 @@ Object.defineProperty(exports, 'toScaledUIAmount', {
   enumerable: true,
   get: function () { return swapSdkCore.toScaledUIAmount; }
 });
+exports.B20Variant = B20Variant;
+exports.B20_ACTIVATION_REGISTRY_ADDRESS = B20_ACTIVATION_REGISTRY_ADDRESS;
+exports.B20_ADDRESS_PREFIX = B20_ADDRESS_PREFIX;
+exports.B20_ERROR_SELECTORS = B20_ERROR_SELECTORS;
+exports.B20_FACTORY_ADDRESS = B20_FACTORY_ADDRESS;
+exports.B20_PAUSABLE_FEATURES = B20_PAUSABLE_FEATURES;
+exports.B20_POLICY_REGISTRY_ADDRESS = B20_POLICY_REGISTRY_ADDRESS;
+exports.B20_SUPPORTED_CHAIN_IDS = B20_SUPPORTED_CHAIN_IDS;
 exports.ERC20Token = ERC20Token;
 exports.Ether = Ether;
 exports.IDENTITY_SCALED_UI_AMOUNT_METADATA = IDENTITY_SCALED_UI_AMOUNT_METADATA;
@@ -558,10 +746,20 @@ exports.WBNB = WBNB;
 exports.WETH9 = WETH9;
 exports.WNATIVE = WNATIVE;
 exports.ZERO_PERCENT = ZERO_PERCENT;
+exports.b20AssetAbi = b20AssetAbi;
+exports.buildScaledUIAmountReads = buildScaledUIAmountReads;
 exports.erc165Abi = erc165Abi;
 exports.erc20Abi = erc20Abi;
 exports.fetchScaledUIAmountMetadata = fetchScaledUIAmountMetadata;
+exports.getB20Variant = getB20Variant;
+exports.isB20Address = isB20Address;
+exports.isB20AssetAddress = isB20AssetAddress;
+exports.isB20AssetToken = isB20AssetToken;
+exports.isB20SupportedChainId = isB20SupportedChainId;
+exports.matchB20RevertError = matchB20RevertError;
+exports.parseScaledUIAmountReads = parseScaledUIAmountReads;
 exports.probeIsScaledUIAmount = probeIsScaledUIAmount;
+exports.resolveScaledUIDialect = resolveScaledUIDialect;
 exports.scaledUIAmountAbi = scaledUIAmountAbi;
 exports.validateAndParseAddress = validateAndParseAddress;
 //# sourceMappingURL=out.js.map