feat: support system to bridge txs

examples/rococo/assetHub/foreignAssetTransfers/bridge/assetHubSnowbridgeETHToBridgeHub.ts

@@ -0,0 +1,54 @@
+/**
+ * When importing from @substrate/asset-transfer-api it would look like the following
+ *
+ * import { AssetTransferApi, constructApiPromise } from '@substrate/asset-transfer-api'
+ */
+import { AssetTransferApi, constructApiPromise } from '../../../../../src';
+import { TxResult } from '../../../../../src/types';
+import { GREEN, PURPLE, RESET } from '../../../../colors';
+
+/**
+ * In this example we are creating a `polkadotXcm` pallet `transferAssets` call to send WETH (foreign asset with location `{"parents":"2","interior":{"X2":[{"GlobalConsensus":{"Ethereum":{"chainId":"11155111"}}},{"AccountKey20":{"network":null,"key":"0xfff9976782d46cc05630d1f6ebab18b2324d6b14"}}]}}`)
+ * from a Rococo Asset Hub (System Parachain) account
+ * to a Rococo Bridge Hub (System ParaChain) account, where the `xcmVersion` is set to 4, the `isLimited` option is set to true and there is no
+ * `weightLimit` option provided which declares that the tx will allow unlimited weight to be used for fees.
+ *
+ * NOTE: When `isLimited` is true it will use the `limited` version of either `reserveTransferAssets`, or `teleportAssets`.
+ */
+const main = async () => {
+	const { api, specName, chainName, safeXcmVersion } = await constructApiPromise(
+		'wss://rococo-asset-hub-rpc.polkadot.io',
+	);
+	const assetApi = new AssetTransferApi(api, specName, safeXcmVersion, {
+		chainName,
+	});
+
+	let callInfo: TxResult<'call'>;
+	try {
+		callInfo = await assetApi.createTransferTransaction(
+			`{"parents":"2","interior":{"X1":{"GlobalConsensus":{"Ethereum":{"chainId":"11155111"}}}}}`,
+			'0x6E733286C3Dc52C67b8DAdFDd634eD9c3Fb05B5B',
+			[
+				`{"parents":"2","interior":{"X2":[{"GlobalConsensus":{"Ethereum":{"chainId":"11155111"}}},{"AccountKey20":{"network":null,"key":"0xfff9976782d46cc05630d1f6ebab18b2324d6b14"}}]}}`,
+			],
+			['1000000000000'],
+			{
+				format: 'call',
+				xcmVersion: 4,
+				isLimited: true,
+			},
+		);
+
+		console.log(callInfo);
+	} catch (e) {
+		console.error(e);
+		throw Error(e as string);
+	}
+
+	const decoded = assetApi.decodeExtrinsic(callInfo.tx, 'call');
+	console.log(`\n${PURPLE}The following decoded tx:\n${GREEN} ${JSON.stringify(JSON.parse(decoded), null, 4)}${RESET}`);
+};
+
+main()
+	.catch((err) => console.error(err))
+	.finally(() => process.exit());

examples/rococo/assetHub/foreignAssetTransfers/local/assetHubSnowbridgeETHForeignAssetsTransfer.ts

@@ -0,0 +1,49 @@
+/**
+ * When importing from @substrate/asset-transfer-api it would look like the following
+ *
+ * import { AssetTransferApi, constructApiPromise } from '@substrate/asset-transfer-api'
+ */
+import { AssetTransferApi, constructApiPromise } from '../../../../../src';
+import { TxResult } from '../../../../../src/types';
+import { GREEN, PURPLE, RESET } from '../../../../colors';
+
+/**
+ * In this example we are creating a `foreignAssets` pallet `transfer` call to send WETH (foreign asset with location `{"parents":"2","interior":{"X2":[{"GlobalConsensus":{"Ethereum":{"chainId":"11155111"}}},{"AccountKey20":{"network":null,"key":"0xfff9976782d46cc05630d1f6ebab18b2324d6b14"}}]}}`,
+`)
+ * from a Rococo Asset Hub (System Parachain) account
+ * to a Rococo Asset Hub (System Parachain) account.
+ *
+ * NOTE: When `isLimited` is true it will use the `limited` version of the either `reserveAssetTransfer`, or `teleportAssets`.
+ */
+const main = async () => {
+	const { api, specName, safeXcmVersion } = await constructApiPromise('wss://rococo-asset-hub-rpc.polkadot.io');
+	const assetApi = new AssetTransferApi(api, specName, safeXcmVersion);
+
+	let callInfo: TxResult<'call'>;
+	try {
+		callInfo = await assetApi.createTransferTransaction(
+			'1000', // NOTE: The destination id is `1000` and matches the origin chain making this a local transfer
+			'5EWNeodpcQ6iYibJ3jmWVe85nsok1EDG8Kk3aFg8ZzpfY1qX',
+			[
+				`{"parents":"2","interior":{"X2":[{"GlobalConsensus":{"Ethereum":{"chainId":"11155111"}}},{"AccountKey20":{"network":null,"key":"0xfff9976782d46cc05630d1f6ebab18b2324d6b14"}}]}}`,
+			],
+			['1000000000000'],
+			{
+				format: 'call',
+				xcmVersion: 3,
+			},
+		);
+
+		console.log(callInfo);
+	} catch (e) {
+		console.error(e);
+		throw Error(e as string);
+	}
+
+	const decoded = assetApi.decodeExtrinsic(callInfo.tx, 'call');
+	console.log(`\n${PURPLE}The following decoded tx:\n${GREEN} ${JSON.stringify(JSON.parse(decoded), null, 4)}${RESET}`);
+};
+
+main()
+	.catch((err) => console.error(err))
+	.finally(() => process.exit());

examples/rococo/assetHub/foreignAssetTransfers/local/assetHubSnowbridgeETHToContracts.ts

@@ -0,0 +1,54 @@
+/**
+ * When importing from @substrate/asset-transfer-api it would look like the following
+ *
+ * import { AssetTransferApi, constructApiPromise } from '@substrate/asset-transfer-api'
+ */
+import { AssetTransferApi, constructApiPromise } from '../../../../../src';
+import { TxResult } from '../../../../../src/types';
+import { GREEN, PURPLE, RESET } from '../../../../colors';
+
+/**
+ * In this example we are creating a `polkadotXcm` pallet `transferAssets` call to send WETH (foreign asset with location `{"parents":"2","interior":{"X2":[{"GlobalConsensus":{"Ethereum":{"chainId":"11155111"}}},{"AccountKey20":{"network":null,"key":"0xfff9976782d46cc05630d1f6ebab18b2324d6b14"}}]}}`)
+ * from a Rococo Asset Hub (System Parachain) account
+ * to a Rococo Contracts (System ParaChain) account, where the `xcmVersion` is set to 4, the `isLimited` option is set to true and there is no
+ * `weightLimit` option provided which declares that the tx will allow unlimited weight to be used for fees.
+ *
+ * NOTE: When `isLimited` is true it will use the `limited` version of either `reserveTransferAssets`, or `teleportAssets`.
+ */
+const main = async () => {
+	const { api, specName, chainName, safeXcmVersion } = await constructApiPromise(
+		'wss://rococo-asset-hub-rpc.polkadot.io',
+	);
+	const assetApi = new AssetTransferApi(api, specName, safeXcmVersion, {
+		chainName,
+	});
+
+	let callInfo: TxResult<'call'>;
+	try {
+		callInfo = await assetApi.createTransferTransaction(
+			'1002',
+			'5EWNeodpcQ6iYibJ3jmWVe85nsok1EDG8Kk3aFg8ZzpfY1qX',
+			[
+				`{"parents":"2","interior":{"X2":[{"GlobalConsensus":{"Ethereum":{"chainId":"11155111"}}},{"AccountKey20":{"network":null,"key":"0xfff9976782d46cc05630d1f6ebab18b2324d6b14"}}]}}`,
+			],
+			['1000000000000'],
+			{
+				format: 'call',
+				xcmVersion: 4,
+				isLimited: true,
+			},
+		);
+
+		console.log(callInfo);
+	} catch (e) {
+		console.error(e);
+		throw Error(e as string);
+	}
+
+	const decoded = assetApi.decodeExtrinsic(callInfo.tx, 'call');
+	console.log(`\n${PURPLE}The following decoded tx:\n${GREEN} ${JSON.stringify(JSON.parse(decoded), null, 4)}${RESET}`);
+};
+
+main()
+	.catch((err) => console.error(err))
+	.finally(() => process.exit());

examples/rococo/assetHub/foreignAssetTransfers/reserve/assetHubSnowbridgeETHToKhala.ts

@@ -0,0 +1,50 @@
+/**
+ * When importing from @substrate/asset-transfer-api it would look like the following
+ *
+ * import { AssetTransferApi, constructApiPromise } from '@substrate/asset-transfer-api'
+ */
+import { AssetTransferApi, constructApiPromise } from '../../../../../src';
+import { TxResult } from '../../../../../src/types';
+import { GREEN, PURPLE, RESET } from '../../../../colors';
+
+/**
+ * In this example we are creating a `polkadotXcm` pallet `transferAssets` call to send ETH (foreign asset with location `{"parents":"2","interior":{"X2":[{"GlobalConsensus":{"Ethereum":{"chainId":"11155111"}}},{"AccountKey20":{"network":null,"key":"0xfff9976782d46cc05630d1f6ebab18b2324d6b14"}}]}}`)
+ * from a Rococo Asset Hub (System Parachain) account
+ * to a Rhala Testnet (ParaChain) account, where the `xcmVersion` is set to 4, the `isLimited` option is set to true and there is no
+ * `weightLimit` option provided which declares that the tx will allow unlimited weight to be used for fees.
+ *
+ * NOTE: When `isLimited` is true it will use the `limited` version of either `reserveTransferAssets`, or `teleportAssets`.
+ */
+const main = async () => {
+	const { api, specName, safeXcmVersion } = await constructApiPromise('wss://rococo-asset-hub-rpc.polkadot.io');
+	const assetApi = new AssetTransferApi(api, specName, safeXcmVersion);
+
+	let callInfo: TxResult<'call'>;
+	try {
+		callInfo = await assetApi.createTransferTransaction(
+			'2004',
+			'5EWNeodpcQ6iYibJ3jmWVe85nsok1EDG8Kk3aFg8ZzpfY1qX',
+			[
+				`{"parents":"2","interior":{"X2":[{"GlobalConsensus":{"Ethereum":{"chainId":"11155111"}}},{"AccountKey20":{"network":null,"key":"0xfff9976782d46cc05630d1f6ebab18b2324d6b14"}}]}}`,
+			],
+			['1000000000000'],
+			{
+				format: 'call',
+				xcmVersion: 4,
+				isLimited: true,
+			},
+		);
+
+		console.log(callInfo);
+	} catch (e) {
+		console.error(e);
+		throw Error(e as string);
+	}
+
+	const decoded = assetApi.decodeExtrinsic(callInfo.tx, 'call');
+	console.log(`\n${PURPLE}The following decoded tx:\n${GREEN} ${JSON.stringify(JSON.parse(decoded), null, 4)}${RESET}`);
+};
+
+main()
+	.catch((err) => console.error(err))
+	.finally(() => process.exit());

examples/rococo/assetHub/foreignAssetTransfers/reserve/assetHubTrapistTransferAssets.ts

@@ -0,0 +1,49 @@
+// [{"parents":"1","interior":{"X1":{"Parachain":"1,836"}}}]
+/**
+ * When importing from @substrate/asset-transfer-api it would look like the following
+ *
+ * import { AssetTransferApi, constructApiPromise } from '@substrate/asset-transfer-api'
+ */
+import { AssetTransferApi, constructApiPromise } from '../../../../../src';
+import { TxResult } from '../../../../../src/types';
+import { GREEN, PURPLE, RESET } from '../../../../colors';
+
+/**
+ * In this example we are creating a `polkadotXcm` pallet `transferAssets` call to send HOP (foreign asset with location `{"parents":"1","interior":{"X1":{"Parachain":"1,836"}}}`)
+ * from a Rococo Asset Hub (System Parachain) account
+ * to a Rhala Testnet (ParaChain) account, where the `xcmVersion` is set to 4, the `isLimited` option is set to true and there is no
+ * `weightLimit` option provided which declares that the tx will allow unlimited weight to be used for fees.
+ *
+ * NOTE: When `isLimited` is true it will use the `limited` version of the either `reserveAssetTransfer`, or `teleportAssets`.
+ */
+const main = async () => {
+	const { api, specName, safeXcmVersion } = await constructApiPromise('wss://rococo-asset-hub-rpc.polkadot.io');
+	const assetApi = new AssetTransferApi(api, specName, safeXcmVersion);
+
+	let callInfo: TxResult<'call'>;
+	try {
+		callInfo = await assetApi.createTransferTransaction(
+			'2004', // Note: Parachain ID 1836 (Equilibrium) is identical to the asset location's `Parachain` Id, making this a `teleportAssets` call
+			'5EWNeodpcQ6iYibJ3jmWVe85nsok1EDG8Kk3aFg8ZzpfY1qX',
+			['{"parents":"1","interior":{"X1":{"Parachain":"1836"}}}'],
+			['1000000000000'],
+			{
+				format: 'call',
+				isLimited: true,
+				xcmVersion: 4,
+			},
+		);
+
+		console.log(callInfo);
+	} catch (e) {
+		console.error(e);
+		throw Error(e as string);
+	}
+
+	const decoded = assetApi.decodeExtrinsic(callInfo.tx, 'call');
+	console.log(`\n${PURPLE}The following decoded tx:\n${GREEN} ${JSON.stringify(JSON.parse(decoded), null, 4)}${RESET}`);
+};
+
+main()
+	.catch((err) => console.error(err))
+	.finally(() => process.exit());

examples/tsconfig.json

@@ -16,6 +16,7 @@
       ],
       "include": [
         "./*",
+        "./rococo/**/*.ts",
         "./kusama/**/*.ts",
         "./polkadot/**/*.ts",
         "../src/**/*.ts",

src/AssetTransferApi.spec.ts

@@ -64,6 +64,7 @@ describe('AssetTransferAPI', () => {
 				isDestParachain: false,
 				isOriginSystemParachain: true,
 				isOriginParachain: false,
+				isDestBridge: false,
 			};
 			const res = systemAssetsApi['establishDirection'](false, info);
 			expect(res).toEqual('SystemToSystem');
@@ -75,6 +76,7 @@ describe('AssetTransferAPI', () => {
 				isDestParachain: true,
 				isOriginSystemParachain: true,
 				isOriginParachain: false,
+				isDestBridge: false,
 			};
 			const res = systemAssetsApi['establishDirection'](false, info);
 			expect(res).toEqual('SystemToPara');
@@ -86,6 +88,7 @@ describe('AssetTransferAPI', () => {
 				isDestParachain: false,
 				isOriginSystemParachain: true,
 				isOriginParachain: false,
+				isDestBridge: false,
 			};
 			const res = systemAssetsApi['establishDirection'](false, info);
 			expect(res).toEqual('SystemToRelay');
@@ -97,6 +100,7 @@ describe('AssetTransferAPI', () => {
 				isDestParachain: true,
 				isOriginSystemParachain: false,
 				isOriginParachain: false,
+				isDestBridge: false,
 			};
 			const res = relayAssetsApi['establishDirection'](false, info);
 			expect(res).toEqual('RelayToPara');
@@ -108,6 +112,7 @@ describe('AssetTransferAPI', () => {
 				isDestParachain: false,
 				isOriginSystemParachain: false,
 				isOriginParachain: false,
+				isDestBridge: false,
 			};
 			const res = relayAssetsApi['establishDirection'](false, info);
 			expect(res).toEqual('RelayToSystem');
@@ -119,6 +124,7 @@ describe('AssetTransferAPI', () => {
 				isDestParachain: false,
 				isOriginSystemParachain: false,
 				isOriginParachain: true,
+				isDestBridge: false,
 			};
 			const res = moonriverAssetsApi['establishDirection'](false, info);
 			expect(res).toEqual('ParaToSystem');
@@ -130,6 +136,7 @@ describe('AssetTransferAPI', () => {
 				isDestParachain: true,
 				isOriginSystemParachain: false,
 				isOriginParachain: true,
+				isDestBridge: false,
 			};
 			const res = moonriverAssetsApi['establishDirection'](false, info);
 			expect(res).toEqual('ParaToPara');