blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: add commitment param to JSON RPC API requests (#549) 

* feat: add commitment param to json rpc requests

* fix: tests and examples

* fix: docs

* fix: epoch info test

* fix: budget example

* fix: test timeout

* fix: remove MAX_COMMITMENT and RECENT_COMMITMENT types
This commit is contained in:
Justin Starry 2019-11-11 13:01:10 -05:00 committed by Michael Vines
parent d0c89f7fa3
commit 189807f5a5
10 changed files with 253 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
web3.js/examples/budget-timestamp.js
View File

@ -13,7 +13,7 @@ const contractState = new solanaWeb3.Account();
let url;
url = 'http://localhost:8899';
const connection = new solanaWeb3.Connection(url);
const connection = new solanaWeb3.Connection(url, 'recent');
function showBalance() {
console.log(`\n== Account State`);
@ -50,9 +50,9 @@ function confirmTransaction(signature) {
}
function airDrop() {
console.log(`\n== Requesting airdrop of 100 to ${account1.publicKey}`);
console.log(`\n== Requesting airdrop of 100000 to ${account1.publicKey}`);
return connection
.requestAirdrop(account1.publicKey, 100)
.requestAirdrop(account1.publicKey, 100000)
.then(confirmTransaction);
}

4
web3.js/examples/budget-two-approvers.js
View File

@ -16,7 +16,7 @@ const approver2 = new solanaWeb3.Account();
let url;
url = 'http://localhost:8899';
//url = 'http://testnet.solana.com:8899';
const connection = new solanaWeb3.Connection(url);
const connection = new solanaWeb3.Connection(url, 'recent');
function getTransactionFee() {
return connection.getRecentBlockhash().then(response => {
@ -59,7 +59,7 @@ function confirmTransaction(signature) {
}
function airDrop(feeCalculator) {
const airdrop = 100 + 3 * feeCalculator.targetLamportsPerSignature;
const airdrop = 100 + 5 * feeCalculator.targetLamportsPerSignature;
console.log(`\n== Requesting airdrop of ${airdrop} to ${account1.publicKey}`);
return connection
.requestAirdrop(account1.publicKey, airdrop)

42
web3.js/module.flow.js
View File

@ -47,6 +47,8 @@ declare module '@solana/web3.js' {
/* TODO */
// === src/connection.js ===
declare export type Commitment = 'max' | 'recent';
declare export type AccountInfo = {
executable: boolean,
owner: PublicKey,
@ -104,28 +106,39 @@ declare module '@solana/web3.js' {
};
declare export class Connection {
constructor(endpoint: string): Connection;
getAccountInfo(publicKey: PublicKey): Promise<AccountInfo>;
constructor(endpoint: string, commitment: ?Commitment): Connection;
getAccountInfo(
publicKey: PublicKey,
commitment: ?Commitment,
): Promise<AccountInfo>;
getProgramAccounts(
programId: PublicKey,
commitment: ?Commitment,
): Promise<Array<[PublicKey, AccountInfo]>>;
getBalance(publicKey: PublicKey): Promise<number>;
getBalance(publicKey: PublicKey, commitment: ?Commitment): Promise<number>;
getClusterNodes(): Promise<Array<ContactInfo>>;
getVoteAccounts(): Promise<VoteAccountStatus>;
confirmTransaction(signature: TransactionSignature): Promise<boolean>;
getSlot(): Promise<number>;
getSlotLeader(): Promise<string>;
getVoteAccounts(commitment: ?Commitment): Promise<VoteAccountStatus>;
confirmTransaction(
signature: TransactionSignature,
commitment: ?Commitment,
): Promise<boolean>;
getSlot(commitment: ?Commitment): Promise<number>;
getSlotLeader(commitment: ?Commitment): Promise<string>;
getSignatureStatus(
signature: TransactionSignature,
commitment: ?Commitment,
): Promise<SignatureSuccess | TransactionError | null>;
getTransactionCount(): Promise<number>;
getTotalSupply(): Promise<number>;
getInflation(): Promise<Inflation>;
getTransactionCount(commitment: ?Commitment): Promise<number>;
getTotalSupply(commitment: ?Commitment): Promise<number>;
getInflation(commitment: ?Commitment): Promise<Inflation>;
getEpochSchedule(): Promise<EpochSchedule>;
getRecentBlockhash(): Promise<[Blockhash, FeeCalculator]>;
getRecentBlockhash(
commitment: ?Commitment,
): Promise<[Blockhash, FeeCalculator]>;
requestAirdrop(
to: PublicKey,
amount: number,
commitment: ?Commitment,
): Promise<TransactionSignature>;
sendTransaction(
transaction: Transaction,
@ -287,10 +300,17 @@ declare module '@solana/web3.js' {
...signers: Array<Account>
): Promise<TransactionSignature>;
declare export function sendAndConfirmRecentTransaction(
connection: Connection,
transaction: Transaction,
...signers: Array<Account>
): Promise<TransactionSignature>;
// === src/util/send-and-confirm-raw-transaction.js ===
declare export function sendAndConfirmRawTransaction(
connection: Connection,
wireTransaction: Buffer,
commitment: ?Commitment,
): Promise<TransactionSignature>;
// === src/util/testnet.js ===

118
web3.js/src/connection.js
View File

@ -18,6 +18,15 @@ import type {TransactionSignature} from './transaction';
type RpcRequest = (methodName: string, args: Array<any>) => any;
/**
* The level of commitment desired when querying state
* 'max': Query the most recent block which has reached max voter lockout
* 'recent': Query the most recent block
*
* @typedef {'max' | 'recent'} Commitment
*/
export type Commitment = 'max' | 'recent';
/**
* Information describing a cluster node
*
@ -488,6 +497,7 @@ export class Connection {
_rpcWebSocket: RpcWebSocketClient;
_rpcWebSocketConnected: boolean = false;
_commitment: ?Commitment;
_blockhashInfo: {
recentBlockhash: Blockhash | null,
seconds: number,
@ -505,11 +515,13 @@ export class Connection {
* Establish a JSON RPC connection
*
* @param endpoint URL to the fullnode JSON RPC endpoint
* @param commitment optional default commitment level
*/
constructor(endpoint: string) {
constructor(endpoint: string, commitment: ?Commitment) {
let url = urlParse(endpoint);
this._rpcRequest = createRpcRequest(url.href);
this._commitment = commitment;
this._blockhashInfo = {
recentBlockhash: null,
seconds: -1,
@ -542,10 +554,12 @@ export class Connection {
/**
* Fetch the balance for the specified public key
*/
async getBalance(publicKey: PublicKey): Promise<number> {
const unsafeRes = await this._rpcRequest('getBalance', [
publicKey.toBase58(),
]);
async getBalance(
publicKey: PublicKey,
commitment: ?Commitment,
): Promise<number> {
const args = this._argsWithCommitment([publicKey.toBase58()], commitment);
const unsafeRes = await this._rpcRequest('getBalance', args);
const res = GetBalanceRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -557,10 +571,12 @@ export class Connection {
/**
* Fetch all the account info for the specified public key
*/
async getAccountInfo(publicKey: PublicKey): Promise<AccountInfo> {
const unsafeRes = await this._rpcRequest('getAccountInfo', [
publicKey.toBase58(),
]);
async getAccountInfo(
publicKey: PublicKey,
commitment: ?Commitment,
): Promise<AccountInfo> {
const args = this._argsWithCommitment([publicKey.toBase58()], commitment);
const unsafeRes = await this._rpcRequest('getAccountInfo', args);
const res = GetAccountInfoRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -582,10 +598,10 @@ export class Connection {
*/
async getProgramAccounts(
programId: PublicKey,
commitment: ?Commitment,
): Promise<Array<PublicKeyAndAccount>> {
const unsafeRes = await this._rpcRequest('getProgramAccounts', [
programId.toBase58(),
]);
const args = this._argsWithCommitment([programId.toBase58()], commitment);
const unsafeRes = await this._rpcRequest('getProgramAccounts', args);
const res = GetProgramAccountsRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -610,8 +626,12 @@ export class Connection {
/**
* Confirm the transaction identified by the specified signature
*/
async confirmTransaction(signature: TransactionSignature): Promise<boolean> {
const unsafeRes = await this._rpcRequest('confirmTransaction', [signature]);
async confirmTransaction(
signature: TransactionSignature,
commitment: ?Commitment,
): Promise<boolean> {
const args = this._argsWithCommitment([signature], commitment);
const unsafeRes = await this._rpcRequest('confirmTransaction', args);
const res = ConfirmTransactionRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -654,8 +674,9 @@ export class Connection {
/**
* Return the list of nodes that are currently participating in the cluster
*/
async getVoteAccounts(): Promise<VoteAccountStatus> {
const unsafeRes = await this._rpcRequest('getVoteAccounts', []);
async getVoteAccounts(commitment: ?Commitment): Promise<VoteAccountStatus> {
const args = this._argsWithCommitment([], commitment);
const unsafeRes = await this._rpcRequest('getVoteAccounts', args);
const res = GetVoteAccounts(unsafeRes);
//const res = unsafeRes;
if (res.error) {
@ -668,8 +689,9 @@ export class Connection {
/**
* Fetch the current slot that the node is processing
*/
async getSlot(): Promise<number> {
const unsafeRes = await this._rpcRequest('getSlot', []);
async getSlot(commitment: ?Commitment): Promise<number> {
const args = this._argsWithCommitment([], commitment);
const unsafeRes = await this._rpcRequest('getSlot', args);
const res = GetSlot(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -681,8 +703,9 @@ export class Connection {
/**
* Fetch the current slot leader of the cluster
*/
async getSlotLeader(): Promise<string> {
const unsafeRes = await this._rpcRequest('getSlotLeader', []);
async getSlotLeader(commitment: ?Commitment): Promise<string> {
const args = this._argsWithCommitment([], commitment);
const unsafeRes = await this._rpcRequest('getSlotLeader', args);
const res = GetSlotLeader(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -696,8 +719,10 @@ export class Connection {
*/
async getSignatureStatus(
signature: TransactionSignature,
commitment: ?Commitment,
): Promise<SignatureSuccess | TransactionError | null> {
const unsafeRes = await this._rpcRequest('getSignatureStatus', [signature]);
const args = this._argsWithCommitment([signature], commitment);
const unsafeRes = await this._rpcRequest('getSignatureStatus', args);
const res = GetSignatureStatusRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -709,8 +734,9 @@ export class Connection {
/**
* Fetch the current transaction count of the cluster
*/
async getTransactionCount(): Promise<number> {
const unsafeRes = await this._rpcRequest('getTransactionCount', []);
async getTransactionCount(commitment: ?Commitment): Promise<number> {
const args = this._argsWithCommitment([], commitment);
const unsafeRes = await this._rpcRequest('getTransactionCount', args);
const res = GetTransactionCountRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -722,8 +748,9 @@ export class Connection {
/**
* Fetch the current total currency supply of the cluster in lamports
*/
async getTotalSupply(): Promise<number> {
const unsafeRes = await this._rpcRequest('getTotalSupply', []);
async getTotalSupply(commitment: ?Commitment): Promise<number> {
const args = this._argsWithCommitment([], commitment);
const unsafeRes = await this._rpcRequest('getTotalSupply', args);
const res = GetTotalSupplyRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -735,8 +762,9 @@ export class Connection {
/**
* Fetch the cluster Inflation parameters
*/
async getInflation(): Promise<GetInflationRpcResult> {
const unsafeRes = await this._rpcRequest('getInflation', []);
async getInflation(commitment: ?Commitment): Promise<GetInflationRpcResult> {
const args = this._argsWithCommitment([], commitment);
const unsafeRes = await this._rpcRequest('getInflation', args);
const res = GetInflationRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -748,8 +776,9 @@ export class Connection {
/**
* Fetch the Epoch Info parameters
*/
async getEpochInfo(): Promise<GetEpochInfoRpcResult> {
const unsafeRes = await this._rpcRequest('getEpochInfo', []);
async getEpochInfo(commitment: ?Commitment): Promise<GetEpochInfoRpcResult> {
const args = this._argsWithCommitment([], commitment);
const unsafeRes = await this._rpcRequest('getEpochInfo', args);
const res = GetEpochInfoRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
@ -775,10 +804,14 @@ export class Connection {
* Fetch the minimum balance needed to exempt an account of `dataLength`
* size from rent
*/
async getMinimumBalanceForRentExemption(dataLength: number): Promise<number> {
async getMinimumBalanceForRentExemption(
dataLength: number,
commitment: ?Commitment,
): Promise<number> {
const args = this._argsWithCommitment([dataLength], commitment);
const unsafeRes = await this._rpcRequest(
'getMinimumBalanceForRentExemption',
[dataLength],
args,
);
const res = GetMinimumBalanceForRentExemptionRpcResult(unsafeRes);
if (res.error) {
@ -792,8 +825,11 @@ export class Connection {
/**
* Fetch a recent blockhash from the cluster
*/
async getRecentBlockhash(): Promise<BlockhashAndFeeCalculator> {
const unsafeRes = await this._rpcRequest('getRecentBlockhash', []);
async getRecentBlockhash(
commitment: ?Commitment,
): Promise<BlockhashAndFeeCalculator> {
const args = this._argsWithCommitment([], commitment);
const unsafeRes = await this._rpcRequest('getRecentBlockhash', args);
// Legacy v0.16 response. TODO: Remove in September 2019
try {
@ -823,17 +859,15 @@ export class Connection {
async requestAirdrop(
to: PublicKey,
amount: number,
commitment: ?Commitment,
): Promise<TransactionSignature> {
const unsafeRes = await this._rpcRequest('requestAirdrop', [
to.toBase58(),
amount,
]);
const args = this._argsWithCommitment([to.toBase58(), amount], commitment);
const unsafeRes = await this._rpcRequest('requestAirdrop', args);
const res = RequestAirdropRpcResult(unsafeRes);
if (res.error) {
throw new Error(res.error.message);
}
assert(typeof res.result !== 'undefined');
await sleep(500);
return res.result;
}
@ -1170,4 +1204,12 @@ export class Connection {
throw new Error(`Unknown account change id: ${id}`);
}
}
_argsWithCommitment(args: Array<any>, override: ?Commitment): Array<any> {
const commitment = override || this._commitment;
if (commitment) {
args.push({commitment});
}
return args;
}
}

4
web3.js/src/util/send-and-confirm-raw-transaction.js
View File

@ -1,6 +1,7 @@
// @flow
import {Connection} from '../connection';
import type {Commitment} from '../connection';
import {sleep} from './sleep';
import type {TransactionSignature} from '../transaction';
import {DEFAULT_TICKS_PER_SLOT, NUM_TICKS_PER_SECOND} from '../timing';
@ -11,6 +12,7 @@ import {DEFAULT_TICKS_PER_SLOT, NUM_TICKS_PER_SECOND} from '../timing';
export async function sendAndConfirmRawTransaction(
connection: Connection,
rawTransaction: Buffer,
commitment: ?Commitment,
): Promise<TransactionSignature> {
const start = Date.now();
let signature = await connection.sendRawTransaction(rawTransaction);
@ -19,7 +21,7 @@ export async function sendAndConfirmRawTransaction(
let status = null;
let statusRetries = 6;
for (;;) {
status = await connection.getSignatureStatus(signature);
status = await connection.getSignatureStatus(signature, commitment);
if (status) {
break;
}

28
web3.js/src/util/send-and-confirm-transaction.js
View File

@ -3,12 +3,29 @@
import invariant from 'assert';
import {Connection} from '../connection';
import type {Commitment} from '../connection';
import {Transaction} from '../transaction';
import {sleep} from './sleep';
import type {Account} from '../account';
import type {TransactionSignature} from '../transaction';
import {DEFAULT_TICKS_PER_SLOT, NUM_TICKS_PER_SECOND} from '../timing';
/**
* Sign, send and confirm a transaction with recent commitment level
*/
export async function sendAndConfirmRecentTransaction(
connection: Connection,
transaction: Transaction,
...signers: Array<Account>
): Promise<TransactionSignature> {
return await _sendAndConfirmTransaction(
connection,
transaction,
signers,
'recent',
);
}
/**
* Sign, send and confirm a transaction
*/
@ -16,6 +33,15 @@ export async function sendAndConfirmTransaction(
connection: Connection,
transaction: Transaction,
...signers: Array<Account>
): Promise<TransactionSignature> {
return await _sendAndConfirmTransaction(connection, transaction, signers);
}
async function _sendAndConfirmTransaction(
connection: Connection,
transaction: Transaction,
signers: Array<Account>,
commitment: ?Commitment,
): Promise<TransactionSignature> {
let sendRetries = 10;
let signature;
@ -27,7 +53,7 @@ export async function sendAndConfirmTransaction(
let status = null;
let statusRetries = 6;
for (;;) {
status = await connection.getSignatureStatus(signature);
status = await connection.getSignatureStatus(signature, commitment);
if (status) {
break;
}

4
web3.js/test/bpf-loader.test.js
View File

@ -27,7 +27,7 @@ test('load BPF C program', async () => {
const data = await fs.readFile('test/fixtures/noop-c/noop.so');
const connection = new Connection(url);
const connection = new Connection(url, 'recent');
const [, feeCalculator] = await connection.getRecentBlockhash();
const fees =
feeCalculator.lamportsPerSignature *
@ -52,7 +52,7 @@ test('load BPF Rust program', async () => {
'test/fixtures/noop-rust/solana_bpf_rust_noop.so',
);
const connection = new Connection(url);
const connection = new Connection(url, 'recent');
const [, feeCalculator] = await connection.getRecentBlockhash();
const fees =
feeCalculator.lamportsPerSignature *

120
web3.js/test/connection.test.js
View File

@ -15,7 +15,7 @@ import {url} from './url';
import {sleep} from '../src/util/sleep';
if (!mockRpcEnabled) {
// The default of 5 seconds is too slow for live testing sometimes
// Testing max commitment level takes around 20s to complete
jest.setTimeout(30000);
}
@ -51,7 +51,7 @@ test('get program accounts', async () => {
return;
}
const connection = new Connection(url);
const connection = new Connection(url, 'recent');
const account0 = new Account();
const account1 = new Account();
const programId = new Account();
@ -171,18 +171,18 @@ test('get inflation', async () => {
});
test('get epoch info', async () => {
const connection = new Connection(url);
const connection = new Connection(url, 'recent');
mockRpc.push([
url,
{
method: 'getEpochInfo',
params: [],
params: [{commitment: 'recent'}],
},
{
error: null,
result: {
epoch: 1,
epoch: 0,
slotIndex: 1,
slotsInEpoch: 8192,
absoluteSlot: 1,
@ -194,7 +194,7 @@ test('get epoch info', async () => {
for (const key of ['epoch', 'slotIndex', 'slotsInEpoch', 'absoluteSlot']) {
expect(epochInfo).toHaveProperty(key);
expect(epochInfo[key]).toBeGreaterThan(0);
expect(epochInfo[key]).toBeGreaterThanOrEqual(0);
}
});
@ -434,13 +434,13 @@ test('get recent blockhash', async () => {
test('request airdrop', async () => {
const account = new Account();
const connection = new Connection(url);
const connection = new Connection(url, 'recent');
mockRpc.push([
url,
{
method: 'requestAirdrop',
params: [account.publicKey.toBase58(), 40],
params: [account.publicKey.toBase58(), 40, {commitment: 'recent'}],
},
{
error: null,
@ -452,7 +452,7 @@ test('request airdrop', async () => {
url,
{
method: 'requestAirdrop',
params: [account.publicKey.toBase58(), 2],
params: [account.publicKey.toBase58(), 2, {commitment: 'recent'}],
},
{
error: null,
@ -464,7 +464,7 @@ test('request airdrop', async () => {
url,
{
method: 'getBalance',
params: [account.publicKey.toBase58()],
params: [account.publicKey.toBase58(), {commitment: 'recent'}],
},
{
error: null,
@ -482,7 +482,7 @@ test('request airdrop', async () => {
url,
{
method: 'getAccountInfo',
params: [account.publicKey.toBase58()],
params: [account.publicKey.toBase58(), {commitment: 'recent'}],
},
{
error: null,
@ -534,16 +534,54 @@ test('request airdrop', async () => {
expect(accountInfo.owner).toEqual(SystemProgram.programId);
});
test('transaction', async () => {
const accountFrom = new Account();
const accountTo = new Account();
const connection = new Connection(url);
// expected to take around 20s
test('request airdrop - max commitment', async () => {
const account = new Account();
const connection = new Connection(url, 'max');
mockRpc.push([
url,
{
method: 'requestAirdrop',
params: [accountFrom.publicKey.toBase58(), 100010],
params: [account.publicKey.toBase58(), 40, {commitment: 'max'}],
},
{
error: null,
result:
'1WE5w4B7v59x6qjyC4FbG2FEKYKQfvsJwqSxNVmtMjT8TQ31hsZieDHcSgqzxiAoTL56n2w5TncjqEKjLhtF4Vk',
},
]);
mockRpc.push([
url,
{
method: 'getBalance',
params: [account.publicKey.toBase58(), {commitment: 'max'}],
},
{
error: null,
result: 40,
},
]);
await connection.requestAirdrop(account.publicKey, 40);
const balance = await connection.getBalance(account.publicKey);
expect(balance).toBe(40);
});
test('transaction', async () => {
const accountFrom = new Account();
const accountTo = new Account();
const connection = new Connection(url, 'recent');
mockRpc.push([
url,
{
method: 'requestAirdrop',
params: [
accountFrom.publicKey.toBase58(),
100010,
{commitment: 'recent'},
],
},
{
error: null,
@ -555,7 +593,7 @@ test('transaction', async () => {
url,
{
method: 'getBalance',
params: [accountFrom.publicKey.toBase58()],
params: [accountFrom.publicKey.toBase58(), {commitment: 'recent'}],
},
{
error: null,
@ -569,7 +607,7 @@ test('transaction', async () => {
url,
{
method: 'requestAirdrop',
params: [accountTo.publicKey.toBase58(), 21],
params: [accountTo.publicKey.toBase58(), 21, {commitment: 'recent'}],
},
{
error: null,
@ -581,7 +619,7 @@ test('transaction', async () => {
url,
{
method: 'getBalance',
params: [accountTo.publicKey.toBase58()],
params: [accountTo.publicKey.toBase58(), {commitment: 'recent'}],
},
{
error: null,
@ -591,7 +629,7 @@ test('transaction', async () => {
await connection.requestAirdrop(accountTo.publicKey, 21);
expect(await connection.getBalance(accountTo.publicKey)).toBe(21);
mockGetRecentBlockhash();
mockGetRecentBlockhash('recent');
mockRpc.push([
url,
{
@ -617,6 +655,7 @@ test('transaction', async () => {
method: 'confirmTransaction',
params: [
'3WE5w4B7v59x6qjyC4FbG2FEKYKQfvsJwqSxNVmtMjT8TQ31hsZieDHcSgqzxiAoTL56n2w5TncjqEKjLhtF4Vk',
{commitment: 'recent'},
],
},
{
@ -642,6 +681,7 @@ test('transaction', async () => {
method: 'getSignatureStatus',
params: [
'3WE5w4B7v59x6qjyC4FbG2FEKYKQfvsJwqSxNVmtMjT8TQ31hsZieDHcSgqzxiAoTL56n2w5TncjqEKjLhtF4Vk',
{commitment: 'recent'},
],
},
{
@ -657,7 +697,7 @@ test('transaction', async () => {
url,
{
method: 'getBalance',
params: [accountFrom.publicKey.toBase58()],
params: [accountFrom.publicKey.toBase58(), {commitment: 'recent'}],
},
{
error: null,
@ -674,7 +714,7 @@ test('transaction', async () => {
url,
{
method: 'getBalance',
params: [accountTo.publicKey.toBase58()],
params: [accountTo.publicKey.toBase58(), {commitment: 'recent'}],
},
{
error: null,
@ -692,7 +732,7 @@ test('multi-instruction transaction', async () => {
const accountFrom = new Account();
const accountTo = new Account();
const connection = new Connection(url);
const connection = new Connection(url, 'recent');
await connection.requestAirdrop(accountFrom.publicKey, SOL_LAMPORTS);
expect(await connection.getBalance(accountFrom.publicKey)).toBe(SOL_LAMPORTS);
@ -743,7 +783,7 @@ test('account change notification', async () => {
return;
}
const connection = new Connection(url);
const connection = new Connection(url, 'recent');
const owner = new Account();
const programAccount = new Account();
@ -755,11 +795,16 @@ test('account change notification', async () => {
);
await connection.requestAirdrop(owner.publicKey, SOL_LAMPORTS);
await Loader.load(connection, owner, programAccount, BpfLoader.programId, [
1,
2,
3,
]);
try {
await Loader.load(connection, owner, programAccount, BpfLoader.programId, [
1,
2,
3,
]);
} catch (err) {
await connection.removeAccountChangeListener(subscriptionId);
throw err;
}
// Wait for mockCallback to receive a call
let i = 0;
@ -788,7 +833,7 @@ test('program account change notification', async () => {
return;
}
const connection = new Connection(url);
const connection = new Connection(url, 'recent');
const owner = new Account();
const programAccount = new Account();
@ -809,11 +854,16 @@ test('program account change notification', async () => {
);
await connection.requestAirdrop(owner.publicKey, SOL_LAMPORTS);
await Loader.load(connection, owner, programAccount, BpfLoader.programId, [
1,
2,
3,
]);
try {
await Loader.load(connection, owner, programAccount, BpfLoader.programId, [
1,
2,
3,
]);
} catch (err) {
await connection.removeProgramAccountChangeListener(subscriptionId);
throw err;
}
// Wait for mockCallback to receive a call
let i = 0;

9
web3.js/test/mockrpc/get-recent-blockhash.js
View File

@ -1,17 +1,22 @@
// @flow
import {Account} from '../../src';
import type {Commitment} from '../../src/connection';
import {url} from '../url';
import {mockRpc} from '../__mocks__/node-fetch';
export function mockGetRecentBlockhash() {
export function mockGetRecentBlockhash(commitment: ?Commitment) {
const recentBlockhash = new Account();
const params = [];
if (commitment) {
params.push({commitment});
}
mockRpc.push([
url,
{
method: 'getRecentBlockhash',
params: [],
params,
},
{
error: null,

20
web3.js/test/transaction-payer.test.js
View File

@ -14,13 +14,17 @@ test('transaction-payer', async () => {
const accountPayer = new Account();
const accountFrom = new Account();
const accountTo = new Account();
const connection = new Connection(url);
const connection = new Connection(url, 'recent');
mockRpc.push([
url,
{
method: 'requestAirdrop',
params: [accountPayer.publicKey.toBase58(), SOL_LAMPORTS],
params: [
accountPayer.publicKey.toBase58(),
SOL_LAMPORTS,
{commitment: 'recent'},
],
},
{
error: null,
@ -34,7 +38,7 @@ test('transaction-payer', async () => {
url,
{
method: 'requestAirdrop',
params: [accountFrom.publicKey.toBase58(), 12],
params: [accountFrom.publicKey.toBase58(), 12, {commitment: 'recent'}],
},
{
error: null,
@ -48,7 +52,7 @@ test('transaction-payer', async () => {
url,
{
method: 'requestAirdrop',
params: [accountTo.publicKey.toBase58(), 21],
params: [accountTo.publicKey.toBase58(), 21, {commitment: 'recent'}],
},
{
error: null,
@ -58,7 +62,7 @@ test('transaction-payer', async () => {
]);
await connection.requestAirdrop(accountTo.publicKey, 21);
mockGetRecentBlockhash();
mockGetRecentBlockhash('recent');
mockRpc.push([
url,
{
@ -89,6 +93,7 @@ test('transaction-payer', async () => {
method: 'confirmTransaction',
params: [
'3WE5w4B7v59x6qjyC4FbG2FEKYKQfvsJwqSxNVmtMjT8TQ31hsZieDHcSgqzxiAoTL56n2w5TncjqEKjLhtF4Vk',
{commitment: 'recent'},
],
},
{
@ -114,6 +119,7 @@ test('transaction-payer', async () => {
method: 'getSignatureStatus',
params: [
'3WE5w4B7v59x6qjyC4FbG2FEKYKQfvsJwqSxNVmtMjT8TQ31hsZieDHcSgqzxiAoTL56n2w5TncjqEKjLhtF4Vk',
{commitment: 'recent'},
],
},
{
@ -129,7 +135,7 @@ test('transaction-payer', async () => {
url,
{
method: 'getBalance',
params: [accountPayer.publicKey.toBase58()],
params: [accountPayer.publicKey.toBase58(), {commitment: 'recent'}],
},
{
error: null,
@ -148,7 +154,7 @@ test('transaction-payer', async () => {
url,
{
method: 'getBalance',
params: [accountFrom.publicKey.toBase58()],
params: [accountFrom.publicKey.toBase58(), {commitment: 'recent'}],
},
{
error: null,