@airgap/bnb 0.13.45-beta.6

package/v1/module.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+var BnbModule_1 = require("./module/BnbModule");
+__exportStar(require("./index"), exports);
+function create() {
+    return new BnbModule_1.BnbModule();
+}
+exports.create = create;
+//# sourceMappingURL=module.js.map

package/v1/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../src/v1/module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AACA,gDAA8C;AAE9C,0CAAuB;AAEvB,SAAgB,MAAM;IACpB,OAAO,IAAI,qBAAS,EAAE,CAAA;AACxB,CAAC;AAFD,wBAEC"}

package/v1/protocol/BnbBaseProtocol.d.ts

@@ -0,0 +1,58 @@
+import { EthereumBaseProtocolImpl, EthereumUnits } from '@airgap/ethereum/v1';
+import { Address, AirGapProtocol, AirGapTransaction, AirGapTransactionStatus, AirGapTransactionsWithCursor, Amount, Balance, CryptoDerivative, ExtendedKeyPair, ExtendedPublicKey, ExtendedSecretKey, FeeDefaults, KeyPair, ProtocolMetadata, ProtocolUnitsMetadata, PublicKey, SecretKey, Signature, TransactionFullConfiguration, TransactionDetails, WalletConnectRequest, TokenDetails } from '@airgap/module-kit';
+import { BnbInfoClient } from '../client/info/BnbinfoClient';
+import { BnbNodeClient } from '../client/node/BnbNodeClient';
+import { BnbCryptoConfiguration } from '../types/crypto';
+import { BnbProtocolNetwork, BnbProtocolOptions } from '../types/protocol';
+import { BnbSignedTransaction, BnbTransactionCursor, BnbUnsignedTransaction } from '../types/transaction';
+export interface BnbBaseProtocol<_Units extends string = EthereumUnits> extends AirGapProtocol<{
+    AddressResult: Address;
+    ProtocolNetwork: BnbProtocolNetwork;
+    CryptoConfiguration: BnbCryptoConfiguration;
+    Units: _Units;
+    FeeUnits: EthereumUnits;
+    FeeEstimation: FeeDefaults<EthereumUnits>;
+    SignedTransaction: BnbSignedTransaction;
+    UnsignedTransaction: BnbUnsignedTransaction;
+    TransactionCursor: BnbTransactionCursor;
+}, 'Bip32', 'Crypto', 'FetchDataForAddress', 'FetchDataForMultipleAddresses', 'GetTokenBalances', 'TransactionStatusChecker', 'WalletConnect'> {
+}
+export declare abstract class BnbBaseProtocolImpl<_Units extends string = EthereumUnits, _EthereumProtocol extends EthereumBaseProtocolImpl<_Units, BnbProtocolNetwork> = EthereumBaseProtocolImpl<_Units, BnbProtocolNetwork>, _Options extends BnbProtocolOptions = BnbProtocolOptions> implements BnbBaseProtocol<_Units> {
+    protected readonly ethereumProtocol: _EthereumProtocol;
+    protected readonly nodeClient: BnbNodeClient;
+    protected readonly infoClient: BnbInfoClient;
+    protected readonly options: _Options;
+    protected constructor(ethereumProtocol: _EthereumProtocol, nodeClient: BnbNodeClient, infoClient: BnbInfoClient, options: _Options);
+    protected readonly units: ProtocolUnitsMetadata<_Units>;
+    protected readonly feeUnits: ProtocolUnitsMetadata<EthereumUnits>;
+    getMetadata(): Promise<ProtocolMetadata<_Units, EthereumUnits>>;
+    getAddressFromPublicKey(publicKey: PublicKey | ExtendedPublicKey): Promise<string>;
+    deriveFromExtendedPublicKey(extendedPublicKey: ExtendedPublicKey, visibilityIndex: number, addressIndex: number): Promise<PublicKey>;
+    getDetailsFromTransaction(transaction: BnbUnsignedTransaction | BnbSignedTransaction, publicKey: PublicKey | ExtendedPublicKey): Promise<AirGapTransaction<_Units, EthereumUnits>[]>;
+    verifyMessageWithPublicKey(message: string, signature: Signature, publicKey: PublicKey | ExtendedPublicKey): Promise<boolean>;
+    encryptAsymmetricWithPublicKey(payload: string, publicKey: PublicKey | ExtendedPublicKey): Promise<string>;
+    getCryptoConfiguration(): Promise<BnbCryptoConfiguration>;
+    getKeyPairFromDerivative(derivative: CryptoDerivative): Promise<KeyPair>;
+    getExtendedKeyPairFromDerivative(derivative: CryptoDerivative): Promise<ExtendedKeyPair>;
+    deriveFromExtendedSecretKey(extendedSecretKey: ExtendedSecretKey, visibilityIndex: number, addressIndex: number): Promise<SecretKey>;
+    signTransactionWithSecretKey(transaction: BnbUnsignedTransaction, secretKey: SecretKey | ExtendedSecretKey): Promise<BnbSignedTransaction>;
+    signMessageWithKeyPair(message: string, keyPair: KeyPair | ExtendedKeyPair): Promise<Signature>;
+    decryptAsymmetricWithKeyPair(payload: string, keyPair: KeyPair | ExtendedKeyPair): Promise<string>;
+    encryptAESWithSecretKey(payload: string, secretKey: SecretKey | ExtendedSecretKey): Promise<string>;
+    decryptAESWithSecretKey(payload: string, secretKey: SecretKey | ExtendedSecretKey): Promise<string>;
+    getNetwork(): Promise<BnbProtocolNetwork>;
+    getTransactionsForPublicKey(publicKey: PublicKey | ExtendedPublicKey, limit: number, cursor?: BnbTransactionCursor): Promise<AirGapTransactionsWithCursor<BnbTransactionCursor, _Units, EthereumUnits>>;
+    getTransactionsForAddress(address: string, limit: number, cursor?: BnbTransactionCursor): Promise<AirGapTransactionsWithCursor<BnbTransactionCursor, _Units, EthereumUnits>>;
+    getTransactionsForAddresses(addresses: string[], limit: number, cursor?: BnbTransactionCursor): Promise<AirGapTransactionsWithCursor<BnbTransactionCursor, _Units, EthereumUnits>>;
+    getTransactionStatus(transactionIds: string[]): Promise<Record<string, AirGapTransactionStatus>>;
+    getBalanceOfPublicKey(publicKey: PublicKey | ExtendedPublicKey): Promise<Balance<_Units>>;
+    getBalanceOfAddress(address: string): Promise<Balance<_Units>>;
+    getBalanceOfAddresses(addresses: string[]): Promise<Balance<_Units>>;
+    getTokenBalancesOfPublicKey(publicKey: PublicKey | ExtendedPublicKey, tokens: TokenDetails[]): Promise<Record<string, Amount>>;
+    getTransactionMaxAmountWithPublicKey(publicKey: PublicKey | ExtendedPublicKey, to: string[], configuration?: TransactionFullConfiguration<EthereumUnits>): Promise<Amount<_Units>>;
+    getTransactionFeeWithPublicKey(publicKey: PublicKey | ExtendedPublicKey, details: TransactionDetails<_Units>[]): Promise<FeeDefaults<EthereumUnits>>;
+    prepareTransactionWithPublicKey(publicKey: PublicKey | ExtendedPublicKey, details: TransactionDetails<_Units>[], configuration?: TransactionFullConfiguration<EthereumUnits>): Promise<BnbUnsignedTransaction>;
+    getWalletConnectChain(): Promise<string>;
+    prepareWalletConnectTransactionWithPublicKey(publicKey: PublicKey | ExtendedPublicKey, request: WalletConnectRequest): Promise<BnbUnsignedTransaction>;
+    broadcastTransaction(transaction: BnbSignedTransaction): Promise<string>;
+}

package/v1/protocol/BnbBaseProtocol.js

@@ -0,0 +1,265 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BnbBaseProtocolImpl = void 0;
+// Implementation
+var BnbBaseProtocolImpl = /** @class */ (function () {
+    function BnbBaseProtocolImpl(ethereumProtocol, nodeClient, infoClient, options) {
+        this.ethereumProtocol = ethereumProtocol;
+        this.nodeClient = nodeClient;
+        this.infoClient = infoClient;
+        this.options = options;
+        this.units = this.ethereumProtocol.units;
+        this.feeUnits = this.ethereumProtocol.feeUnits;
+    }
+    BnbBaseProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getMetadata()];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getAddressFromPublicKey(publicKey)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.deriveFromExtendedPublicKey = function (extendedPublicKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.deriveFromExtendedPublicKey(extendedPublicKey, visibilityIndex, addressIndex)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getDetailsFromTransaction(transaction, publicKey)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.verifyMessageWithPublicKey(message, signature, publicKey)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.encryptAsymmetricWithPublicKey(payload, publicKey)];
+            });
+        });
+    };
+    // Offline
+    BnbBaseProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getCryptoConfiguration()];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getKeyPairFromDerivative(derivative)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getExtendedKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getExtendedKeyPairFromDerivative(derivative)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.deriveFromExtendedSecretKey = function (extendedSecretKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.deriveFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.signTransactionWithSecretKey(transaction, secretKey)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.signMessageWithKeyPair(message, keyPair)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.decryptAsymmetricWithKeyPair(payload, keyPair)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.encryptAESWithSecretKey(payload, secretKey)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.decryptAESWithSecretKey(payload, secretKey)];
+            });
+        });
+    };
+    // Online
+    BnbBaseProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getNetwork()];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getTransactionsForPublicKey(publicKey, limit, cursor)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getTransactionsForAddress(address, limit, cursor)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getTransactionsForAddresses = function (addresses, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getTransactionsForAddresses(addresses, limit, cursor)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getTransactionStatus = function (transactionIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getTransactionStatus(transactionIds)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getBalanceOfPublicKey(publicKey)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getBalanceOfAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getBalanceOfAddress(address)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getBalanceOfAddresses(addresses)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getTokenBalancesOfPublicKey = function (publicKey, tokens) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getTokenBalancesOfPublicKey(publicKey, tokens)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getTransactionMaxAmountWithPublicKey(publicKey, to, configuration)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getTransactionFeeWithPublicKey(publicKey, details)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.prepareTransactionWithPublicKey(publicKey, details, configuration)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.getWalletConnectChain = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getWalletConnectChain()];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.prepareWalletConnectTransactionWithPublicKey = function (publicKey, request) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.prepareWalletConnectTransactionWithPublicKey(publicKey, request)];
+            });
+        });
+    };
+    BnbBaseProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.broadcastTransaction(transaction)];
+            });
+        });
+    };
+    return BnbBaseProtocolImpl;
+}());
+exports.BnbBaseProtocolImpl = BnbBaseProtocolImpl;
+//# sourceMappingURL=BnbBaseProtocol.js.map

package/v1/protocol/BnbBaseProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BnbBaseProtocol.js","sourceRoot":"","sources":["../../../src/v1/protocol/BnbBaseProtocol.ts"],"names":[],"mappings":"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"}

package/v1/protocol/BnbProtocol.d.ts

@@ -0,0 +1,8 @@
+import { RecursivePartial } from '@airgap/module-kit';
+import { BnbProtocolNetwork, BnbProtocolOptions } from '../types/protocol';
+import { BnbBaseProtocol } from './BnbBaseProtocol';
+export interface BnbProtocol extends BnbBaseProtocol {
+}
+export declare function createBnbProtocol(options?: RecursivePartial<BnbProtocolOptions>): BnbProtocol;
+export declare const BNB_MAINNET_PROTOCOL_NETWORK: BnbProtocolNetwork;
+export declare function createBnbProtocolOptions(network?: Partial<BnbProtocolNetwork>): BnbProtocolOptions;

package/v1/protocol/BnbProtocol.js

@@ -0,0 +1,84 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBnbProtocolOptions = exports.BNB_MAINNET_PROTOCOL_NETWORK = exports.createBnbProtocol = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var v1_1 = require("@airgap/ethereum/v1");
+var module_kit_1 = require("@airgap/module-kit");
+var HttpBnbNodeClient_1 = require("../client/node/HttpBnbNodeClient");
+var BnbBaseProtocol_1 = require("./BnbBaseProtocol");
+// Implementation
+var BnbProtocolImpl = /** @class */ (function (_super) {
+    __extends(BnbProtocolImpl, _super);
+    function BnbProtocolImpl(options) {
+        var completeOptions = createBnbProtocolOptions(options.network);
+        var nodeClient = new HttpBnbNodeClient_1.HttpBnbNodeClient(completeOptions.network.rpcUrl);
+        var infoClient = new v1_1.EtherscanInfoClient(completeOptions.network.blockExplorerApi);
+        var baseProtocolOptions = {
+            network: completeOptions.network,
+            identifier: coinlib_core_1.MainProtocolSymbols.BNB,
+            name: 'BNB Smart Chain',
+            units: __assign(__assign({}, v1_1.DEFAULT_ETHEREUM_UNITS_METADATA), { ETH: {
+                    symbol: __assign(__assign({}, v1_1.DEFAULT_ETHEREUM_UNITS_METADATA.ETH.symbol), { asset: 'BNB' }),
+                    decimals: v1_1.DEFAULT_ETHEREUM_UNITS_METADATA.ETH.decimals
+                } }),
+            mainUnit: 'ETH',
+            feeDefaults: {
+                low: (0, module_kit_1.newAmount)(63000 /* 21000 GAS * 3 GWEI */, 'GWEI').blockchain(v1_1.DEFAULT_ETHEREUM_UNITS_METADATA),
+                medium: (0, module_kit_1.newAmount)(105000 /* 21000 GAS * 5 GWEI */, 'GWEI').blockchain(v1_1.DEFAULT_ETHEREUM_UNITS_METADATA),
+                high: (0, module_kit_1.newAmount)(210000 /* 21000 GAS * 10 GWEI */, 'GWEI').blockchain(v1_1.DEFAULT_ETHEREUM_UNITS_METADATA)
+            }
+        };
+        var ethereumProtocol = new v1_1.EthereumBaseProtocolImpl(nodeClient, infoClient, baseProtocolOptions);
+        return _super.call(this, ethereumProtocol, nodeClient, infoClient, completeOptions) || this;
+    }
+    return BnbProtocolImpl;
+}(BnbBaseProtocol_1.BnbBaseProtocolImpl));
+// Factory
+function createBnbProtocol(options) {
+    if (options === void 0) { options = {}; }
+    return new BnbProtocolImpl(options);
+}
+exports.createBnbProtocol = createBnbProtocol;
+exports.BNB_MAINNET_PROTOCOL_NETWORK = {
+    name: 'Mainnet',
+    type: 'mainnet',
+    rpcUrl: 'https://bsc-dataseed.binance.org',
+    chainId: 56,
+    blockExplorerUrl: 'https://bscscan.com',
+    blockExplorerApi: 'https://api.bscscan.com/api'
+};
+var DEFAULT_BNB_PROTOCOL_NETWORK = exports.BNB_MAINNET_PROTOCOL_NETWORK;
+function createBnbProtocolOptions(network) {
+    if (network === void 0) { network = {}; }
+    return {
+        network: __assign(__assign({}, DEFAULT_BNB_PROTOCOL_NETWORK), network)
+    };
+}
+exports.createBnbProtocolOptions = createBnbProtocolOptions;
+//# sourceMappingURL=BnbProtocol.js.map

package/v1/protocol/BnbProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BnbProtocol.js","sourceRoot":"","sources":["../../../src/v1/protocol/BnbProtocol.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qDAA0D;AAC1D,0CAM4B;AAC5B,iDAAgE;AAEhE,sEAAoE;AAGpE,qDAAwE;AAMxE,iBAAiB;AAEjB;IAA8B,mCAAmB;IAC/C,yBAAY,OAA6C;QACvD,IAAM,eAAe,GAAG,wBAAwB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QAEjE,IAAM,UAAU,GAAG,IAAI,qCAAiB,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QACxE,IAAM,UAAU,GAAG,IAAI,wBAAmB,CAAC,eAAe,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAA;QAEpF,IAAM,mBAAmB,GAAmE;YAC1F,OAAO,EAAE,eAAe,CAAC,OAAO;YAEhC,UAAU,EAAE,kCAAmB,CAAC,GAAG;YACnC,IAAI,EAAE,iBAAiB;YAEvB,KAAK,wBACA,oCAA+B,KAClC,GAAG,EAAE;oBACH,MAAM,wBAAO,oCAA+B,CAAC,GAAG,CAAC,MAAM,KAAE,KAAK,EAAE,KAAK,GAAE;oBACvE,QAAQ,EAAE,oCAA+B,CAAC,GAAG,CAAC,QAAQ;iBACvD,GACF;YACD,QAAQ,EAAE,KAAK;YAEf,WAAW,EAAE;gBACX,GAAG,EAAE,IAAA,sBAAS,EAAC,KAAK,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,oCAA+B,CAAC;gBAClG,MAAM,EAAE,IAAA,sBAAS,EAAC,MAAM,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,oCAA+B,CAAC;gBACtG,IAAI,EAAE,IAAA,sBAAS,EAAC,MAAM,CAAC,yBAAyB,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,oCAA+B,CAAC;aACtG;SACF,CAAA;QAED,IAAM,gBAAgB,GAAG,IAAI,6BAAwB,CAAC,UAAU,EAAE,UAAU,EAAE,mBAAmB,CAAC,CAAA;eAElG,kBAAM,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,CAAC;IAClE,CAAC;IACH,sBAAC;AAAD,CAAC,AAjCD,CAA8B,qCAAmB,GAiChD;AAED,UAAU;AAEV,SAAgB,iBAAiB,CAAC,OAAkD;IAAlD,wBAAA,EAAA,YAAkD;IAClF,OAAO,IAAI,eAAe,CAAC,OAAO,CAAC,CAAA;AACrC,CAAC;AAFD,8CAEC;AAEY,QAAA,4BAA4B,GAAuB;IAC9D,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,kCAAkC;IAC1C,OAAO,EAAE,EAAE;IACX,gBAAgB,EAAE,qBAAqB;IACvC,gBAAgB,EAAE,6BAA6B;CAChD,CAAA;AAED,IAAM,4BAA4B,GAAuB,oCAA4B,CAAA;AAErF,SAAgB,wBAAwB,CAAC,OAAyC;IAAzC,wBAAA,EAAA,YAAyC;IAChF,OAAO;QACL,OAAO,wBAAO,4BAA4B,GAAK,OAAO,CAAE;KACzD,CAAA;AACH,CAAC;AAJD,4DAIC"}

package/v1/protocol/erc20/ERC20Token.d.ts

@@ -0,0 +1,20 @@
+import { ERC20TokenMetadata, ERC20TokenOptions, EthereumProtocolNetwork } from '@airgap/ethereum/v1';
+import { AirGapInterface, RecursivePartial } from '@airgap/module-kit';
+import { BnbProtocolNetwork, BnbProtocolOptions } from '../../types/protocol';
+import { BnbBaseProtocol } from '../BnbBaseProtocol';
+export interface ERC20Token extends AirGapInterface<BnbBaseProtocol<string>, 'SingleTokenSubProtocol'> {
+    name(): Promise<string | undefined>;
+    symbol(): Promise<string | undefined>;
+    decimals(): Promise<number | undefined>;
+    tokenMetadata(): Promise<ERC20TokenMetadata>;
+}
+export declare function createERC20Token(metadata: ERC20TokenMetadata, options?: RecursivePartial<BnbProtocolOptions>): ERC20Token;
+export declare const BNB_ERC20_MAINNET_PROTOCOL_NETWORK: BnbProtocolNetwork;
+export declare function createERC20TokenOptions(metadata: ERC20TokenMetadata, network?: Partial<EthereumProtocolNetwork>): ERC20TokenOptions<BnbProtocolNetwork>;
+export interface SerializedERC20Token {
+    metadata: ERC20TokenMetadata;
+    network: BnbProtocolNetwork;
+}
+export declare function serializeERC20Token(erc20Token: ERC20Token): Promise<SerializedERC20Token>;
+export declare function deserializeERC20Token(serialized: SerializedERC20Token): ERC20Token;
+export declare function isSerializedERC20Token(serialized: unknown): serialized is SerializedERC20Token;