@avalabs/bridge-unified 2.1.1 → 3.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+Copyright (C) 2021, Ava Labs, Inc. All rights reserved.
+
+Subject to the limited license below (**”License””), you may not, and you may not permit anyone else to, copy, reproduce, aggregate, republish, download, post, distribute, license, sublicense, reverse engineer, modify, or create derivative works based on this software (collectively, **“Software”**). 
+
+You are hereby granted a limited, non-exclusive, non-sublicensable and non-transferable license to download and use the Software as-is solely (i) for use in connection with the Avalanche Public Blockchain platform, having a NetworkID of 1 (Mainnet) or 5 (Fuji), and associated blockchains, comprised exclusively of the Avalanche X-Chain, C-Chain, P-Chain and any subnets linked to the P-Chain (**“Avalanche Authorized Platform”**) or (ii) for non-production, testing or research purposes without any commercial application within the Avalanche ecosystem (**“Non-Commercial Use”**); provided that, in each case, you may not use or allow use of the Software (a) in connection with any forks of the Avalanche Authorized Platform, (b) in any manner not operationally connected to the Avalanche Authorized Platform other than for Non-Commercial Use, or (c) to the extent the number of monthly active users or the number of total installs of any software that uses the Software across all versions thereof exceeds 10,000 at any time. You may not modify or alter the Software in any way.
+
+You hereby acknowledge and agree to the terms set forth at www.avalabs.org/important-notice.
+
+**TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED ON AN “AS IS” BASIS, AND AVA LABS EXPRESSLY DISCLAIMS AND EXCLUDES ALL REPRESENTATIONS, WARRANTIES AND OTHER TERMS AND CONDITIONS, WHETHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION BY OPERATION OF LAW OR BY CUSTOM, STATUTE OR OTHERWISE, AND INCLUDING, BUT NOT LIMITED TO, ANY IMPLIED WARRANTY, TERM, OR CONDITION OF NON-INFRINGEMENT, MERCHANTABILITY, TITLE, OR FITNESS FOR PARTICULAR PURPOSE. YOU USE THE SOFTWARE AT YOUR OWN RISK. AVA LABS EXPRESSLY DISCLAIMS ALL LIABILITY (INCLUDING FOR ALL DIRECT, CONSEQUENTIAL OR OTHER DAMAGES OR LOSSES) RELATED TO ANY USE OF THE SOFTWARE.**

package/README.md

@@ -16,7 +16,7 @@ The bridging ecosystem is complex. There are often multiple tools that can be us
 
 These are the bridges we currently support:
 
-- **CCTP** - preferred for brdiging USDC between Ethereum and Avalanche C-Chain. See the `bridges/cctp` folder.
+- **CCTP** - preferred for bridging USDC between Ethereum and Avalanche C-Chain. See the `bridges/cctp` folder.
 
 Future bridges we plan to support:
 
@@ -37,16 +37,75 @@ Future bridges we plan to support:
 ## Usage
 
 ```js
-import { createUnifiedBridgeService, Environment, BridgeTransfer } from '@avalabs/bridge-unified';
-
-// create a new service for an environment
+import { createUnifiedBridgeService, getEnabledBridgeServices, Environment, BridgeTransfer } from '@avalabs/bridge-unified';
+
+const environment = Environment.TEST;
+const evmSigner: EvmSigner = {
+  sign: async ({ data, from, to, value }) => {
+    return await window.ethereum.request({
+      method: 'eth_sendTransaction,',
+      params:{
+        account: from,
+        data: data ?? undefined,
+        from,
+        to: to ?? null,
+        chain: undefined,
+        value
+      }
+    });
+  },
+};
+
+const btcSigner: BtcSigner = {
+  sign: async ({ inputs, outputs }) => {
+    return await window.ethereum.request({
+      method: 'bitcoin_signTransaction',
+      params: { inputs, outputs },
+    });
+  },
+};
+
+const cctpInitializer: EvmBridgeInitializer = {
+  type: BridgeType.CCTP,
+  signer: evmSigner,
+};
+const icttErc20Initializer: EvmBridgeInitializer = {
+  type: BridgeType.ICTT_ERC20_ERC20,
+  signer: evmSigner,
+};
+const avalancheEvmInitializer: EvmBridgeInitializer = {
+  type: BridgeType.AVALANCHE_EVM,
+  signer: evmSigner,
+};
+const avalancheBtcInitializer: AvaToBtcBridgeInitializer = {
+  type: BridgeType.AVALANCHE_AVA_BTC,
+  signer: evmSigner,
+  bitcoinFunctions: bitcoinProvider as BitcoinFunctions,
+};
+const bitcoinAvaInitializer: BtcToAvaBridgeInitializer = {
+  type: BridgeType.AVALANCHE_BTC_AVA,
+  signer: btcSigner,
+  bitcoinFunctions: bitcoinProvider as BitcoinFunctions,
+};
+
+// use all available bridges
+const enabledBridgeInitializers: BridgeInitializer[] = [
+  cctpInitializer,
+  icttErc20Initializer,
+  avalancheEvmInitializer,
+  avalancheBtcInitializer,
+  bitcoinAvaInitializer,
+]
+
+// fetch all available bridge services
+const enabledBridgeServices = await getEnabledBridgeServices(environment, disabledBridgeTypes);
+
+// create a new service for a given environment and list of bridge services
 const unifiedService = createUnifiedBridgeService({
-  environment: Environment.TEST,
+  environment,
+  enabledBridgeServices
 });
 
-// init the service, fetch and setup its configs
-await unifiedService.init();
-
 // get the list of supported assets, grouped by caip2 (https://chainagnostic.org/CAIPs/caip-2) chain IDs
 const assets = await unifiedService.getAssets()
 
@@ -64,7 +123,7 @@ const updateListener = (transfer: BridgeTransfer) => {
 // start tracking the transfer's state. whenever the state changes, it will call the provided `updateListener`
 const { cancel, result } = await unifiedService.trackTransfer({bridgeTransfer, updateListener, ...})
 
-// immediatelly stops tracking and rejects the tracker's promise
+// immediately stops tracking and rejects the tracker's promise
 // cancel()
 
 // wait for the transfer to finish and get its final state
@@ -73,9 +132,11 @@ const finalizedBridgeTransfer = await result
 
 ## API
 
-### createUnifiedBridgeService({ environment, disabledBridgeTypes? })
+### getEnabledBridgeServices(environment, enabledBridgeInitializers);
 
-Returns a new `unifiedBridgeService` for the given `environment`, using all supported bridge integrations by default. Individual bridges can be turned off via the `disabledBridgeTypes` array.
+Type: `(environment: Environment, enabledBridgeInitializers: BridgeInitializer[]) => Promise<BridgeServicesMap>`
+
+Returns all available bridge services for a given environment (excluding disabledBridgeTypes). Any bridge service which fails to initialize will be absent from this returned value.
 
 #### environment
 
@@ -83,11 +144,21 @@ Type: `Environment`
 
 Defines if the bridge service should use `testnet` or `mainnet`.
 
-#### disabledBridgeTypes
+#### enabledBridgeInitializers
+
+Type: `BridgeInitializer[]`
+
+Enables the integration of the provided `BridgeType`s based on each `BridgeInitializer`.
+
+#### enabledBridgeServices
+
+Type: `BridgeServicesMap` => `Map<BridgeType, BridgeService>`
 
-Type: `BridgeType[] | undefined`
+This includes all the bridge services which were initialized successfully, to pass to `createUnifiedBridgeService`.
 
-Disables the integration of the provided `BridgeType`s.
+### createUnifiedBridgeService({ environment, enabledBridgeServices })
+
+Returns a new `unifiedBridgeService` for the given `environment` and `enabledBridgeServices` map.
 
 ### unifiedBridgeService
 
@@ -97,28 +168,15 @@ Automatically picks the right (enabled) bridge integration to use based on the p
 ```js
 {
   environment, // the provided Environment during initialization
-  bridges, // the list of enabled bridge integrations
-  init,
-  updateConfigs,
   getAssets,
   getFees,
+  estimateGas,
+  canTransferAsset,
   transferAsset,
   trackTransfer,
 }
 ```
 
-#### init
-
-Type: `() => Promise<void>`
-
-Initializes the unified service by attempting to fetch the configurations of the enabled bridges.
-
-#### updateConfigs
-
-Type: `() => Promise<void>`
-
-Attempts to fetch the configurations of the enabled bridges.
-
 #### getAssets
 
 Type: `() => Promise<ChainAssetMap>`
@@ -131,14 +189,40 @@ Type: `(params: FeeParams) => Promise<AssetFeeMap>`
 
 Calculates and returns the bridge fees in `tokenAddress` - `amount` pairs for a given bridge transfer.
 
+#### estimateGas
+
+Type: `(params: TransferParams) => Promise<bigint>`
+
+Estimates the gas cost of a specific transfer.
+
+#### getMinimumTransferAmount
+
+Type: `(params: FeeParams) => Promise<bigint>`
+
+Calculates and returns the minimum transfer amount for a given bridge transfer.
+
 #### transferAsset
 
 Type: `(params: TransferParams) => Promise<BridgeTransfer>`
 
 Starts a new bridge transfer, executing every required step in a single call.
-Transactions signing is done by either the provided `sourceProvider` or a custom `sign` callback. Clients using their custom `sign` implementation may use their own solution or the default `dispatch` callback to submit the transaction to the network.
+Transactions signing is done by a custom `sign` callback. The custom `sign` implementation may use their own solution or the default `dispatch` callback to submit the transaction to the network.
 Returns a `BridgeTransfer` containing all the (known) initial values such as: environment, addresses, amount, fee, transaction hash, required and actual block confirmation counts, etc.
 
+Notes about TransferParams:
+fromAddress: The address where the bridge amount is from.
+
+toAddress: The address where the bridge amount is going to end up.
+
+For example, A user has an account with AddressC and AddressBtc.
+The user wants to bridge some funds from Ethereum to Avalanche using the same address. FromAddress and toAddress will be both AddressC.
+
+The user wants to bridge some funds from Bitcoin to Avalanche.
+FromAddress is AddressBtc and toAddress is AddressC.
+
+Some bridges allows you to bridge the tokens to a different address. (CCTP and ICTT ERC20).
+In this case, fromAddress is the address of the token is getting bridged from. And toAddress is the address which is going to receive the bridged funds.
+
 #### trackTransfer
 
 Type: `(params: TrackingParams) => ({cancel, result})`
@@ -149,7 +233,7 @@ Tracks the given `BridgeTransfer`'s progress and invokes the provided listener c
 
 Type: `() => void`
 
-If it's still pending, rejects the tracker's promise (`result`) immediatelly and breaks its loop under the hood.
+If it's still pending, rejects the tracker's promise (`result`) immediately and breaks its loop under the hood.
 
 ###### result