@catalabs/catalyst-sdk
Version:
Catalyst AMM SDK
200 lines • 8.66 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EvmSDK = void 0;
const catalyst_channel_lists_1 = require("@catalabs/catalyst-channel-lists");
const ethers_1 = require("ethers");
const catalyst_sdk_1 = require("./catalyst-sdk");
const contracts_1 = require("./contracts");
const enums_1 = require("./enums");
const catalyst_network_enum_1 = require("./enums/catalyst-network.enum");
const evm_describers_module_1 = require("./evm/evm-describers.module");
const evm_registry_module_1 = require("./evm/evm-registry.module");
const evm_tokens_module_1 = require("./evm/evm-tokens.module");
const evm_vaults_module_1 = require("./evm/evm-vaults.module");
const channels_utils_1 = require("./utils/channels.utils");
class EvmSDK extends catalyst_sdk_1.CatalystSDK {
provider;
signer;
registryModule;
describerModule;
tokensModule;
vaultsModule;
constructor(options) {
super(options.catalystNetwork ?? catalyst_network_enum_1.CatalystNetwork.Mainnet);
this.provider = this.#getSdkProvider(options);
this.registryModule = new evm_registry_module_1.EvmRegistryModule(this);
this.describerModule = new evm_describers_module_1.EvmDescriberModule(this);
this.tokensModule = new evm_tokens_module_1.EvmTokensModule(this);
this.vaultsModule = new evm_vaults_module_1.EvmVaultsModule(this);
}
async getGasFeeData() {
return this.provider.getFeeData();
}
async getCciFeeData(toChainIds) {
const fromNetwork = await this.provider.getNetwork();
const fromChainId = fromNetwork.chainId.toString();
const registry = this.registryModule.registryAddress();
const describers = await this.registryModule.getVaultDescribers(registry);
const whitelistedCcisArrays = await Promise.all(describers.map(async (describer) => this.describerModule.getWhitelistedCcisWithVersions(describer)));
const whitelistedCcis = whitelistedCcisArrays.flat();
const cciFeeData = {};
await Promise.all(whitelistedCcis.map(async ({ address, version }) => {
const arbitraryMessagingBridge = (0, channels_utils_1.getArbitraryMessagingBridgeFromVersion)(version);
if (arbitraryMessagingBridge == null) {
return;
}
cciFeeData[arbitraryMessagingBridge] = {};
const cci = contracts_1.CrosschainInterface__factory.connect(address, this.provider);
const garpAddress = await cci.GARP();
const garp = contracts_1.Garp__factory.connect(garpAddress, this.provider);
for (const toChainId of toChainIds) {
try {
let estimate;
const wormholeAMB = (0, channels_utils_1.getArbitraryMessagingBridgeFromVersion)(enums_1.CCIVersion.Wormhole);
if (arbitraryMessagingBridge === wormholeAMB) {
estimate = await garp['estimateAdditionalCost()']();
}
else {
const chainIdentifier = (0, catalyst_channel_lists_1.getChannelIdentifier)(arbitraryMessagingBridge, fromChainId, toChainId);
if (chainIdentifier === null) {
continue;
}
estimate =
await garp['estimateAdditionalCost(bytes32)'](chainIdentifier);
}
cciFeeData[arbitraryMessagingBridge][toChainId] = {
messageVerifyGasCost: estimate,
};
}
catch (err) {
console.warn(`Unable to lookup CCI fee data for ${arbitraryMessagingBridge} from to chain ${toChainId}`);
}
}
}));
return cciFeeData;
}
async signMessage(message) {
if (!this.signer) {
throw new Error('signMessages requires a signer');
}
return this.signer.signMessage(message);
}
async signTypedData(domain, types, value) {
if (!this.signer) {
throw new Error('signTypedData requires a signer');
}
return this.signer.signTypedData(domain, types, value);
}
async deployVault(options) {
return this.vaultsModule.deployVault(options);
}
async setConnection(vault, toVault, channelId, isActive) {
return this.vaultsModule.setConnection(vault, toVault, channelId, isActive);
}
async finishSetup(vault) {
return this.vaultsModule.finishSetup(vault);
}
async sendAsset(options) {
return this.vaultsModule.sendAsset(options);
}
sendAssetWithRouter(instructions, gasAmount, options) {
return this.vaultsModule.sendAssetWithRouter(instructions, gasAmount, options);
}
estimateGasForExecuteInstructions(instructions, gasAmount, options) {
return this.vaultsModule.estimateGasForExecuteInstructions(instructions, gasAmount, options);
}
sendAssetWithRouterFromQuote(quote) {
return this.vaultsModule.sendAssetWithRouterFromQuote(quote);
}
async sendAssetFromQuote(quote, toAccount, fallbackUser, callData) {
return this.vaultsModule.sendAssetFromQuote(quote, toAccount, fallbackUser, callData);
}
async calcSendAsset(vault, from, amount) {
return this.vaultsModule.calcSendAsset(vault, from, amount);
}
async calcReceiveAsset(vault, to, units) {
return this.vaultsModule.calcReceiveAsset(vault, to, units);
}
async depositMixed(vault, tokenAmounts, minOut) {
return this.vaultsModule.depositMixed(vault, tokenAmounts, minOut);
}
async withdrawAll(vault, poolTokens, minOut) {
return this.vaultsModule.withdrawAll(vault, poolTokens, minOut);
}
async withdrawMixed(vault, poolTokens, withdrawRatio, minOut) {
return this.vaultsModule.withdrawMixed(vault, poolTokens, withdrawRatio, minOut);
}
async getUnitCapacity(vault) {
return this.vaultsModule.getUnitCapacity(vault);
}
async getBalance(address) {
return this.provider.getBalance(address);
}
async checkBalance(token, owner) {
return this.tokensModule.checkBalance(token, owner);
}
async checkBalances(tokens, owner) {
return this.tokensModule.checkBalances(tokens, owner);
}
async checkAllowance(token, owner, spender) {
return this.tokensModule.checkAllowance(token, owner, spender);
}
async increaseAllowance(token, spender, amount, options) {
return this.tokensModule.increaseAllowance(token, spender, amount, options);
}
async estimateApprovalGasFee(token, spender, amount) {
return this.tokensModule.estimateApprovalGasFee(token, spender, amount);
}
async checkPermitAmount(token, owner, spender) {
return this.tokensModule.checkPermitAmount(token, owner, spender);
}
async ensurePermit2Allowance(token, options) {
return this.tokensModule.ensurePermit2Allowance(token, options);
}
async generatePermitData(token, spender, amount) {
return this.tokensModule.generatePermitData(token, spender, amount);
}
async generatePermitBatchData(assets, spender) {
return this.tokensModule.generatePermitBatchData(assets, spender);
}
async signPermitBatchTransferFrom(permit, witness) {
return this.tokensModule.signPermitBatchTransferFrom(permit, witness);
}
async revoke(token, spender) {
return this.tokensModule.revoke(token, spender);
}
updateProvider(options) {
this.provider = this.#getSdkProvider(options);
}
async connectSigner(signer) {
try {
this.signer = signer;
this.address = await signer.getAddress();
}
catch (err) {
console.error(err);
}
}
#getSdkProvider(options) {
const { provider, network } = options;
let sdkProvider;
if (typeof provider === 'string') {
sdkProvider = new ethers_1.JsonRpcProvider(provider, network, {
staticNetwork: true,
});
}
else {
sdkProvider = provider;
}
return sdkProvider;
}
async ensureAllowance(token, owner, spender, amount, options) {
return this.tokensModule.ensureAllowance(token, owner, spender, amount, options);
}
async getChainId() {
const network = await this.provider.getNetwork();
return Number(network.chainId.toString());
}
}
exports.EvmSDK = EvmSDK;
//# sourceMappingURL=evm-sdk.js.map