@clonegod/ttd-sol-common 1.0.12 → 1.0.14

package/dist/helius_sdk_v1.4.0/RpcClient.js

@@ -0,0 +1,639 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+const axios_1 = __importDefault(require("axios"));
+const types_1 = require("./types");
+class RpcClient {
+    constructor(connection, id) {
+        this.connection = connection;
+        this.id = id;
+    }
+    airdrop(publicKey, lamports, commitment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signature = yield this.connection.requestAirdrop(publicKey, lamports);
+            const blockhashWithExpiryBlockHeight = yield this.getLatestBlockhash();
+            const confirmResponse = yield this.connection.confirmTransaction(Object.assign({ signature }, blockhashWithExpiryBlockHeight), commitment);
+            return Object.assign({ signature, confirmResponse }, blockhashWithExpiryBlockHeight);
+        });
+    }
+    getLatestBlockhash() {
+        return __awaiter(this, arguments, void 0, function* (commitmentOrConfig = 'finalized') {
+            return this.connection.getLatestBlockhash(commitmentOrConfig);
+        });
+    }
+    getCurrentTPS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const samples = yield this.connection.getRecentPerformanceSamples(1);
+                return ((_a = samples[0]) === null || _a === void 0 ? void 0 : _a.numTransactions) / ((_b = samples[0]) === null || _b === void 0 ? void 0 : _b.samplePeriodSecs);
+            }
+            catch (e) {
+                throw new Error(`error calling getCurrentTPS: ${e}`);
+            }
+        });
+    }
+    getStakeAccounts(wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.connection.getParsedProgramAccounts(new web3_js_1.PublicKey('Stake11111111111111111111111111111111111111'), {
+                    filters: [
+                        {
+                            dataSize: 200,
+                        },
+                        {
+                            memcmp: {
+                                offset: 44,
+                                bytes: wallet,
+                            },
+                        },
+                    ],
+                });
+            }
+            catch (e) {
+                throw new Error(`error calling getStakeAccounts: ${e}`);
+            }
+        });
+    }
+    getTokenHolders(mintAddress) {
+        try {
+            return this.connection.getParsedProgramAccounts(new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'), {
+                filters: [
+                    {
+                        dataSize: 165,
+                    },
+                    {
+                        memcmp: {
+                            offset: 0,
+                            bytes: mintAddress,
+                        },
+                    },
+                ],
+            });
+        }
+        catch (e) {
+            throw new Error(`error calling getTokenHolders: ${e}`);
+        }
+    }
+    getAsset(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getAsset',
+                    params,
+                }, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+                const { result } = response.data;
+                return result;
+            }
+            catch (error) {
+                throw new Error(`Error in getAsset: ${error}`);
+            }
+        });
+    }
+    getRwaAsset(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getRwaAccountsByMint',
+                    params,
+                }, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+                const { result } = response.data;
+                return result;
+            }
+            catch (error) {
+                throw new Error(`Error in getRwaAsset: ${error}`);
+            }
+        });
+    }
+    getAssetBatch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getAssetBatch',
+                    params,
+                });
+                return response.data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in getAssetBatch: ${error}`);
+            }
+        });
+    }
+    getAssetProof(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getAssetProof',
+                    params,
+                });
+                const { data } = response;
+                return data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in getAssetProof: ${error}`);
+            }
+        });
+    }
+    getAssetsByGroup(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getAssetsByGroup',
+                    params,
+                });
+                const { data } = response;
+                return data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in getAssetsByGroup: ${error}`);
+            }
+        });
+    }
+    getAssetsByOwner(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getAssetsByOwner',
+                    params,
+                });
+                const { data } = response;
+                return data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in getAssetsByOwner: ${error}`);
+            }
+        });
+    }
+    getAssetsByCreator(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getAssetsByCreator',
+                    params,
+                });
+                const { data } = response;
+                return data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in getAssetsByCreator: ${error}`);
+            }
+        });
+    }
+    getAssetsByAuthority(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getAssetsByAuthority',
+                    params,
+                });
+                const { data } = response;
+                return data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in getAssetsByAuthority: ${error}`);
+            }
+        });
+    }
+    searchAssets(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'searchAssets',
+                    params,
+                });
+                const { data } = response;
+                return data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in searchAssets: ${error}`);
+            }
+        });
+    }
+    getSignaturesForAsset(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getSignaturesForAsset',
+                    params,
+                });
+                const { data } = response;
+                return data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in getSignaturesForAsset: ${error}`);
+            }
+        });
+    }
+    getPriorityFeeEstimate(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getPriorityFeeEstimate',
+                    params: [params],
+                }, {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+                if (response.data.error) {
+                    throw new Error(`Error fetching priority fee estimate: ${JSON.stringify(response.data.error, null, 2)}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error) && error.response) {
+                    throw new Error(`Error fetching priority fee estimate: ${JSON.stringify(error.response.data, null, 2)}`);
+                }
+                throw new Error(`Error fetching priority fee estimate: ${error}`);
+            }
+        });
+    }
+    getComputeUnits(instructions, payer, lookupTables, signers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const testInstructions = [
+                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: 1400000 }),
+                ...instructions,
+            ];
+            const testTransaction = new web3_js_1.VersionedTransaction(new web3_js_1.TransactionMessage({
+                instructions: testInstructions,
+                payerKey: payer,
+                recentBlockhash: (yield this.connection.getLatestBlockhash()).blockhash,
+            }).compileToV0Message(lookupTables));
+            if (signers) {
+                testTransaction.sign(signers);
+            }
+            const rpcResponse = yield this.connection.simulateTransaction(testTransaction, {
+                sigVerify: !!signers,
+            });
+            if (rpcResponse.value.err) {
+                console.error(`Simulation error: ${JSON.stringify(rpcResponse.value.err, null, 2)}`);
+                return null;
+            }
+            return rpcResponse.value.unitsConsumed || null;
+        });
+    }
+    pollTransactionConfirmation(txtSig_1) {
+        return __awaiter(this, arguments, void 0, function* (txtSig, pollOptions = {
+            confirmationStatuses: ["confirmed", "finalized"],
+            timeout: 15000,
+            interval: 5000
+        }) {
+            let elapsed = 0;
+            return new Promise((resolve, reject) => {
+                const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b, _c;
+                    elapsed += pollOptions.interval;
+                    if (elapsed >= pollOptions.timeout) {
+                        clearInterval(intervalId);
+                        reject(new Error(`Transaction ${txtSig}'s confirmation timed out`));
+                    }
+                    const status = yield this.connection.getSignatureStatus(txtSig);
+                    if (((_a = status === null || status === void 0 ? void 0 : status.value) === null || _a === void 0 ? void 0 : _a.confirmationStatus) && ((_b = pollOptions.confirmationStatuses) === null || _b === void 0 ? void 0 : _b.includes((_c = status === null || status === void 0 ? void 0 : status.value) === null || _c === void 0 ? void 0 : _c.confirmationStatus))) {
+                        clearInterval(intervalId);
+                        resolve(txtSig);
+                    }
+                }), pollOptions.interval);
+            });
+        });
+    }
+    createSmartTransaction(instructions_1, signers_1) {
+        return __awaiter(this, arguments, void 0, function* (instructions, signers, lookupTables = [], feePayer, serializeOptions = {
+            requireAllSignatures: true,
+            verifySignatures: true,
+        }) {
+            if (!signers.length) {
+                throw new Error('The transaction must have at least one signer');
+            }
+            const existingComputeBudgetInstructions = instructions.filter((instruction) => instruction.programId.equals(web3_js_1.ComputeBudgetProgram.programId));
+            if (existingComputeBudgetInstructions.length > 0) {
+                throw new Error('Cannot provide instructions that set the compute unit price and/or limit');
+            }
+            const payerKey = feePayer ? feePayer.publicKey : signers[0].publicKey;
+            const { context: { slot: minContextSlot }, value: blockhash, } = yield this.connection.getLatestBlockhashAndContext();
+            const recentBlockhash = blockhash.blockhash;
+            const isVersioned = lookupTables.length > 0;
+            let legacyTransaction = null;
+            let versionedTransaction = null;
+            if (isVersioned) {
+                const v0Message = new web3_js_1.TransactionMessage({
+                    instructions,
+                    payerKey,
+                    recentBlockhash,
+                }).compileToV0Message(lookupTables);
+                versionedTransaction = new web3_js_1.VersionedTransaction(v0Message);
+                const allSigners = feePayer ? [...signers, feePayer] : signers;
+                versionedTransaction.sign(allSigners);
+            }
+            else {
+                legacyTransaction = new web3_js_1.Transaction().add(...instructions);
+                legacyTransaction.recentBlockhash = recentBlockhash;
+                legacyTransaction.feePayer = payerKey;
+                for (const signer of signers) {
+                    legacyTransaction.partialSign(signer);
+                }
+                if (feePayer) {
+                    legacyTransaction.partialSign(feePayer);
+                }
+            }
+            const serializedTransaction = bs58_1.default.encode(isVersioned
+                ? versionedTransaction.serialize()
+                : legacyTransaction.serialize(serializeOptions));
+            const priorityFeeEstimateResponse = yield this.getPriorityFeeEstimate({
+                transaction: serializedTransaction,
+                options: {
+                    recommended: true,
+                },
+            });
+            const { priorityFeeEstimate } = priorityFeeEstimateResponse;
+            if (!priorityFeeEstimate) {
+                throw new Error('Priority fee estimate not available');
+            }
+            const computeBudgetIx = web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: priorityFeeEstimate,
+            });
+            instructions.unshift(computeBudgetIx);
+            const units = yield this.getComputeUnits(instructions, payerKey, isVersioned ? lookupTables : [], signers);
+            if (!units) {
+                throw new Error(`Error fetching compute units for the instructions provided`);
+            }
+            const customersCU = units < 1000 ? 1000 : Math.ceil(units * 1.1);
+            const computeUnitsIx = web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                units: customersCU,
+            });
+            instructions.unshift(computeUnitsIx);
+            if (isVersioned) {
+                const v0Message = new web3_js_1.TransactionMessage({
+                    instructions,
+                    payerKey,
+                    recentBlockhash,
+                }).compileToV0Message(lookupTables);
+                versionedTransaction = new web3_js_1.VersionedTransaction(v0Message);
+                const allSigners = feePayer ? [...signers, feePayer] : signers;
+                versionedTransaction.sign(allSigners);
+                return {
+                    transaction: versionedTransaction,
+                    blockhash,
+                    minContextSlot,
+                };
+            }
+            legacyTransaction = new web3_js_1.Transaction().add(...instructions);
+            legacyTransaction.recentBlockhash = recentBlockhash;
+            legacyTransaction.feePayer = payerKey;
+            for (const signer of signers) {
+                legacyTransaction.partialSign(signer);
+            }
+            if (feePayer) {
+                legacyTransaction.partialSign(feePayer);
+            }
+            return {
+                transaction: legacyTransaction,
+                blockhash,
+                minContextSlot,
+            };
+        });
+    }
+    sendSmartTransaction(instructions_1, signers_1) {
+        return __awaiter(this, arguments, void 0, function* (instructions, signers, lookupTables = [], sendOptions = { skipPreflight: false, lastValidBlockHeightOffset: 150 }) {
+            var _a;
+            const lastValidBlockHeightOffset = (_a = sendOptions.lastValidBlockHeightOffset) !== null && _a !== void 0 ? _a : 150;
+            if (lastValidBlockHeightOffset < 0)
+                throw new Error('expiryBlockOffset must be a positive integer');
+            try {
+                const { transaction, blockhash, minContextSlot } = yield this.createSmartTransaction(instructions, signers, lookupTables, sendOptions.feePayer);
+                const commitment = (sendOptions === null || sendOptions === void 0 ? void 0 : sendOptions.preflightCommitment) || 'confirmed';
+                const currentBlockHeight = yield this.connection.getBlockHeight();
+                const lastValidBlockHeight = Math.min(blockhash.lastValidBlockHeight, currentBlockHeight + lastValidBlockHeightOffset);
+                let error;
+                do {
+                    try {
+                        const signature = yield this.connection.sendRawTransaction(transaction.serialize(), Object.assign({ maxRetries: 0, preflightCommitment: 'confirmed', skipPreflight: sendOptions.skipPreflight, minContextSlot }, sendOptions));
+                        const abortSignal = AbortSignal.timeout(15000);
+                        yield this.connection.confirmTransaction({
+                            abortSignal,
+                            signature,
+                            blockhash: blockhash.blockhash,
+                            lastValidBlockHeight: lastValidBlockHeight,
+                        }, commitment);
+                        abortSignal.removeEventListener('abort', () => { });
+                        return signature;
+                    }
+                    catch (_error) {
+                        if (!(_error instanceof Error))
+                            error = new Error();
+                        error = _error;
+                    }
+                } while (!(error instanceof web3_js_1.TransactionExpiredBlockheightExceededError));
+            }
+            catch (error) {
+                throw new Error(`Error sending smart transaction: ${error}`);
+            }
+            throw new Error('Transaction failed to confirm within lastValidBlockHeight');
+        });
+    }
+    addTipInstruction(instructions, feePayer, tipAccount, tipAmount) {
+        const tipInstruction = web3_js_1.SystemProgram.transfer({
+            fromPubkey: feePayer,
+            toPubkey: new web3_js_1.PublicKey(tipAccount),
+            lamports: tipAmount,
+        });
+        instructions.push(tipInstruction);
+    }
+    createSmartTransactionWithTip(instructions_1, signers_1) {
+        return __awaiter(this, arguments, void 0, function* (instructions, signers, lookupTables = [], tipAmount = 1000, feePayer) {
+            if (!signers.length) {
+                throw new Error('The transaction must have at least one signer');
+            }
+            const randomTipAccount = types_1.JITO_TIP_ACCOUNTS[Math.floor(Math.random() * types_1.JITO_TIP_ACCOUNTS.length)];
+            const payerKey = feePayer ? feePayer.publicKey : signers[0].publicKey;
+            this.addTipInstruction(instructions, payerKey, randomTipAccount, tipAmount);
+            return this.createSmartTransaction(instructions, signers, lookupTables, feePayer);
+        });
+    }
+    sendJitoBundle(serializedTransactions, jitoApiUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post(jitoApiUrl, {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'sendBundle',
+                params: [serializedTransactions],
+            }, {
+                headers: { 'Content-Type': 'application/json' },
+            });
+            if (response.data.error) {
+                throw new Error(`Error sending bundles: ${JSON.stringify(response.data.error, null, 2)}`);
+            }
+            return response.data.result;
+        });
+    }
+    getBundleStatuses(bundleIds, jitoApiUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post(jitoApiUrl, {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'getBundleStatuses',
+                params: [bundleIds],
+            }, {
+                headers: { 'Content-Type': 'application/json' },
+            });
+            if (response.data.error) {
+                throw new Error(`Error getting bundle statuses: ${JSON.stringify(response.data.error, null, 2)}`);
+            }
+            return response.data.result;
+        });
+    }
+    sendSmartTransactionWithTip(instructions_1, signers_1) {
+        return __awaiter(this, arguments, void 0, function* (instructions, signers, lookupTables = [], tipAmount = 1000, region = 'Default', feePayer, lastValidBlockHeightOffset = 150) {
+            if (lastValidBlockHeightOffset < 0)
+                throw new Error('lastValidBlockHeightOffset must be a positive integer');
+            if (!signers.length) {
+                throw new Error('The transaction must have at least one signer');
+            }
+            const { transaction, blockhash } = yield this.createSmartTransactionWithTip(instructions, signers, lookupTables, tipAmount, feePayer);
+            const serializedTransaction = bs58_1.default.encode(transaction.serialize());
+            const jitoApiUrl = `${types_1.JITO_API_URLS[region]}/api/v1/bundles`;
+            const bundleId = yield this.sendJitoBundle([serializedTransaction], jitoApiUrl);
+            const currentBlockHeight = yield this.connection.getBlockHeight();
+            const lastValidBlockHeight = Math.min(blockhash.lastValidBlockHeight, currentBlockHeight + lastValidBlockHeightOffset);
+            const timeout = 60000;
+            const interval = 5000;
+            const startTime = Date.now();
+            while (Date.now() - startTime < timeout ||
+                (yield this.connection.getBlockHeight()) <= lastValidBlockHeight) {
+                const bundleStatuses = yield this.getBundleStatuses([bundleId], jitoApiUrl);
+                if (bundleStatuses &&
+                    bundleStatuses.value &&
+                    bundleStatuses.value.length > 0) {
+                    const status = bundleStatuses.value[0].confirmation_status;
+                    if (status === 'confirmed') {
+                        return bundleStatuses.value[0].transactions[0];
+                    }
+                }
+                yield new Promise((resolve) => setTimeout(resolve, interval));
+            }
+            throw new Error('Bundle failed to confirm within the timeout period');
+        });
+    }
+    getNftEditions(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getNftEditions',
+                    params,
+                }, {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+                return response.data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in getNftEditions: ${error}`);
+            }
+        });
+    }
+    getTokenAccounts(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'getTokenAccounts',
+                    params,
+                }, {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+                return response.data.result;
+            }
+            catch (error) {
+                throw new Error(`Error in getTokenAccounts: ${error}`);
+            }
+        });
+    }
+    sendTransaction(transaction_1) {
+        return __awaiter(this, arguments, void 0, function* (transaction, options = {
+            skipPreflight: true,
+        }) {
+            let rawTransaction;
+            if (transaction instanceof web3_js_1.VersionedTransaction) {
+                rawTransaction = Buffer.from(transaction.serialize()).toString('base64');
+            }
+            else {
+                rawTransaction = transaction.serialize().toString('base64');
+            }
+            try {
+                const url = `${this.connection.rpcEndpoint}`;
+                const response = yield axios_1.default.post(url, {
+                    jsonrpc: '2.0',
+                    id: this.id,
+                    method: 'sendTransaction',
+                    params: [rawTransaction, Object.assign({ encoding: 'base64' }, options)],
+                }, {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+                if (response.data.error) {
+                    throw new Error(`RPC error: ${JSON.stringify(response.data.error)}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                throw new Error(`Error sending transaction: ${error}`);
+            }
+        });
+    }
+}
+exports.RpcClient = RpcClient;

package/dist/helius_sdk_v1.4.0/constants.d.ts

@@ -0,0 +1 @@
+export declare const SFDP_REJECTS_URL = "https://helius-docs.s3.us-east-2.amazonaws.com/sfdp_rejects.json";

package/dist/helius_sdk_v1.4.0/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFDP_REJECTS_URL = void 0;
+exports.SFDP_REJECTS_URL = 'https://helius-docs.s3.us-east-2.amazonaws.com/sfdp_rejects.json';

package/dist/helius_sdk_v1.4.0/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './types';
+export * from './utils';
+export * from './Helius';
+export * from './RpcClient';

package/dist/helius_sdk_v1.4.0/index.js

@@ -0,0 +1,21 @@
+"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 });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./Helius"), exports);
+__exportStar(require("./RpcClient"), exports);