@bitgo-beta/statics 15.1.1-beta.213 → 15.1.1-beta.2131

package/dist/src/networkFeatureMapForTokens.d.ts

@@ -0,0 +1,30 @@
+import { CoinFamily, CoinFeature } from './base';
+/** Register default token features for a dynamically onboarded chain family. */
+export declare function registerNetworkFeatures(family: string, features: CoinFeature[]): void;
+/** Default token feature set shared by "plain" EVM-compatible chain families (no bespoke features). */
+export declare const EVM_TOKEN_FEATURES: CoinFeature[];
+/** Same as EVM_TOKEN_FEATURES, minus EIP1559, for EVM-compatible families that don't support it (e.g. xdc). */
+export declare const EVM_TOKEN_FEATURES_NON_EIP1559: CoinFeature[];
+/**
+ * Populate networkFeatureMapForTokens for every family whose base coin carries
+ * CoinFeature.SUPPORTS_ERC20 and isn't already explicitly listed below, using EVM_TOKEN_FEATURES
+ * (or its non-EIP1559 variant, mirroring the base coin's own EIP1559 support). Called once from
+ * coins.ts (which has access to the full coin map) so this module doesn't need to import it
+ * directly (that would create a circular import: coins.ts -> networkFeatureMapForTokens.ts ->
+ * allCoinsAndTokens.ts -> coins/botTokens.ts -> networkFeatureMapForTokens.ts).
+ */
+export declare function registerErc20Families(families: Iterable<[family: string, supportsEip1559: boolean]>): void;
+/**
+ * Look up token features for a family.
+ * Checks the static map first (including entries backfilled by registerErc20Families), then the
+ * dynamic map. Returns undefined if the family isn't recognized by either.
+ */
+export declare function getNetworkFeatures(family: string): CoinFeature[] | undefined;
+/**
+ * Resolve the final feature list for a token: the family's default token features
+ * plus `additionalFeatures`, minus `excludedFeatures`. Used by generated bot-token
+ * lists to apply the per-token diff returned by AMS (`features=false`).
+ */
+export declare function getTokenFeatures(family: string, additionalFeatures?: CoinFeature[], excludedFeatures?: CoinFeature[]): CoinFeature[];
+export declare const networkFeatureMapForTokens: Partial<Record<CoinFamily, CoinFeature[]>>;
+//# sourceMappingURL=networkFeatureMapForTokens.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"networkFeatureMapForTokens.d.ts","sourceRoot":"","sources":["../../src/networkFeatureMapForTokens.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAiBjD,gFAAgF;AAChF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAI,CAErF;AAED,uGAAuG;AACvG,eAAO,MAAM,kBAAkB,EAAE,WAAW,EAQ3C,CAAC;AAEF,+GAA+G;AAC/G,eAAO,MAAM,8BAA8B,EAAE,WAAW,EAEvD,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAQ1G;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,GAAG,SAAS,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,kBAAkB,GAAE,WAAW,EAAO,EACtC,gBAAgB,GAAE,WAAW,EAAO,GACnC,WAAW,EAAE,CAIf;AAED,eAAO,MAAM,0BAA0B,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC,CA4BjF,CAAC"}

package/dist/src/networkFeatureMapForTokens.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkFeatureMapForTokens = exports.EVM_TOKEN_FEATURES_NON_EIP1559 = exports.EVM_TOKEN_FEATURES = void 0;
+exports.registerNetworkFeatures = registerNetworkFeatures;
+exports.registerErc20Families = registerErc20Families;
+exports.getNetworkFeatures = getNetworkFeatures;
+exports.getTokenFeatures = getTokenFeatures;
+const account_1 = require("./account");
+const base_1 = require("./base");
+const coinFeatures_1 = require("./coinFeatures");
+const dynamicNetworkFeaturesMap = new Map();
+/** Register default token features for a dynamically onboarded chain family. */
+function registerNetworkFeatures(family, features) {
+    dynamicNetworkFeaturesMap.set(family, features);
+}
+/** Default token feature set shared by "plain" EVM-compatible chain families (no bespoke features). */
+exports.EVM_TOKEN_FEATURES = [
+    ...coinFeatures_1.EVM_FEATURES,
+    base_1.CoinFeature.SHARED_EVM_SIGNING,
+    base_1.CoinFeature.SHARED_EVM_SDK,
+    base_1.CoinFeature.EVM_COMPATIBLE_IMS,
+    base_1.CoinFeature.EVM_COMPATIBLE_UI,
+    base_1.CoinFeature.EVM_COMPATIBLE_WP,
+    base_1.CoinFeature.SUPPORTS_ERC20,
+];
+/** Same as EVM_TOKEN_FEATURES, minus EIP1559, for EVM-compatible families that don't support it (e.g. xdc). */
+exports.EVM_TOKEN_FEATURES_NON_EIP1559 = exports.EVM_TOKEN_FEATURES.filter((feature) => feature !== base_1.CoinFeature.EIP1559);
+/**
+ * Populate networkFeatureMapForTokens for every family whose base coin carries
+ * CoinFeature.SUPPORTS_ERC20 and isn't already explicitly listed below, using EVM_TOKEN_FEATURES
+ * (or its non-EIP1559 variant, mirroring the base coin's own EIP1559 support). Called once from
+ * coins.ts (which has access to the full coin map) so this module doesn't need to import it
+ * directly (that would create a circular import: coins.ts -> networkFeatureMapForTokens.ts ->
+ * allCoinsAndTokens.ts -> coins/botTokens.ts -> networkFeatureMapForTokens.ts).
+ */
+function registerErc20Families(families) {
+    for (const [family, supportsEip1559] of families) {
+        if (!(family in exports.networkFeatureMapForTokens)) {
+            exports.networkFeatureMapForTokens[family] = supportsEip1559
+                ? exports.EVM_TOKEN_FEATURES
+                : exports.EVM_TOKEN_FEATURES_NON_EIP1559;
+        }
+    }
+}
+/**
+ * Look up token features for a family.
+ * Checks the static map first (including entries backfilled by registerErc20Families), then the
+ * dynamic map. Returns undefined if the family isn't recognized by either.
+ */
+function getNetworkFeatures(family) {
+    return exports.networkFeatureMapForTokens[family] ?? dynamicNetworkFeaturesMap.get(family);
+}
+/**
+ * Resolve the final feature list for a token: the family's default token features
+ * plus `additionalFeatures`, minus `excludedFeatures`. Used by generated bot-token
+ * lists to apply the per-token diff returned by AMS (`features=false`).
+ */
+function getTokenFeatures(family, additionalFeatures = [], excludedFeatures = []) {
+    const base = getNetworkFeatures(family) ?? [];
+    const excluded = new Set(excludedFeatures);
+    return [...new Set([...base, ...additionalFeatures])].filter((f) => !excluded.has(f));
+}
+exports.networkFeatureMapForTokens = {
+    algo: account_1.AccountCoin.DEFAULT_FEATURES,
+    apt: coinFeatures_1.APT_FEATURES,
+    arbeth: [...account_1.AccountCoin.DEFAULT_FEATURES, base_1.CoinFeature.EIP1559],
+    avaxc: account_1.AccountCoin.DEFAULT_FEATURES,
+    bera: [...account_1.AccountCoin.DEFAULT_FEATURES, base_1.CoinFeature.EIP1559],
+    bsc: coinFeatures_1.BSC_TOKEN_FEATURES,
+    canton: coinFeatures_1.CANTON_TOKEN_FEATURES,
+    celo: account_1.AccountCoin.DEFAULT_FEATURES,
+    eth: account_1.AccountCoin.DEFAULT_FEATURES,
+    baseeth: exports.EVM_TOKEN_FEATURES,
+    eos: account_1.AccountCoin.DEFAULT_FEATURES,
+    gasevm: exports.EVM_TOKEN_FEATURES,
+    hbar: account_1.AccountCoin.DEFAULT_FEATURES,
+    opeth: [...account_1.AccountCoin.DEFAULT_FEATURES, base_1.CoinFeature.EIP1559],
+    katanaeth: exports.EVM_TOKEN_FEATURES,
+    polygon: coinFeatures_1.POLYGON_TOKEN_FEATURES,
+    scrolleth: exports.EVM_TOKEN_FEATURES,
+    sol: coinFeatures_1.SOL_TOKEN_FEATURES,
+    stx: coinFeatures_1.STX_TOKEN_FEATURES,
+    sui: coinFeatures_1.SUI_TOKEN_FEATURES,
+    tao: coinFeatures_1.TAO_TOKEN_FEATURES,
+    polyx: coinFeatures_1.POLYX_TOKEN_FEATURES,
+    trx: account_1.AccountCoin.DEFAULT_FEATURES,
+    xlm: account_1.AccountCoin.DEFAULT_FEATURES,
+    xrp: account_1.AccountCoin.DEFAULT_FEATURES,
+    ofc: [],
+    ada: coinFeatures_1.ADA_TOKEN_FEATURES,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkFeatureMapForTokens.js","sourceRoot":"","sources":["../../src/networkFeatureMapForTokens.ts"],"names":[],"mappings":"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","sourcesContent":["import { AccountCoin } from './account';\nimport { CoinFamily, CoinFeature } from './base';\nimport {\n  ADA_TOKEN_FEATURES,\n  APT_FEATURES,\n  BSC_TOKEN_FEATURES,\n  CANTON_TOKEN_FEATURES,\n  EVM_FEATURES,\n  POLYGON_TOKEN_FEATURES,\n  POLYX_TOKEN_FEATURES,\n  SOL_TOKEN_FEATURES,\n  STX_TOKEN_FEATURES,\n  SUI_TOKEN_FEATURES,\n  TAO_TOKEN_FEATURES,\n} from './coinFeatures';\n\nconst dynamicNetworkFeaturesMap = new Map<string, CoinFeature[]>();\n\n/** Register default token features for a dynamically onboarded chain family. */\nexport function registerNetworkFeatures(family: string, features: CoinFeature[]): void {\n  dynamicNetworkFeaturesMap.set(family, features);\n}\n\n/** Default token feature set shared by \"plain\" EVM-compatible chain families (no bespoke features). */\nexport const EVM_TOKEN_FEATURES: CoinFeature[] = [\n  ...EVM_FEATURES,\n  CoinFeature.SHARED_EVM_SIGNING,\n  CoinFeature.SHARED_EVM_SDK,\n  CoinFeature.EVM_COMPATIBLE_IMS,\n  CoinFeature.EVM_COMPATIBLE_UI,\n  CoinFeature.EVM_COMPATIBLE_WP,\n  CoinFeature.SUPPORTS_ERC20,\n];\n\n/** Same as EVM_TOKEN_FEATURES, minus EIP1559, for EVM-compatible families that don't support it (e.g. xdc). */\nexport const EVM_TOKEN_FEATURES_NON_EIP1559: CoinFeature[] = EVM_TOKEN_FEATURES.filter(\n  (feature) => feature !== CoinFeature.EIP1559\n);\n\n/**\n * Populate networkFeatureMapForTokens for every family whose base coin carries\n * CoinFeature.SUPPORTS_ERC20 and isn't already explicitly listed below, using EVM_TOKEN_FEATURES\n * (or its non-EIP1559 variant, mirroring the base coin's own EIP1559 support). Called once from\n * coins.ts (which has access to the full coin map) so this module doesn't need to import it\n * directly (that would create a circular import: coins.ts -> networkFeatureMapForTokens.ts ->\n * allCoinsAndTokens.ts -> coins/botTokens.ts -> networkFeatureMapForTokens.ts).\n */\nexport function registerErc20Families(families: Iterable<[family: string, supportsEip1559: boolean]>): void {\n  for (const [family, supportsEip1559] of families) {\n    if (!(family in networkFeatureMapForTokens)) {\n      networkFeatureMapForTokens[family as CoinFamily] = supportsEip1559\n        ? EVM_TOKEN_FEATURES\n        : EVM_TOKEN_FEATURES_NON_EIP1559;\n    }\n  }\n}\n\n/**\n * Look up token features for a family.\n * Checks the static map first (including entries backfilled by registerErc20Families), then the\n * dynamic map. Returns undefined if the family isn't recognized by either.\n */\nexport function getNetworkFeatures(family: string): CoinFeature[] | undefined {\n  return networkFeatureMapForTokens[family as CoinFamily] ?? dynamicNetworkFeaturesMap.get(family);\n}\n\n/**\n * Resolve the final feature list for a token: the family's default token features\n * plus `additionalFeatures`, minus `excludedFeatures`. Used by generated bot-token\n * lists to apply the per-token diff returned by AMS (`features=false`).\n */\nexport function getTokenFeatures(\n  family: string,\n  additionalFeatures: CoinFeature[] = [],\n  excludedFeatures: CoinFeature[] = []\n): CoinFeature[] {\n  const base = getNetworkFeatures(family) ?? [];\n  const excluded = new Set<CoinFeature>(excludedFeatures);\n  return [...new Set<CoinFeature>([...base, ...additionalFeatures])].filter((f) => !excluded.has(f));\n}\n\nexport const networkFeatureMapForTokens: Partial<Record<CoinFamily, CoinFeature[]>> = {\n  algo: AccountCoin.DEFAULT_FEATURES,\n  apt: APT_FEATURES,\n  arbeth: [...AccountCoin.DEFAULT_FEATURES, CoinFeature.EIP1559],\n  avaxc: AccountCoin.DEFAULT_FEATURES,\n  bera: [...AccountCoin.DEFAULT_FEATURES, CoinFeature.EIP1559],\n  bsc: BSC_TOKEN_FEATURES,\n  canton: CANTON_TOKEN_FEATURES,\n  celo: AccountCoin.DEFAULT_FEATURES,\n  eth: AccountCoin.DEFAULT_FEATURES,\n  baseeth: EVM_TOKEN_FEATURES,\n  eos: AccountCoin.DEFAULT_FEATURES,\n  gasevm: EVM_TOKEN_FEATURES,\n  hbar: AccountCoin.DEFAULT_FEATURES,\n  opeth: [...AccountCoin.DEFAULT_FEATURES, CoinFeature.EIP1559],\n  katanaeth: EVM_TOKEN_FEATURES,\n  polygon: POLYGON_TOKEN_FEATURES,\n  scrolleth: EVM_TOKEN_FEATURES,\n  sol: SOL_TOKEN_FEATURES,\n  stx: STX_TOKEN_FEATURES,\n  sui: SUI_TOKEN_FEATURES,\n  tao: TAO_TOKEN_FEATURES,\n  polyx: POLYX_TOKEN_FEATURES,\n  trx: AccountCoin.DEFAULT_FEATURES,\n  xlm: AccountCoin.DEFAULT_FEATURES,\n  xrp: AccountCoin.DEFAULT_FEATURES,\n  ofc: [],\n  ada: ADA_TOKEN_FEATURES,\n};\n"]}