@moonbeam-network/xcm-builder 1.0.0-dev.153 → 1.0.0-dev.155

package/build/index.d.ts

@@ -44,12 +44,14 @@ declare class SubstrateQueryConfig extends BaseConfig {
 
 type AssetMinConfigBuilder = ConfigBuilder<SubstrateQueryConfig, AssetMinConfigBuilderParams>;
 interface AssetMinConfigBuilderParams {
+    address?: string;
     asset: ChainAssetId;
 }
 
 declare function AssetMinBuilder(): {
     assetRegistry: typeof assetRegistry;
     assets: typeof assets$1;
+    foreignAssets: typeof foreignAssets$1;
 };
 declare function assetRegistry(): {
     assetMetadatas: () => AssetMinConfigBuilder;
@@ -58,6 +60,9 @@ declare function assetRegistry(): {
 declare function assets$1(): {
     asset: () => AssetMinConfigBuilder;
 };
+declare function foreignAssets$1(): {
+    asset: () => AssetMinConfigBuilder;
+};
 
 interface ContractConfigConstructorParams extends BaseConfigConstructorParams {
     address: string;
@@ -133,12 +138,16 @@ declare function erc20(): BalanceConfigBuilder;
 declare function native(): BalanceConfigBuilder;
 declare function substrate(): {
     assets: typeof assets;
+    foreignAssets: typeof foreignAssets;
     system: typeof system;
     tokens: typeof tokens;
 };
 declare function assets(): {
     account: () => BalanceConfigBuilder;
 };
+declare function foreignAssets(): {
+    account: () => BalanceConfigBuilder;
+};
 declare function system(): {
     account: () => BalanceConfigBuilder;
     accountEquilibrium: () => BalanceConfigBuilder;
@@ -354,6 +363,9 @@ declare function polkadotXcm$1(): {
     transferAssets: () => {
         here: () => ExtrinsicConfigBuilder;
     };
+    transferAssetsUsingTypeAndThen: () => {
+        globalConsensusEthereum: () => ExtrinsicConfigBuilder;
+    };
 };
 
 declare function xTokens(): {

package/build/index.mjs

@@ -1,6 +1,84 @@
 // src/index.ts
 import "@polkadot/api-augment";
 
+// src/extrinsic/ExtrinsicBuilder.utils.ts
+import { getTypeDef } from "@polkadot/types";
+import { u8aToHex } from "@polkadot/util";
+import { decodeAddress } from "@polkadot/util-crypto";
+
+// src/extrinsic/ExtrinsicBuilder.interfaces.ts
+var XcmVersion = /* @__PURE__ */ ((XcmVersion2) => {
+  XcmVersion2["v1"] = "V1";
+  XcmVersion2["v2"] = "V2";
+  XcmVersion2["v3"] = "V3";
+  XcmVersion2["v4"] = "V4";
+  XcmVersion2["v5"] = "V5";
+  return XcmVersion2;
+})(XcmVersion || {});
+
+// src/extrinsic/ExtrinsicBuilder.utils.ts
+function getExtrinsicArgumentVersion(func, index = 0) {
+  if (!func) return "V1" /* v1 */;
+  const { type } = func.meta.args[index];
+  const instance = func.meta.registry.createType(type.toString());
+  const raw = getTypeDef(instance?.toRawType());
+  if (!raw.sub) {
+    return "V1" /* v1 */;
+  }
+  const versions = Array.isArray(raw.sub) ? raw.sub.map((x) => x.name) : [raw.sub.name];
+  if (versions.includes("V5" /* v5 */)) {
+    return "V5" /* v5 */;
+  }
+  if (versions.includes("V4" /* v4 */)) {
+    return "V4" /* v4 */;
+  }
+  if (versions.includes("V3" /* v3 */)) {
+    return "V3" /* v3 */;
+  }
+  if (versions.includes("V2" /* v2 */)) {
+    return "V2" /* v2 */;
+  }
+  if (versions.includes("V1" /* v1 */)) {
+    return "V1" /* v1 */;
+  }
+  throw new Error("Can't find XCM version");
+}
+function getExtrinsicAccount(address) {
+  const isEthAddress = address.length === 42 && address.startsWith("0x");
+  return isEthAddress ? {
+    AccountKey20: {
+      key: address
+    }
+  } : {
+    AccountId32: {
+      id: u8aToHex(decodeAddress(address)),
+      network: null
+    }
+  };
+}
+function isXcmV4(xcmVersion) {
+  return xcmVersion >= "V4" /* v4 */;
+}
+function normalizeX1(xcmVersion, versionedObject) {
+  if (!isXcmV4(xcmVersion)) return versionedObject;
+  const normalizedObject = { ...versionedObject };
+  const interior = normalizedObject.interior;
+  if ("X1" in interior && interior?.X1 && !Array.isArray(interior.X1)) {
+    interior.X1 = [interior.X1];
+  } else if ("x1" in interior && interior?.x1 && !Array.isArray(interior.x1)) {
+    interior.x1 = [interior.x1];
+  }
+  return normalizedObject;
+}
+function normalizeConcrete(xcmVersion, versionedObject) {
+  return isXcmV4(xcmVersion) ? versionedObject : applyConcreteWrapper(versionedObject);
+}
+function applyConcreteWrapper(versionedObject) {
+  return {
+    Concrete: { ...versionedObject }
+  };
+}
+
 // src/types/BaseConfig.ts
 var BaseConfig = class {
   module;
@@ -33,7 +111,8 @@ var SubstrateQueryConfig = class _SubstrateQueryConfig extends BaseConfig {
 function AssetMinBuilder() {
   return {
     assetRegistry,
-    assets
+    assets,
+    foreignAssets
   };
 }
 function assetRegistry() {
@@ -71,6 +150,40 @@ function assets() {
     })
   };
 }
+function foreignAssets() {
+  return {
+    asset: () => ({
+      build: ({ address }) => {
+        if (!address) {
+          throw new Error(
+            "Asset address is missing for foreignAssets.asset min calculation"
+          );
+        }
+        const multilocation = {
+          parents: 2,
+          interior: {
+            X2: [
+              {
+                globalconsensus: {
+                  ethereum: {
+                    chainId: 1
+                  }
+                }
+              },
+              getExtrinsicAccount(address)
+            ]
+          }
+        };
+        return new SubstrateQueryConfig({
+          module: "foreignAssets",
+          func: "asset",
+          args: [multilocation],
+          transform: async (response) => response.unwrapOrDefault().minBalance.toBigInt()
+        });
+      }
+    })
+  };
+}
 
 // src/balance/BalanceBuilder.ts
 import { evmToAddress as evmToAddress2 } from "@polkadot/util-crypto";
@@ -107,20 +220,20 @@ var ContractConfig = class _ContractConfig extends BaseConfig {
 
 // src/contract/contracts/Xtokens/Xtokens.ts
 import { formatAssetIdToERC20 } from "@moonbeam-network/xcm-utils";
-import { u8aToHex as u8aToHex2 } from "@polkadot/util";
-import { decodeAddress as decodeAddress2, evmToAddress } from "@polkadot/util-crypto";
+import { u8aToHex as u8aToHex3 } from "@polkadot/util";
+import { decodeAddress as decodeAddress3, evmToAddress } from "@polkadot/util-crypto";
 
 // src/builder.utils.ts
 import { EvmParachain } from "@moonbeam-network/xcm-types";
-import { u8aToHex } from "@polkadot/util";
-import { decodeAddress } from "@polkadot/util-crypto";
+import { u8aToHex as u8aToHex2 } from "@polkadot/util";
+import { decodeAddress as decodeAddress2 } from "@polkadot/util-crypto";
 function getPrecompileDestinationInterior(destination, address) {
   if (!address) {
     return [`0x0000000${destination.parachainId.toString(16)}`];
   }
   const accountType = EvmParachain.is(destination) ? "03" : "01";
-  const acc = `0x${accountType}${u8aToHex(
-    decodeAddress(address),
+  const acc = `0x${accountType}${u8aToHex2(
+    decodeAddress2(address),
     -1,
     false
   )}00`;
@@ -291,8 +404,8 @@ function Xtokens() {
 function getDestinationMultilocationForPrecompileDestination(address, destination) {
   const accountType = "01";
   const substrateAddress = evmToAddress(address);
-  const acc = `0x${accountType}${u8aToHex2(
-    decodeAddress2(substrateAddress),
+  const acc = `0x${accountType}${u8aToHex3(
+    decodeAddress3(substrateAddress),
     -1,
     false
   )}00`;
@@ -592,6 +705,7 @@ function native() {
 function substrate() {
   return {
     assets: assets2,
+    foreignAssets: foreignAssets2,
     system,
     tokens
   };
@@ -608,6 +722,34 @@ function assets2() {
     })
   };
 }
+function foreignAssets2() {
+  return {
+    account: () => ({
+      build: ({ address, asset }) => {
+        if (!asset.address) {
+          throw new Error(
+            "Asset address is needed to calculate balance with foreignAssets.account function"
+          );
+        }
+        const multilocation = {
+          parents: 2,
+          interior: {
+            X2: [
+              { GlobalConsensus: { ethereum: { chainId: 1 } } },
+              getExtrinsicAccount(asset.address)
+            ]
+          }
+        };
+        return new SubstrateQueryConfig({
+          module: "foreignAssets",
+          func: "account",
+          args: [multilocation, address],
+          transform: async (response) => response.unwrapOrDefault().balance.toBigInt()
+        });
+      }
+    })
+  };
+}
 function system() {
   return {
     account: () => ({
@@ -698,84 +840,6 @@ var ExtrinsicConfig = class _ExtrinsicConfig extends BaseConfig {
   }
 };
 
-// src/extrinsic/ExtrinsicBuilder.utils.ts
-import { getTypeDef } from "@polkadot/types";
-import { u8aToHex as u8aToHex3 } from "@polkadot/util";
-import { decodeAddress as decodeAddress3 } from "@polkadot/util-crypto";
-
-// src/extrinsic/ExtrinsicBuilder.interfaces.ts
-var XcmVersion = /* @__PURE__ */ ((XcmVersion2) => {
-  XcmVersion2["v1"] = "V1";
-  XcmVersion2["v2"] = "V2";
-  XcmVersion2["v3"] = "V3";
-  XcmVersion2["v4"] = "V4";
-  XcmVersion2["v5"] = "V5";
-  return XcmVersion2;
-})(XcmVersion || {});
-
-// src/extrinsic/ExtrinsicBuilder.utils.ts
-function getExtrinsicArgumentVersion(func, index = 0) {
-  if (!func) return "V1" /* v1 */;
-  const { type } = func.meta.args[index];
-  const instance = func.meta.registry.createType(type.toString());
-  const raw = getTypeDef(instance?.toRawType());
-  if (!raw.sub) {
-    return "V1" /* v1 */;
-  }
-  const versions = Array.isArray(raw.sub) ? raw.sub.map((x) => x.name) : [raw.sub.name];
-  if (versions.includes("V5" /* v5 */)) {
-    return "V5" /* v5 */;
-  }
-  if (versions.includes("V4" /* v4 */)) {
-    return "V4" /* v4 */;
-  }
-  if (versions.includes("V3" /* v3 */)) {
-    return "V3" /* v3 */;
-  }
-  if (versions.includes("V2" /* v2 */)) {
-    return "V2" /* v2 */;
-  }
-  if (versions.includes("V1" /* v1 */)) {
-    return "V1" /* v1 */;
-  }
-  throw new Error("Can't find XCM version");
-}
-function getExtrinsicAccount(address) {
-  const isEthAddress = address.length === 42 && address.startsWith("0x");
-  return isEthAddress ? {
-    AccountKey20: {
-      key: address
-    }
-  } : {
-    AccountId32: {
-      id: u8aToHex3(decodeAddress3(address)),
-      network: null
-    }
-  };
-}
-function isXcmV4(xcmVersion) {
-  return xcmVersion >= "V4" /* v4 */;
-}
-function normalizeX1(xcmVersion, versionedObject) {
-  if (!isXcmV4(xcmVersion)) return versionedObject;
-  const normalizedObject = { ...versionedObject };
-  const interior = normalizedObject.interior;
-  if ("X1" in interior && interior?.X1 && !Array.isArray(interior.X1)) {
-    interior.X1 = [interior.X1];
-  } else if ("x1" in interior && interior?.x1 && !Array.isArray(interior.x1)) {
-    interior.x1 = [interior.x1];
-  }
-  return normalizedObject;
-}
-function normalizeConcrete(xcmVersion, versionedObject) {
-  return isXcmV4(xcmVersion) ? versionedObject : applyConcreteWrapper(versionedObject);
-}
-function applyConcreteWrapper(versionedObject) {
-  return {
-    Concrete: { ...versionedObject }
-  };
-}
-
 // src/extrinsic/pallets/eqBalances/eqBalances.ts
 var pallet = "eqBalances";
 function eqBalances() {
@@ -1073,6 +1137,89 @@ function polkadotXcm() {
           })
         })
       };
+    },
+    transferAssetsUsingTypeAndThen: () => {
+      const func = "transferAssetsUsingTypeAndThen";
+      return {
+        // TODO we could pass a parameter globalConsensus in the chain asset if we need a different one
+        globalConsensusEthereum: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet2,
+            func,
+            getArgs: (extrinsicFunction) => {
+              if (!params.asset.address) {
+                throw new Error(
+                  "Asset address is needed for transferAssetsUsingTypeAndThen.globalConsensus function"
+                );
+              }
+              const version = getExtrinsicArgumentVersion(extrinsicFunction);
+              return [
+                {
+                  [version]: {
+                    parents: 1,
+                    interior: {
+                      X1: [
+                        {
+                          Parachain: params.destination.parachainId
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  [version]: [
+                    {
+                      id: normalizeConcrete(version, {
+                        parents: 2,
+                        interior: {
+                          X2: [
+                            { globalConsensus: { Ethereum: { ChainId: 1 } } },
+                            getExtrinsicAccount(params.asset.address)
+                          ]
+                        }
+                      }),
+                      fun: { fungible: params.asset.amount }
+                    }
+                  ]
+                },
+                "LocalReserve",
+                {
+                  [version]: normalizeConcrete(version, {
+                    parents: 2,
+                    interior: {
+                      X2: [
+                        { globalConsensus: { Ethereum: { ChainId: 1 } } },
+                        getExtrinsicAccount(params.asset.address)
+                      ]
+                    }
+                  })
+                },
+                "LocalReserve",
+                {
+                  [version]: [
+                    {
+                      DepositAsset: {
+                        assets: {
+                          Wild: { AllCounted: 1 }
+                        },
+                        beneficiary: normalizeX1(version, {
+                          parents: 0,
+                          interior: {
+                            X1: getExtrinsicAccount(
+                              params.destinationAddress
+                            )
+                          }
+                        })
+                      }
+                    }
+                  ]
+                },
+                "Unlimited"
+              ];
+            }
+          })
+        })
+      };
     }
   };
 }