@solana/kit
Version:
Solana Javascript API
799 lines (789 loc) • 30.3 kB
JavaScript
;
var accounts = require('@solana/accounts');
var addresses = require('@solana/addresses');
var codecs = require('@solana/codecs');
var errors = require('@solana/errors');
var functional = require('@solana/functional');
var instructions = require('@solana/instructions');
var instructionPlans = require('@solana/instruction-plans');
var keys = require('@solana/keys');
var offchainMessages = require('@solana/offchain-messages');
var pluginCore = require('@solana/plugin-core');
var programs = require('@solana/programs');
var rpc = require('@solana/rpc');
var rpcParsedTypes = require('@solana/rpc-parsed-types');
var rpcSubscriptions = require('@solana/rpc-subscriptions');
var rpcTypes = require('@solana/rpc-types');
var signers = require('@solana/signers');
var subscribable = require('@solana/subscribable');
var transactionIntrospection = require('@solana/transaction-introspection');
var transactionMessages = require('@solana/transaction-messages');
var transactions = require('@solana/transactions');
var transactionConfirmation = require('@solana/transaction-confirmation');
var rpcSpecTypes = require('@solana/rpc-spec-types');
// src/index.ts
// src/create-async-generator-with-initial-value-and-slot-tracking.ts
async function* createAsyncGeneratorWithInitialValueAndSlotTracking({
abortSignal,
rpcRequest,
rpcValueMapper,
rpcSubscriptionRequest,
rpcSubscriptionValueMapper
}) {
if (abortSignal.aborted) return;
let lastUpdateSlot = -1n;
const queue = [];
let waitingResolve = null;
let waitingReject = null;
let rpcDone = false;
let subscriptionDone = false;
let done = false;
let pendingError;
function markSourcesDone() {
done = true;
if (waitingResolve) {
const resolve = waitingResolve;
waitingResolve = null;
waitingReject = null;
resolve({ done: true, value: void 0 });
}
}
const abortController = new AbortController();
const signal = abortController.signal;
function onAbort() {
done = true;
abortController.abort(abortSignal.reason);
if (waitingResolve) {
const resolve = waitingResolve;
waitingResolve = null;
waitingReject = null;
resolve({ done: true, value: void 0 });
}
}
abortSignal.addEventListener("abort", onAbort);
function enqueue(item) {
if (done || signal.aborted) return;
if (waitingResolve) {
const resolve = waitingResolve;
waitingResolve = null;
waitingReject = null;
resolve({ done: false, value: item });
} else {
queue.push(item);
}
}
function handleError(err) {
if (signal.aborted) return;
done = true;
pendingError = err;
abortController.abort(err);
if (waitingReject) {
const reject = waitingReject;
waitingResolve = null;
waitingReject = null;
reject(err);
}
}
rpcRequest.send({ abortSignal: signal }).then(({ context: { slot }, value }) => {
if (signal.aborted) return;
if (slot < lastUpdateSlot) return;
lastUpdateSlot = slot;
enqueue({ context: { slot }, value: rpcValueMapper(value) });
}).then(() => {
rpcDone = true;
if (subscriptionDone) markSourcesDone();
}).catch(handleError);
rpcSubscriptionRequest.subscribe({ abortSignal: signal }).then(async (notifications) => {
for await (const {
context: { slot },
value
} of notifications) {
if (signal.aborted) return;
if (slot < lastUpdateSlot) continue;
lastUpdateSlot = slot;
enqueue({ context: { slot }, value: rpcSubscriptionValueMapper(value) });
}
subscriptionDone = true;
if (rpcDone) markSourcesDone();
}).catch(handleError);
try {
while (true) {
if (pendingError) throw pendingError;
if (queue.length > 0) {
yield queue.shift();
} else if (done) {
return;
} else {
const result = await new Promise((resolve, reject) => {
waitingResolve = resolve;
waitingReject = reject;
});
if (result.done) return;
yield result.value;
}
}
} finally {
abortSignal.removeEventListener("abort", onAbort);
if (!signal.aborted) {
abortController.abort();
}
}
}
// src/create-reactive-store-with-initial-value-and-slot-tracking.ts
var IDLE_STATE = Object.freeze({
data: void 0,
error: void 0,
status: "idle"
});
function createReactiveStoreWithInitialValueAndSlotTracking({
initialValueMapper,
initialValueSource,
streamSource,
streamValueMapper
}) {
let currentState = IDLE_STATE;
let lastUpdateSlot = -1n;
let currentInnerController;
const subscribers = /* @__PURE__ */ new Set();
function notify() {
subscribers.forEach((cb) => cb());
}
function setState(next) {
if (currentState.status === next.status && currentState.data === next.data && currentState.error === next.error) {
return;
}
currentState = next;
notify();
}
function performConnect(callerSignal) {
currentInnerController?.abort();
if (callerSignal?.aborted) {
setState({ data: currentState.data, error: callerSignal.reason, status: "error" });
return;
}
setState({ data: currentState.data, error: currentState.error, status: "loading" });
const innerController = new AbortController();
currentInnerController = innerController;
const innerSignal = innerController.signal;
const signal = callerSignal ? AbortSignal.any([innerSignal, callerSignal]) : innerSignal;
if (callerSignal) {
callerSignal.addEventListener(
"abort",
() => {
if (innerSignal.aborted) return;
setState({ data: currentState.data, error: callerSignal.reason, status: "error" });
innerController.abort(callerSignal.reason);
},
{ signal: innerSignal }
);
}
function handleError(err) {
if (signal.aborted) return;
if (currentState.status === "error") return;
setState({ data: currentState.data, error: err, status: "error" });
innerController.abort(err);
}
function handleSlottedValue({ context: { slot }, value }) {
if (signal.aborted) return;
if (slot < lastUpdateSlot) {
if (currentState.data !== void 0) {
setState({ data: currentState.data, error: void 0, status: "loaded" });
}
return;
}
lastUpdateSlot = slot;
setState({ data: { context: { slot }, value }, error: void 0, status: "loaded" });
}
const actionStore = initialValueSource.reactiveStore();
const streamStore = streamSource.reactiveStore();
const unsubscribeAction = actionStore.subscribe(() => {
const state = actionStore.getState();
if (state.status === "success") {
const { context, value } = state.data;
handleSlottedValue({ context, value: initialValueMapper(value) });
} else if (state.status === "error") {
handleError(state.error);
}
});
const unsubscribeStream = streamStore.subscribe(() => {
const state = streamStore.getState();
if (state.status === "loaded") {
const { context, value } = state.data;
handleSlottedValue({ context, value: streamValueMapper(value) });
} else if (state.status === "error") {
handleError(state.error);
}
});
innerSignal.addEventListener(
"abort",
() => {
unsubscribeAction();
unsubscribeStream();
},
{ once: true }
);
streamStore.withSignal(signal).connect();
actionStore.withSignal(signal).dispatch();
}
function performReset() {
currentInnerController?.abort();
currentInnerController = void 0;
lastUpdateSlot = -1n;
setState(IDLE_STATE);
}
return {
connect() {
performConnect(void 0);
},
getState() {
return currentState;
},
reset: performReset,
subscribe(callback) {
subscribers.add(callback);
return () => {
subscribers.delete(callback);
};
},
withSignal(signal) {
return {
connect() {
performConnect(signal);
}
};
}
};
}
// src/airdrop-internal.ts
async function requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT({
abortSignal,
commitment,
confirmSignatureOnlyTransaction,
lamports,
recipientAddress,
rpc
}) {
const airdropTransactionSignature = await rpc.requestAirdrop(recipientAddress, lamports, { commitment }).send({ abortSignal });
await confirmSignatureOnlyTransaction({
abortSignal,
commitment,
signature: airdropTransactionSignature
});
return airdropTransactionSignature;
}
// src/airdrop.ts
function airdropFactory({
rpc,
rpcSubscriptions
}) {
const getRecentSignatureConfirmationPromise = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory({
rpc,
rpcSubscriptions
});
async function confirmSignatureOnlyTransaction(config) {
await transactionConfirmation.waitForRecentTransactionConfirmationUntilTimeout({
...config,
getRecentSignatureConfirmationPromise,
getTimeoutPromise: transactionConfirmation.getTimeoutPromise
});
}
return async function airdrop(config) {
return await requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT({
...config,
confirmSignatureOnlyTransaction,
rpc
});
};
}
var PROVISORY_COMPUTE_UNIT_LIMIT = 0;
var MAX_COMPUTE_UNIT_LIMIT = 14e5;
function estimateComputeUnitLimitFactory({
rpc
}) {
return async function estimateComputeUnitLimit(transactionMessage, config) {
const { abortSignal, ...simulateConfig } = config ?? {};
const replaceRecentBlockhash = !transactionMessages.isTransactionMessageWithDurableNonceLifetime(transactionMessage);
const transaction = functional.pipe(
transactionMessage,
(m) => transactionMessages.setTransactionMessageComputeUnitLimit(MAX_COMPUTE_UNIT_LIMIT, m),
transactions.compileTransaction
);
const wireTransactionBytes = transactions.getBase64EncodedWireTransaction(transaction);
try {
const response = await rpc.simulateTransaction(wireTransactionBytes, {
...simulateConfig,
encoding: "base64",
replaceRecentBlockhash,
sigVerify: false
}).send({ abortSignal });
const { err: transactionError, ...simulationResult } = response.value;
if (simulationResult.unitsConsumed == null) {
throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT);
}
if (transactionError) {
throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT, {
...simulationResult,
cause: errors.getSolanaErrorFromTransactionError(transactionError)
});
}
return simulationResult.unitsConsumed > 4294967295n ? 4294967295 : Number(simulationResult.unitsConsumed);
} catch (e) {
if (errors.isSolanaError(e, errors.SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT)) {
throw e;
}
throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT, {
cause: e
});
}
};
}
function estimateAndSetComputeUnitLimitFactory(estimateComputeUnitLimit) {
return async function estimateAndSetComputeUnitLimit(transactionMessage, config) {
const existingLimit = transactionMessages.getTransactionMessageComputeUnitLimit(transactionMessage);
if (existingLimit && existingLimit !== MAX_COMPUTE_UNIT_LIMIT) {
return transactionMessage;
}
const estimatedUnits = await estimateComputeUnitLimit(transactionMessage, config);
return transactionMessages.setTransactionMessageComputeUnitLimit(estimatedUnits, transactionMessage);
};
}
function fillTransactionMessageProvisoryComputeUnitLimit(transactionMessage) {
if (transactionMessages.getTransactionMessageComputeUnitLimit(transactionMessage) !== void 0) {
return transactionMessage;
}
return transactionMessages.setTransactionMessageComputeUnitLimit(PROVISORY_COMPUTE_UNIT_LIMIT, transactionMessage);
}
async function fetchAddressesForLookupTables(lookupTableAddresses, rpc, config) {
if (lookupTableAddresses.length === 0) {
return {};
}
const fetchedLookupTables = await accounts.fetchJsonParsedAccounts(
rpc,
lookupTableAddresses,
config
);
accounts.assertAccountsDecoded(fetchedLookupTables);
accounts.assertAccountsExist(fetchedLookupTables);
return fetchedLookupTables.reduce((acc, lookup) => {
return {
...acc,
[lookup.address]: lookup.data.addresses
};
}, {});
}
// src/decompile-transaction-message-fetching-lookup-tables.ts
async function decompileTransactionMessageFetchingLookupTables(compiledTransactionMessage, rpc, config) {
const lookupTables = "addressTableLookups" in compiledTransactionMessage && compiledTransactionMessage.addressTableLookups !== void 0 && compiledTransactionMessage.addressTableLookups.length > 0 ? compiledTransactionMessage.addressTableLookups : [];
const lookupTableAddresses = lookupTables.map((l) => l.lookupTableAddress);
const { lastValidBlockHeight, ...fetchAccountsConfig } = config ?? {};
const addressesByLookupTableAddress = lookupTableAddresses.length > 0 ? await fetchAddressesForLookupTables(lookupTableAddresses, rpc, fetchAccountsConfig) : {};
return transactionMessages.decompileTransactionMessage(compiledTransactionMessage, {
addressesByLookupTableAddress,
lastValidBlockHeight
});
}
var PROVISORY_LIMIT = 0;
var MAX_COMPUTE_UNIT_LIMIT2 = 14e5;
var MAX_LOADED_ACCOUNTS_DATA_SIZE_LIMIT = 64 * 1024 * 1024;
function estimateResourceLimitsFactory({
rpc
}) {
return async function estimateResourceLimits(transactionMessage, config) {
const { abortSignal, ...simulateConfig } = config ?? {};
const replaceRecentBlockhash = !transactionMessages.isTransactionMessageWithDurableNonceLifetime(transactionMessage);
const isDataSizeRequired = transactionMessage.version === 1;
const transaction = functional.pipe(
transactionMessage,
(m) => transactionMessages.setTransactionMessageComputeUnitLimit(MAX_COMPUTE_UNIT_LIMIT2, m),
(m) => isDataSizeRequired ? transactionMessages.setTransactionMessageLoadedAccountsDataSizeLimit(MAX_LOADED_ACCOUNTS_DATA_SIZE_LIMIT, m) : m,
transactions.compileTransaction
);
const wireTransactionBytes = transactions.getBase64EncodedWireTransaction(transaction);
try {
const response = await rpc.simulateTransaction(wireTransactionBytes, {
...simulateConfig,
encoding: "base64",
replaceRecentBlockhash,
sigVerify: false
}).send({ abortSignal });
const { err: transactionError, ...simulationResult } = response.value;
if (simulationResult.unitsConsumed == null) {
throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT);
}
if (isDataSizeRequired && simulationResult.loadedAccountsDataSize == null) {
throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_LOADED_ACCOUNTS_DATA_SIZE_LIMIT);
}
if (transactionError) {
throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_RESOURCE_LIMITS, {
...simulationResult,
cause: errors.getSolanaErrorFromTransactionError(transactionError)
});
}
const computeUnitLimit = simulationResult.unitsConsumed > 4294967295n ? 4294967295 : Number(simulationResult.unitsConsumed);
if (isDataSizeRequired) {
return {
computeUnitLimit,
loadedAccountsDataSizeLimit: simulationResult.loadedAccountsDataSize
};
}
return simulationResult.loadedAccountsDataSize == null ? { computeUnitLimit } : { computeUnitLimit, loadedAccountsDataSizeLimit: simulationResult.loadedAccountsDataSize };
} catch (e) {
if (errors.isSolanaError(e, errors.SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_RESOURCE_LIMITS) || errors.isSolanaError(e, errors.SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_LOADED_ACCOUNTS_DATA_SIZE_LIMIT)) {
throw e;
}
throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT, {
cause: e
});
}
};
}
function estimateAndSetResourceLimitsFactory(estimateResourceLimits) {
return async function estimateAndSetResourceLimits(transactionMessage, config) {
const existingComputeUnitLimit = transactionMessages.getTransactionMessageComputeUnitLimit(transactionMessage);
const computeUnitLimitIsExplicit = existingComputeUnitLimit !== void 0 && existingComputeUnitLimit !== PROVISORY_LIMIT && existingComputeUnitLimit !== MAX_COMPUTE_UNIT_LIMIT2;
const isV1 = transactionMessage.version === 1;
let loadedAccountsDataSizeLimitIsExplicit = true;
if (isV1) {
const existingLoadedAccountsDataSizeLimit = transactionMessages.getTransactionMessageLoadedAccountsDataSizeLimit(transactionMessage);
loadedAccountsDataSizeLimitIsExplicit = existingLoadedAccountsDataSizeLimit !== void 0 && existingLoadedAccountsDataSizeLimit !== PROVISORY_LIMIT;
}
if (computeUnitLimitIsExplicit && loadedAccountsDataSizeLimitIsExplicit) {
return transactionMessage;
}
const estimate = await estimateResourceLimits(transactionMessage, config);
let result = transactionMessage;
if (!computeUnitLimitIsExplicit) {
result = transactionMessages.setTransactionMessageComputeUnitLimit(estimate.computeUnitLimit, result);
}
if (isV1 && !loadedAccountsDataSizeLimitIsExplicit && "loadedAccountsDataSizeLimit" in estimate) {
result = transactionMessages.setTransactionMessageLoadedAccountsDataSizeLimit(estimate.loadedAccountsDataSizeLimit, result);
}
return result;
};
}
function fillTransactionMessageProvisoryResourceLimits(transactionMessage) {
let result = transactionMessage;
if (transactionMessages.getTransactionMessageComputeUnitLimit(result) === void 0) {
result = transactionMessages.setTransactionMessageComputeUnitLimit(PROVISORY_LIMIT, result);
}
if (result.version === 1 && transactionMessages.getTransactionMessageLoadedAccountsDataSizeLimit(result) === void 0) {
result = transactionMessages.setTransactionMessageLoadedAccountsDataSizeLimit(PROVISORY_LIMIT, result);
}
return result;
}
function getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, config) {
if (
// The developer has supplied no value for `preflightCommitment`.
!config?.preflightCommitment && // The value of `commitment` is lower than the server default of `preflightCommitment`.
rpcTypes.commitmentComparator(
commitment,
"finalized"
/* default value of `preflightCommitment` */
) < 0
) {
return {
...config,
// In the common case, it is unlikely that you want to simulate a transaction at
// `finalized` commitment when your standard of commitment for confirming the
// transaction is lower. Cap the simulation commitment level to the level of the
// confirmation commitment.
preflightCommitment: commitment
};
}
return config;
}
async function sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
abortSignal,
commitment,
rpc,
transaction,
...sendTransactionConfig
}) {
const base64EncodedWireTransaction = transactions.getBase64EncodedWireTransaction(transaction);
return await rpc.sendTransaction(base64EncodedWireTransaction, {
...getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, sendTransactionConfig),
encoding: "base64"
}).send({ abortSignal });
}
async function sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
abortSignal,
commitment,
confirmDurableNonceTransaction,
rpc,
transaction,
...sendTransactionConfig
}) {
const transactionSignature = await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
...sendTransactionConfig,
abortSignal,
commitment,
rpc,
transaction
});
await confirmDurableNonceTransaction({
abortSignal,
commitment,
transaction
});
return transactionSignature;
}
async function sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT({
abortSignal,
commitment,
confirmRecentTransaction,
rpc,
transaction,
...sendTransactionConfig
}) {
const transactionSignature = await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
...sendTransactionConfig,
abortSignal,
commitment,
rpc,
transaction
});
await confirmRecentTransaction({
abortSignal,
commitment,
transaction
});
return transactionSignature;
}
// src/send-and-confirm-durable-nonce-transaction.ts
function sendAndConfirmDurableNonceTransactionFactory({
rpc,
rpcSubscriptions
}) {
const getNonceInvalidationPromise = transactionConfirmation.createNonceInvalidationPromiseFactory({ rpc, rpcSubscriptions });
const getRecentSignatureConfirmationPromise = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory({
rpc,
rpcSubscriptions
});
function createNonceInvalidationPromiseHandlingRaceCondition(signature) {
return async function wrappedGetNonceInvalidationPromise(config) {
try {
return await getNonceInvalidationPromise(config);
} catch (e) {
if (errors.isSolanaError(e, errors.SOLANA_ERROR__INVALID_NONCE)) {
let status;
try {
const { value: statuses } = await rpc.getSignatureStatuses([signature]).send({ abortSignal: config.abortSignal });
status = statuses[0];
} catch {
throw e;
}
if (status === null || status === void 0) {
throw e;
}
if (status.confirmationStatus !== null && rpcTypes.commitmentComparator(status.confirmationStatus, config.commitment) >= 0) {
if (status.err !== null) {
throw errors.getSolanaErrorFromTransactionError(status.err);
}
return;
}
return await new Promise(() => {
});
}
throw e;
}
};
}
async function confirmDurableNonceTransaction(config) {
const wrappedGetNonceInvalidationPromise = createNonceInvalidationPromiseHandlingRaceCondition(
transactions.getSignatureFromTransaction(config.transaction)
);
await transactionConfirmation.waitForDurableNonceTransactionConfirmation({
...config,
getNonceInvalidationPromise: wrappedGetNonceInvalidationPromise,
getRecentSignatureConfirmationPromise
});
}
return async function sendAndConfirmDurableNonceTransaction(transaction, config) {
await sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
...config,
confirmDurableNonceTransaction,
rpc,
transaction
});
};
}
function sendAndConfirmTransactionFactory({
rpc,
rpcSubscriptions
}) {
const getBlockHeightExceedencePromise = transactionConfirmation.createBlockHeightExceedencePromiseFactory({
rpc,
rpcSubscriptions
});
const getRecentSignatureConfirmationPromise = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory({
rpc,
rpcSubscriptions
});
async function confirmRecentTransaction(config) {
await transactionConfirmation.waitForRecentTransactionConfirmation({
...config,
getBlockHeightExceedencePromise,
getRecentSignatureConfirmationPromise
});
}
return async function sendAndConfirmTransaction(transaction, config) {
await sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT({
...config,
confirmRecentTransaction,
rpc,
transaction
});
};
}
// src/send-transaction-without-confirming.ts
function sendTransactionWithoutConfirmingFactory({
rpc
}) {
return async function sendTransactionWithoutConfirming(transaction, config) {
await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
...config,
rpc,
transaction
});
};
}
Object.defineProperty(exports, "createRpcMessage", {
enumerable: true,
get: function () { return rpcSpecTypes.createRpcMessage; }
});
exports.airdropFactory = airdropFactory;
exports.createAsyncGeneratorWithInitialValueAndSlotTracking = createAsyncGeneratorWithInitialValueAndSlotTracking;
exports.createReactiveStoreWithInitialValueAndSlotTracking = createReactiveStoreWithInitialValueAndSlotTracking;
exports.decompileTransactionMessageFetchingLookupTables = decompileTransactionMessageFetchingLookupTables;
exports.estimateAndSetComputeUnitLimitFactory = estimateAndSetComputeUnitLimitFactory;
exports.estimateAndSetResourceLimitsFactory = estimateAndSetResourceLimitsFactory;
exports.estimateComputeUnitLimitFactory = estimateComputeUnitLimitFactory;
exports.estimateResourceLimitsFactory = estimateResourceLimitsFactory;
exports.fetchAddressesForLookupTables = fetchAddressesForLookupTables;
exports.fillTransactionMessageProvisoryComputeUnitLimit = fillTransactionMessageProvisoryComputeUnitLimit;
exports.fillTransactionMessageProvisoryResourceLimits = fillTransactionMessageProvisoryResourceLimits;
exports.sendAndConfirmDurableNonceTransactionFactory = sendAndConfirmDurableNonceTransactionFactory;
exports.sendAndConfirmTransactionFactory = sendAndConfirmTransactionFactory;
exports.sendTransactionWithoutConfirmingFactory = sendTransactionWithoutConfirmingFactory;
Object.keys(accounts).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return accounts[k]; }
});
});
Object.keys(addresses).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return addresses[k]; }
});
});
Object.keys(codecs).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return codecs[k]; }
});
});
Object.keys(errors).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return errors[k]; }
});
});
Object.keys(functional).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return functional[k]; }
});
});
Object.keys(instructions).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return instructions[k]; }
});
});
Object.keys(instructionPlans).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return instructionPlans[k]; }
});
});
Object.keys(keys).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return keys[k]; }
});
});
Object.keys(offchainMessages).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return offchainMessages[k]; }
});
});
Object.keys(pluginCore).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return pluginCore[k]; }
});
});
Object.keys(programs).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return programs[k]; }
});
});
Object.keys(rpc).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return rpc[k]; }
});
});
Object.keys(rpcParsedTypes).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return rpcParsedTypes[k]; }
});
});
Object.keys(rpcSubscriptions).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return rpcSubscriptions[k]; }
});
});
Object.keys(rpcTypes).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return rpcTypes[k]; }
});
});
Object.keys(signers).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return signers[k]; }
});
});
Object.keys(subscribable).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return subscribable[k]; }
});
});
Object.keys(transactionIntrospection).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return transactionIntrospection[k]; }
});
});
Object.keys(transactionMessages).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return transactionMessages[k]; }
});
});
Object.keys(transactions).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return transactions[k]; }
});
});
//# sourceMappingURL=index.node.cjs.map
//# sourceMappingURL=index.node.cjs.map