Security News
The Unpaid Backbone of Open Source: Solo Maintainers Face Increasing Security Demands
Solo open source maintainers face burnout and security challenges, with 60% unpaid and 60% considering quitting.
@radixdlt/babylon-core-api-sdk
Advanced tools
This SDK is a thin wrapper around the [Babylon Core API](https://docs-babylon.radixdlt.com/main/apis/api-specification.html).
This SDK is a thin wrapper around the Babylon Core API.
The CoreApiClient
is the main exported object. It currently includes high-level wrappers around two sub-APIs: LTS
and Status
.
For querying other sub-APIs, for now, use methods on coreApiClient.LowLevel.X
where X
is each of the different sub-APIs.
Behind the scenes, this library uses the fetch API:
fetch
is not available, a polyfill must be used (see eg node-fetch).window.fetch
into the fetch
parameter.The client checks that it can connect to the Core API at initialize
time. If you'd rather, you can use initializeUnchecked
which skips this check.
import fetch from "node-fetch" // Optional polyfill for fetch required if running in nodeJS
import http from 'node:http';
import https from 'node:http';
import { CoreApiClient} from "@radixdlt/babylon-core-api-sdk";
const coreApiClient = await CoreApiClient.initialize({
// Note - in nodeJS, you may need to use 127.0.0.1 instead of localhost
basePath: "http://127.0.0.1:3333/core",
logicalNetworkName: "kisharnet",
fetch,
// Configuration for fixing issues with node-fetch
httpAgent: new http.Agent({ keepAlive: true }),
httpsAgent: new https.Agent({ keepAlive: true }),
});
The Core API has a "Long Term Support" sub-API. This is documented in the API specification.
The client has a high-level LTS
API, which includes the following features:
getConstructionMetadata
includes a node synced-up checksubmitTransaction
handles different submit transaction errorsConstruction and submission looks something like this:
import { LtsCommittedTransactionStatus } from "@radixdlt/babylon-core-api-sdk";
const constructionMetadata = await coreApiClient.LTS.getConstructionMetadata();
const currentEpoch = constructionMetadata.current_epoch;
const { notarizedTransactionHex, intentHash } = buildTransaction(currentEpoch, ...);
/**
* By testing `submitResponse.result`, you can distinguish different possible results
* Some of these possible results will need to be handled.
* See the integrators guide for more information.
*/
const submitResponse = await coreApiClient.LTS.submitTransaction({
notarized_transaction_hex: notarizedTransactionHex
});
console.log(submitResponse);
/**
* By testing `statusResponse.intent_status`, you can see different intent statuses.
*
* You may wish to poll this endpoint until it is one of:
* - LtsTransactionIntentStatus.CommittedSuccess
* - LtsTransactionIntentStatus.CommittedFailure
* - LtsTransactionIntentStatus.PermanentRejection
*
* See the integrators guide for more information.
*/
const statusResponse = await coreApiClient.LTS.getTransactionStatus({
intent_hash: intentHash
});
console.log(statusResponse);
if (statusResponse.committed_state_version) {
const committedOutcomeResponse = await coreApiClient.LTS.getTransactionOutcome({
state_version: statusResponse.committed_state_version
});
if (committedOutcomeResponse?.status == LtsCommittedTransactionStatus.Success) {
console.log("Committed success");
} else if (committedOutcomeResponse?.status == LtsCommittedTransactionStatus.Failure) {
console.log("Committed failure");
}
}
Account balance queries look like this:
const accountAddress = "..";
const resourceAddress = "..";
const balanceResponse = await coreApiClient.LTS.getAccountFungibleResourceBalance({
account_address: accountAddress,
resource_address: resourceAddress,
});
const allBalancesResponse = await coreApiClient.LTS.getAccountAllFungibleResourceBalances({
account_address: accountAddress,
});
You can get transaction outcomes in ledger order with these endpoints.
You can sum the fungible_entity_balance_changes
from the transaction outcomes to track balance changes in components including accounts.
const accountAddress = "..";
const transactionsBatch = await coreApiClient.LTS.getTransactionOutcomes({
from_state_version: 1,
limit: 100,
});
const accountTransactionsBatch = await coreApiClient.LTS.getAccountTransactionOutcomes({
account_address: accountAddress,
from_state_version: 1,
limit: 100,
});
FAQs
A client for the RadixDLT Babylon Core API
The npm package @radixdlt/babylon-core-api-sdk receives a total of 773 weekly downloads. As such, @radixdlt/babylon-core-api-sdk popularity was classified as not popular.
We found that @radixdlt/babylon-core-api-sdk demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 6 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Solo open source maintainers face burnout and security challenges, with 60% unpaid and 60% considering quitting.
Security News
License exceptions modify the terms of open source licenses, impacting how software can be used, modified, and distributed. Developers should be aware of the legal implications of these exceptions.
Security News
A developer is accusing Tencent of violating the GPL by modifying a Python utility and changing its license to BSD, highlighting the importance of copyleft compliance.