@collabland/staking-contracts/dist/staking.js

Staking contracts supported by Collab.Land

// Copyright Abridged, Inc. 2022. All Rights Reserved.
// Node module: @collabland/staking-contracts
// This file is licensed under the MIT License.
// License text available at https://opensource.org/licenses/MIT
import { __decorate, __metadata } from "tslib";
import { AssetType } from '@collabland/chain';
import { getEnvVar } from '@collabland/common';
import { inject } from '@loopback/core';
import { BigNumber, providers } from 'ethers';
import { ETHERS_PROVIDER_SERVICE } from './keys.js';
export { StakingAsset, StakingContractMetadata } from './models/staking.model.js';
const defaultEthersProviderService = {
    getProvider(chainId) {
        if (chainId.toString() === '56') {
            return new providers.JsonRpcProvider('https://bsc-dataseed.binance.org/');
        }
        if (chainId.toString() === '81457') {
            return new providers.JsonRpcProvider('https://rpc.blast.io');
        }
        const projectId = getEnvVar('INFURA_PROJECT_ID') ?? getEnvVar('STAKING_INFURA_PROJECT_ID');
        const projectSecret = getEnvVar('INFURA_PROJECT_SECRET');
        if (projectId == null) {
            return providers.getDefaultProvider(chainId);
        }
        else {
            return new providers.InfuraProvider(chainId, { projectId, projectSecret });
        }
    },
};
/**
 * Base class for staking contract adapters
 */
export class BaseStakingContractAdapter {
    constructor() {
        this.providerService = defaultEthersProviderService;
        this.chainId = 1;
    }
    get provider() {
        if (this._provider)
            return this._provider;
        this._provider = this.providerService.getProvider(this.chainId);
        return this.provider;
    }
    async isAssetSupported(assetName) {
        return this.supportedAssets.some(a => a.asset.toLowerCase() === assetName.toLowerCase());
    }
    getStakingAsset(nameOrAssetType) {
        const assetType = nameOrAssetType?.toLowerCase();
        let asset = this.supportedAssets.find(a => a.name?.toLowerCase() === assetType ||
            a.asset.toLowerCase() === assetType);
        if (asset != null)
            return asset;
        // Find the asset that doesn't have a name
        asset = this.supportedAssets.find(a => a.name == null);
        if (asset != null)
            return asset;
        return this.supportedAssets[0];
    }
    getStakingAssetType(name) {
        const asset = this.getStakingAsset(name);
        if (asset == null)
            return undefined;
        return new AssetType({
            chainId: {
                namespace: 'evm',
                reference: this.chainId.toString(),
            },
            assetName: asset.asset,
        });
    }
    async getStakedTokenBalance(owner, assetName) {
        const ids = await this.getStakedTokenIds(owner, assetName);
        return BigNumber.from(ids.length);
    }
    async getStakedTokenIds(owner, assetName) {
        return [];
    }
}
__decorate([
    inject(ETHERS_PROVIDER_SERVICE, { optional: true }),
    __metadata("design:type", Object)
], BaseStakingContractAdapter.prototype, "providerService", void 0);
//# sourceMappingURL=staking.js.map