@atomiqlabs/chain-starknet
Version:
Starknet specific base implementation
225 lines (224 loc) • 8.27 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.StarknetChainInterface = void 0;
const starknet_1 = require("starknet");
const Utils_1 = require("../../utils/Utils");
const StarknetTransactions_1 = require("./modules/StarknetTransactions");
const StarknetFees_1 = require("./modules/StarknetFees");
const StarknetAddresses_1 = require("./modules/StarknetAddresses");
const StarknetTokens_1 = require("./modules/StarknetTokens");
const StarknetEvents_1 = require("./modules/StarknetEvents");
const StarknetSignatures_1 = require("./modules/StarknetSignatures");
const StarknetAccounts_1 = require("./modules/StarknetAccounts");
const StarknetBlocks_1 = require("./modules/StarknetBlocks");
const base_1 = require("@atomiqlabs/base");
const StarknetSigner_1 = require("../wallet/StarknetSigner");
const buffer_1 = require("buffer");
const StarknetKeypairWallet_1 = require("../wallet/accounts/StarknetKeypairWallet");
const StarknetBrowserSigner_1 = require("../wallet/StarknetBrowserSigner");
/**
* Main chain interface for interacting with Starknet blockchain
*
* @category Chain Interface
*/
class StarknetChainInterface {
constructor(chainId, provider, wsChannel, feeEstimator = new StarknetFees_1.StarknetFees(provider), options, bitcoinNetwork) {
var _a, _b, _c, _d;
this.chainId = "STARKNET";
this.starknetChainId = chainId;
this.provider = provider;
this.config = options ?? {};
(_a = this.config).getLogForwardBlockRange ?? (_a.getLogForwardBlockRange = 2000);
(_b = this.config).getLogChunkSize ?? (_b.getLogChunkSize = 100);
(_c = this.config).maxGetLogKeys ?? (_c.maxGetLogKeys = 64);
(_d = this.config).maxParallelCalls ?? (_d.maxParallelCalls = 10);
this.wsChannel = wsChannel;
this.Fees = feeEstimator;
this.Tokens = new StarknetTokens_1.StarknetTokens(this);
this.Transactions = new StarknetTransactions_1.StarknetTransactions(this);
this.Signatures = new StarknetSignatures_1.StarknetSignatures(this);
this.Events = new StarknetEvents_1.StarknetEvents(this);
this.Accounts = new StarknetAccounts_1.StarknetAccounts(this);
this.Blocks = new StarknetBlocks_1.StarknetBlocks(this);
this.bitcoinNetwork = bitcoinNetwork;
}
/**
* @inheritDoc
*/
async getBalance(signer, tokenAddress) {
//TODO: For native token we should discount the cost of deploying an account if it is not deployed yet and the tx fee
return await this.Tokens.getTokenBalance(signer, tokenAddress);
}
/**
* @inheritDoc
*/
getNativeCurrencyAddress() {
return this.Tokens.getNativeCurrencyAddress();
}
/**
* @inheritDoc
*/
isValidToken(tokenIdentifier) {
return this.Tokens.isValidToken(tokenIdentifier);
}
/**
* @inheritDoc
*/
isValidAddress(address, lenient) {
return StarknetAddresses_1.StarknetAddresses.isValidAddress(address, lenient);
}
/**
* @inheritDoc
*/
normalizeAddress(address) {
return (0, Utils_1.toHex)(address);
}
///////////////////////////////////
//// Callbacks & handlers
/**
* @inheritDoc
*/
offBeforeTxReplace(callback) {
return true;
}
/**
* @inheritDoc
*/
onBeforeTxReplace(callback) { }
/**
* @inheritDoc
*/
onBeforeTxSigned(callback) {
this.Transactions.onBeforeTxSigned(callback);
}
/**
* @inheritDoc
*/
offBeforeTxSigned(callback) {
return this.Transactions.offBeforeTxSigned(callback);
}
/**
* @inheritDoc
*/
randomAddress() {
return (0, Utils_1.toHex)(starknet_1.stark.randomAddress());
}
/**
* @inheritDoc
*/
randomSigner() {
const privateKey = "0x" + buffer_1.Buffer.from(starknet_1.ec.starkCurve.utils.randomPrivateKey()).toString("hex");
const wallet = new StarknetKeypairWallet_1.StarknetKeypairWallet(this.provider, privateKey);
return new StarknetSigner_1.StarknetSigner(wallet);
}
////////////////////////////////////////////
//// Transactions
/**
* @inheritDoc
*/
sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
}
/**
* @inheritDoc
*/
sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
return this.Transactions.sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
}
/**
* @inheritDoc
*/
async prepareTxs(txs) {
await this.Transactions.prepareTransactions(txs);
return txs;
}
/**
* @inheritDoc
*/
serializeTx(tx) {
return Promise.resolve(StarknetTransactions_1.StarknetTransactions.serializeTx(tx));
}
/**
* @inheritDoc
*/
deserializeTx(txData) {
return Promise.resolve(StarknetTransactions_1.StarknetTransactions.deserializeTx(txData));
}
/**
* @inheritDoc
*/
serializeSignedTx(signedTx) {
return Promise.resolve(StarknetTransactions_1.StarknetTransactions.serializeTx(signedTx));
}
/**
* @inheritDoc
*/
deserializeSignedTx(txData) {
return Promise.resolve(StarknetTransactions_1.StarknetTransactions.deserializeTx(txData));
}
/**
* @inheritDoc
*/
getTxId(signedTX) {
return Promise.resolve(signedTX.txId ?? (0, Utils_1.calculateHash)(signedTX));
}
/**
* @inheritDoc
*/
getTxIdStatus(txId) {
return this.Transactions.getTxIdStatus(txId);
}
/**
* @inheritDoc
*/
getTxStatus(tx) {
return this.Transactions.getTxStatus(tx);
}
/**
* @inheritDoc
*/
async getFinalizedBlock() {
const block = await this.Blocks.getBlock("l1_accepted");
return {
height: block.block_number,
blockHash: block.block_hash
};
}
/**
* @inheritDoc
*/
txsTransfer(signer, token, amount, dstAddress, feeRate) {
return this.Tokens.txsTransfer(signer, token, amount, dstAddress, feeRate);
}
/**
* @inheritDoc
*/
async transfer(signer, token, amount, dstAddress, txOptions) {
const txs = await this.Tokens.txsTransfer(signer.getAddress(), token, amount, dstAddress, txOptions?.feeRate);
const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
return txId;
}
/**
* @inheritDoc
*/
wrapSigner(signer) {
if (signer.walletProvider != null) {
return Promise.resolve(new StarknetBrowserSigner_1.StarknetBrowserSigner(signer));
}
else {
return Promise.resolve(new StarknetSigner_1.StarknetSigner(signer));
}
}
async verifyNetwork(bitcoinNetwork) {
if (this.bitcoinNetwork != null && bitcoinNetwork !== this.bitcoinNetwork)
throw new Error(`Network mismatch, the chain interface was not setup for ${base_1.BitcoinNetwork[bitcoinNetwork]}, chain interface network: ${base_1.BitcoinNetwork[this.bitcoinNetwork]}`);
const chainId = await this.provider.getChainId();
if (chainId !== starknet_1.constants.StarknetChainId.SN_MAIN && chainId !== starknet_1.constants.StarknetChainId.SN_SEPOLIA) {
starknet_1.logger.warn(`verifyNetwork(): Using non-standard chainId ${chainId}, skipping network verfication!`);
return;
}
if (this.starknetChainId !== chainId)
throw new Error(`Network mismatch, the underlying RPC provider isn't using the correct chainId, expected: ${this.starknetChainId}, provider returned: ${chainId}`);
}
}
exports.StarknetChainInterface = StarknetChainInterface;