From 532b28e96e71c209e2d3f84a292f1ad7deb986e5 Mon Sep 17 00:00:00 2001 From: Tyera Eulberg Date: Mon, 23 Dec 2019 11:46:49 -0700 Subject: [PATCH] feat: add stake program methods; refactor instruction type handling --- web3.js/flow-typed/hasha.js | 4 + web3.js/module.flow.js | 74 +++++- web3.js/package-lock.json | 21 ++ web3.js/package.json | 1 + web3.js/src/config-program.js | 6 + web3.js/src/index.js | 15 +- web3.js/src/instruction.js | 27 +++ web3.js/src/layout.js | 20 ++ web3.js/src/loader.js | 2 +- web3.js/src/publickey.js | 12 +- web3.js/src/stake-program.js | 395 +++++++++++++++++++++++++++++++++ web3.js/src/system-program.js | 35 +-- web3.js/src/sysvar-rent.js | 6 - web3.js/src/sysvar.js | 18 ++ web3.js/src/vote-account.js | 2 +- web3.js/test/publickey.test.js | 12 +- 16 files changed, 602 insertions(+), 48 deletions(-) create mode 100644 web3.js/flow-typed/hasha.js create mode 100644 web3.js/src/config-program.js create mode 100644 web3.js/src/instruction.js create mode 100644 web3.js/src/stake-program.js delete mode 100644 web3.js/src/sysvar-rent.js create mode 100644 web3.js/src/sysvar.js diff --git a/web3.js/flow-typed/hasha.js b/web3.js/flow-typed/hasha.js new file mode 100644 index 0000000000..4d3113a2a8 --- /dev/null +++ b/web3.js/flow-typed/hasha.js @@ -0,0 +1,4 @@ +declare module 'hasha' { + // TODO: Fill in types + declare module.exports: any; +} diff --git a/web3.js/module.flow.js b/web3.js/module.flow.js index 876040b976..c915c387b0 100644 --- a/web3.js/module.flow.js +++ b/web3.js/module.flow.js @@ -203,6 +203,62 @@ declare module '@solana/web3.js' { validatorExit(): Promise; } + // === src/config-program.js === + declare export var CONFIG_PROGRAM_ID; + + // === src/stake-program.js === + declare export class StakeProgram { + static programId: PublicKey; + static space: number; + + static createAccount( + from: PublicKey, + stakeAccount: PublicKey, + authorized: Authorized, + lockup: Lockup, + lamports: number, + ): Transaction; + static createAccountWithSeed( + from: PublicKey, + stakeAccount: PublicKey, + seed: string, + authorized: Authorized, + lockup: Lockup, + lamports: number, + ): Transaction; + static delegate( + stakeAccount: PublicKey, + authorizedPubkey: PublicKey, + votePubkey: PublicKey, + ): Transaction; + static authorize( + stakeAccount: PublicKey, + authorizedPubkey: PublicKey, + newAuthorized: PublicKey, + stakeAuthorizationType: StakeAuthorizationType, + ): Transaction; + static redeemVoteCredits( + stakeAccount: PublicKey, + votePubkey: PublicKey, + ): Transaction; + static split( + stakeAccount: PublicKey, + authorizedPubkey: PublicKey, + lamports: number, + splitStakePubkey: PublicKey, + ): Transaction; + static withdraw( + stakeAccount: PublicKey, + withdrawerPubkey: PublicKey, + to: PublicKey, + lamports: number, + ): Transaction; + static deactivate( + stakeAccount: PublicKey, + authorizedPubkey: PublicKey, + ): Transaction; + } + // === src/system-program.js === declare export class SystemProgram { static programId: PublicKey; @@ -248,11 +304,14 @@ declare module '@solana/web3.js' { static fromConfigData(buffer: Buffer): ?ValidatorInfo; } - // === src/sysvar-rent.js === + // === src/sysvar.js === + declare export var SYSVAR_CLOCK_PUBKEY; declare export var SYSVAR_RENT_PUBKEY; + declare export var SYSVAR_REWARDS_PUBKEY; + declare export var SYSVAR_STAKE_HISTORY_PUBKEY; // === src/vote-account.js === - declare export var VOTE_ACCOUNT_KEY; + declare export var VOTE_PROGRAM_ID; declare export type Lockout = {| slot: number, confirmationCount: number, @@ -277,6 +336,17 @@ declare module '@solana/web3.js' { static fromAccountData(buffer: Buffer): VoteAccount; } + // === src/instruction.js === + declare export type InstructionType = {| + index: number, + layout: typeof BufferLayout, + |}; + + declare export function encodeData( + type: InstructionType, + fields: Object, + ): Buffer; + // === src/transaction.js === declare export type TransactionSignature = string; diff --git a/web3.js/package-lock.json b/web3.js/package-lock.json index a127166e0f..13ea8d611c 100644 --- a/web3.js/package-lock.json +++ b/web3.js/package-lock.json @@ -9692,6 +9692,27 @@ "minimalistic-assert": "^1.0.1" } }, + "hasha": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/hasha/-/hasha-5.1.0.tgz", + "integrity": "sha512-OFPDWmzPN1l7atOV1TgBVmNtBxaIysToK6Ve9DK+vT6pYuklw/nPNT+HJbZi0KDcI6vWB+9tgvZ5YD7fA3CXcA==", + "requires": { + "is-stream": "^2.0.0", + "type-fest": "^0.8.0" + }, + "dependencies": { + "is-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.0.tgz", + "integrity": "sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==" + }, + "type-fest": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz", + "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==" + } + } + }, "hawk": { "version": "6.0.2", "resolved": "https://registry.npmjs.org/hawk/-/hawk-6.0.2.tgz", diff --git a/web3.js/package.json b/web3.js/package.json index 0492c5349f..b70933a7b5 100644 --- a/web3.js/package.json +++ b/web3.js/package.json @@ -71,6 +71,7 @@ "bs58": "^4.0.1", "buffer-layout": "^1.2.0", "esdoc-inject-style-plugin": "^1.0.0", + "hasha": "^5.1.0", "jayson": "^3.0.1", "mz": "^2.7.0", "node-fetch": "^2.2.0", diff --git a/web3.js/src/config-program.js b/web3.js/src/config-program.js new file mode 100644 index 0000000000..54029afe0f --- /dev/null +++ b/web3.js/src/config-program.js @@ -0,0 +1,6 @@ +// @flow +import {PublicKey} from './publickey'; + +export const CONFIG_PROGRAM_ID = new PublicKey( + 'Config1111111111111111111111111111111111111', +); diff --git a/web3.js/src/index.js b/web3.js/src/index.js index 424d9e902a..edcb9f81ec 100644 --- a/web3.js/src/index.js +++ b/web3.js/src/index.js @@ -2,21 +2,26 @@ export {Account} from './account'; export {BpfLoader} from './bpf-loader'; export {BudgetProgram} from './budget-program'; +export {CONFIG_PROGRAM_ID} from './config-program'; export {Connection} from './connection'; export {Loader} from './loader'; export {PublicKey} from './publickey'; +export {StakeInstruction, StakeProgram} from './stake-program'; export {SystemInstruction, SystemProgram} from './system-program'; export {Transaction, TransactionInstruction} from './transaction'; export {VALIDATOR_INFO_KEY, ValidatorInfo} from './validator-info'; -export {VOTE_ACCOUNT_KEY, VoteAccount} from './vote-account'; -export {SYSVAR_RENT_PUBKEY} from './sysvar-rent'; +export {VOTE_PROGRAM_ID, VoteAccount} from './vote-account'; +export { + SYSVAR_CLOCK_PUBKEY, + SYSVAR_RENT_PUBKEY, + SYSVAR_REWARDS_PUBKEY, + SYSVAR_STAKE_HISTORY_PUBKEY, +} from './sysvar'; export { sendAndConfirmTransaction, sendAndConfirmRecentTransaction, } from './util/send-and-confirm-transaction'; -export { - sendAndConfirmRawTransaction, -} from './util/send-and-confirm-raw-transaction'; +export {sendAndConfirmRawTransaction} from './util/send-and-confirm-raw-transaction'; export {testnetChannelEndpoint} from './util/testnet'; // There are 1-billion lamports in one SOL diff --git a/web3.js/src/instruction.js b/web3.js/src/instruction.js new file mode 100644 index 0000000000..a507d8dd9c --- /dev/null +++ b/web3.js/src/instruction.js @@ -0,0 +1,27 @@ +// @flow + +import * as BufferLayout from 'buffer-layout'; + +import * as Layout from './layout'; + +/** + * @typedef {Object} InstructionType + * @property (index} The Instruction index (from solana upstream program) + * @property (BufferLayout} The BufferLayout to use to build data + */ +export type InstructionType = {| + index: number, + layout: typeof BufferLayout, +|}; + +/** + * Populate a buffer of instruction data using an InstructionType + */ +export function encodeData(type: InstructionType, fields: Object): Buffer { + const allocLength = + type.layout.span >= 0 ? type.layout.span : Layout.getAlloc(type, fields); + const data = Buffer.alloc(allocLength); + const layoutFields = Object.assign({instruction: type.index}, fields); + type.layout.encode(layoutFields, data); + return data; +} diff --git a/web3.js/src/layout.js b/web3.js/src/layout.js index 667b4ca7ca..82c317c90d 100644 --- a/web3.js/src/layout.js +++ b/web3.js/src/layout.js @@ -54,6 +54,26 @@ export const rustString = (property: string = 'string') => { return rsl; }; +/** + * Layout for an Authorized object + */ +export const authorized = (property: string = 'authorized') => { + return BufferLayout.struct( + [publicKey('staker'), publicKey('withdrawer')], + property, + ); +}; + +/** + * Layout for a Lockup object + */ +export const lockup = (property: string = 'lockup') => { + return BufferLayout.struct( + [BufferLayout.ns64('epoch'), publicKey('custodian')], + property, + ); +}; + export function getAlloc(type: Object, fields: Object): number { let alloc = 0; type.layout.fields.forEach(item => { diff --git a/web3.js/src/loader.js b/web3.js/src/loader.js index 552231effa..d1a3edd715 100644 --- a/web3.js/src/loader.js +++ b/web3.js/src/loader.js @@ -6,7 +6,7 @@ import {Account} from './account'; import {PublicKey} from './publickey'; import {NUM_TICKS_PER_SECOND} from './timing'; import {Transaction, PACKET_DATA_SIZE} from './transaction'; -import {SYSVAR_RENT_PUBKEY} from './sysvar-rent'; +import {SYSVAR_RENT_PUBKEY} from './sysvar'; import {sendAndConfirmTransaction} from './util/send-and-confirm-transaction'; import {sleep} from './util/sleep'; import type {Connection} from './connection'; diff --git a/web3.js/src/publickey.js b/web3.js/src/publickey.js index 3976661442..5dd073e0aa 100644 --- a/web3.js/src/publickey.js +++ b/web3.js/src/publickey.js @@ -80,8 +80,16 @@ export class PublicKey { /** * Derive a public key from another key, a seed, and a programId. */ - static createWithSeed(fromPublicKey: PublicKey, seed: string, programId: PublicKey): PublicKey { - const buffer = Buffer.concat([fromPublicKey.toBuffer(), Buffer.from(seed), programId.toBuffer()]) + static createWithSeed( + fromPublicKey: PublicKey, + seed: string, + programId: PublicKey, + ): PublicKey { + const buffer = Buffer.concat([ + fromPublicKey.toBuffer(), + Buffer.from(seed), + programId.toBuffer(), + ]); const hash = hasha(buffer, {algorithm: 'sha256'}); return new PublicKey('0x' + hash); } diff --git a/web3.js/src/stake-program.js b/web3.js/src/stake-program.js new file mode 100644 index 0000000000..d02c90ba35 --- /dev/null +++ b/web3.js/src/stake-program.js @@ -0,0 +1,395 @@ +// @flow + +import * as BufferLayout from 'buffer-layout'; +import hasha from 'hasha'; + +import {CONFIG_PROGRAM_ID} from './config-program'; +import {encodeData} from './instruction'; +import type {InstructionType} from './instruction'; +import * as Layout from './layout'; +import {PublicKey} from './publickey'; +import {SystemProgram} from './system-program'; +import { + SYSVAR_CLOCK_PUBKEY, + SYSVAR_RENT_PUBKEY, + SYSVAR_REWARDS_PUBKEY, + SYSVAR_STAKE_HISTORY_PUBKEY, +} from './sysvar'; +import {Transaction, TransactionInstruction} from './transaction'; +import type {TransactionInstructionCtorFields} from './transaction'; + +export class Authorized { + staker: PublicKey; + withdrawer: PublicKey; + + /** + * Create a new Authorized object + */ + constructor(staker: PublicKey, withdrawer: PublicKey) { + this.staker = staker; + this.withdrawer = withdrawer; + } +} + +export class Lockup { + epoch: number; + custodian: PublicKey; + + /** + * Create a new Authorized object + */ + constructor(epoch: number, custodian: PublicKey) { + this.epoch = epoch; + this.custodian = custodian; + } +} + +/** + * Stake Instruction class + */ +export class StakeInstruction extends TransactionInstruction { + /** + * Type of StakeInstruction + */ + type: InstructionType; +} + +/** + * An enumeration of valid StakeInstructionTypes + */ +const StakeInstructionLayout = Object.freeze({ + Initialize: { + index: 0, + layout: BufferLayout.struct([ + BufferLayout.u32('instruction'), + Layout.authorized(), + Layout.lockup(), + ]), + }, + Authorize: { + index: 1, + layout: BufferLayout.struct([ + BufferLayout.u32('instruction'), + Layout.publicKey('newAuthorized'), + BufferLayout.u32('stakeAuthorizationType'), + ]), + }, + DelegateStake: { + index: 2, + layout: BufferLayout.struct([BufferLayout.u32('instruction')]), + }, + RedeemVoteCredits: { + index: 3, + layout: BufferLayout.struct([BufferLayout.u32('instruction')]), + }, + Split: { + index: 4, + layout: BufferLayout.struct([ + BufferLayout.u32('instruction'), + BufferLayout.ns64('amount'), + ]), + }, + Withdraw: { + index: 5, + layout: BufferLayout.struct([ + BufferLayout.u32('instruction'), + BufferLayout.ns64('amount'), + ]), + }, + Deactivate: { + index: 6, + layout: BufferLayout.struct([BufferLayout.u32('instruction')]), + }, +}); + +/** + * @typedef {Object} StakeAuthorizationType + * @property (index} The Stake Authorization index (from solana-stake-program) + */ +export type StakeAuthorizationType = {| + index: number, +|}; + +/** + * An enumeration of valid StakeInstructionTypes + */ +export const StakeAuthorizationLayout = Object.freeze({ + Staker: { + index: 0, + }, + Withdrawer: { + index: 1, + }, +}); + +class RewardsPoolPublicKey extends PublicKey { + static get rewardsPoolBaseId(): PublicKey { + return new PublicKey('StakeRewards1111111111111111111111111111111'); + } + + /** + * Generate Derive a public key from another key, a seed, and a programId. + */ + static randomId(): PublicKey { + const randomInt = Math.floor(Math.random() * (256 - 1)); + let pubkey = this.rewardsPoolBaseId; + for (let i = 0; i < randomInt; i++) { + const buffer = pubkey.toBuffer(); + const hash = hasha(buffer, {algorithm: 'sha256'}); + return new PublicKey('0x' + hash); + } + return pubkey; + } +} + +/** + * Factory class for transactions to interact with the Stake program + */ +export class StakeProgram { + /** + * Public key that identifies the Stake program + */ + static get programId(): PublicKey { + return new PublicKey('Stake11111111111111111111111111111111111111'); + } + + /** + * Max space of a Stake account + */ + static get space(): number { + return 2000; + } + + /** + * Generate an Initialize instruction to add to a Stake Create transaction + */ + static initialize( + stakeAccount: PublicKey, + authorized: Authorized, + lockup: Lockup, + ): TransactionInstruction { + const type = StakeInstructionLayout.Initialize; + const data = encodeData(type, { + authorized, + lockup, + }); + const instructionData = { + keys: [ + {pubkey: stakeAccount, isSigner: false, isWritable: true}, + {pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false}, + ], + programId: this.programId, + data, + }; + return new TransactionInstruction(instructionData); + } + + /** + * Generate a Transaction that creates a new Stake account at + * an address generated with `from`, a seed, and the Stake programId + */ + static createAccountWithSeed( + from: PublicKey, + stakeAccount: PublicKey, + seed: string, + authorized: Authorized, + lockup: Lockup, + lamports: number, + ): Transaction { + let transaction = SystemProgram.createAccountWithSeed( + from, + stakeAccount, + seed, + lamports, + this.space, + this.programId, + ); + + return transaction.add(this.initialize(stakeAccount, authorized, lockup)); + } + + /** + * Generate a Transaction that creates a new Stake account + */ + static createAccount( + from: PublicKey, + stakeAccount: PublicKey, + authorized: Authorized, + lockup: Lockup, + lamports: number, + ): Transaction { + let transaction = SystemProgram.createAccount( + from, + stakeAccount, + lamports, + this.space, + this.programId, + ); + + return transaction.add(this.initialize(stakeAccount, authorized, lockup)); + } + + /** + * Generate a Transaction that delegates Stake tokens to a validator + * Vote PublicKey. This transaction can also be used to redelegate Stake + * to a new validator Vote PublicKey. + */ + static delegate( + stakeAccount: PublicKey, + authorizedPubkey: PublicKey, + votePubkey: PublicKey, + ): Transaction { + const type = StakeInstructionLayout.DelegateStake; + const data = encodeData(type); + + return new Transaction().add({ + keys: [ + {pubkey: stakeAccount, isSigner: false, isWritable: true}, + {pubkey: votePubkey, isSigner: false, isWritable: false}, + {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false}, + {pubkey: CONFIG_PROGRAM_ID, isSigner: false, isWritable: false}, + {pubkey: authorizedPubkey, isSigner: true, isWritable: false}, + ], + programId: this.programId, + data, + }); + } + + /** + * Generate a Transaction that authorizes a new PublicKey as Staker + * or Withdrawer on the Stake account. + */ + static authorize( + stakeAccount: PublicKey, + authorizedPubkey: PublicKey, + newAuthorized: PublicKey, + stakeAuthorizationType: StakeAuthorizationType, + ): Transaction { + const type = StakeInstructionLayout.Authorize; + const data = encodeData(type, { + newAuthorized, + stakeAuthorizationType: stakeAuthorizationType.index, + }); + + return new Transaction().add({ + keys: [ + {pubkey: stakeAccount, isSigner: false, isWritable: true}, + {pubkey: authorizedPubkey, isSigner: true, isWritable: false}, + ], + programId: this.programId, + data, + }); + } + + /** + * Generate a Transaction that authorizes a new PublicKey as Staker + * or Withdrawer on the Stake account. + */ + static redeemVoteCredits( + stakeAccount: PublicKey, + votePubkey: PublicKey, + ): Transaction { + const type = StakeInstructionLayout.RedeemVoteCredits; + const data = encodeData(type); + + return new Transaction().add({ + keys: [ + {pubkey: stakeAccount, isSigner: false, isWritable: true}, + {pubkey: votePubkey, isSigner: false, isWritable: true}, + { + pubkey: RewardsPoolPublicKey.randomId(), + isSigner: false, + isWritable: true, + }, + {pubkey: SYSVAR_REWARDS_PUBKEY, isSigner: false, isWritable: false}, + { + pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, + isSigner: false, + isWritable: false, + }, + ], + programId: this.programId, + data, + }); + } + + /** + * Generate a Transaction that splits Stake tokens into another stake account + */ + static split( + stakeAccount: PublicKey, + authorizedPubkey: PublicKey, + lamports: number, + splitStakePubkey: PublicKey, + ): Transaction { + let transaction = SystemProgram.createAccount( + stakeAccount, + splitStakePubkey, + 0, + this.space, + this.programId, + ); + const type = StakeInstructionLayout.Split; + const data = encodeData(type, {lamports}); + + return transaction.add({ + keys: [ + {pubkey: stakeAccount, isSigner: false, isWritable: true}, + {pubkey: splitStakePubkey, isSigner: false, isWritable: true}, + {pubkey: authorizedPubkey, isSigner: true, isWritable: false}, + ], + programId: this.programId, + data, + }); + } + + /** + * Generate a Transaction that withdraws deactivated Stake tokens. + */ + static withdraw( + stakeAccount: PublicKey, + withdrawerPubkey: PublicKey, + to: PublicKey, + lamports: number, + ): Transaction { + const type = StakeInstructionLayout.Withdraw; + const data = encodeData(type, {lamports}); + + return new Transaction().add({ + keys: [ + {pubkey: stakeAccount, isSigner: false, isWritable: true}, + {pubkey: to, isSigner: false, isWritable: true}, + {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false}, + { + pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, + isSigner: false, + isWritable: false, + }, + {pubkey: withdrawerPubkey, isSigner: true, isWritable: false}, + ], + programId: this.programId, + data, + }); + } + + /** + * Generate a Transaction that deactivates Stake tokens. + */ + static deactivate( + stakeAccount: PublicKey, + authorizedPubkey: PublicKey, + ): Transaction { + const type = StakeInstructionLayout.Deactivate; + const data = encodeData(type); + + return new Transaction().add({ + keys: [ + {pubkey: stakeAccount, isSigner: false, isWritable: true}, + {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false}, + {pubkey: authorizedPubkey, isSigner: true, isWritable: false}, + ], + programId: this.programId, + data, + }); + } +} diff --git a/web3.js/src/system-program.js b/web3.js/src/system-program.js index 03366f44ea..361c868b94 100644 --- a/web3.js/src/system-program.js +++ b/web3.js/src/system-program.js @@ -2,9 +2,11 @@ import * as BufferLayout from 'buffer-layout'; -import {Transaction, TransactionInstruction} from './transaction'; -import {PublicKey} from './publickey'; +import {encodeData} from './instruction'; +import type {InstructionType} from './instruction'; import * as Layout from './layout'; +import {PublicKey} from './publickey'; +import {Transaction, TransactionInstruction} from './transaction'; import type {TransactionInstructionCtorFields} from './transaction'; /** @@ -14,12 +16,9 @@ export class SystemInstruction extends TransactionInstruction { /** * Type of SystemInstruction */ - type: SystemInstructionType; + type: InstructionType; - constructor( - opts?: TransactionInstructionCtorFields, - type?: SystemInstructionType, - ) { + constructor(opts?: TransactionInstructionCtorFields, type?: InstructionType) { if ( opts && opts.programId && @@ -107,16 +106,6 @@ export class SystemInstruction extends TransactionInstruction { } } -/** - * @typedef {Object} SystemInstructionType - * @property (index} The System Instruction index (from solana-sdk) - * @property (BufferLayout} The BufferLayout to use to build data - */ -type SystemInstructionType = {| - index: number, - layout: typeof BufferLayout, -|}; - /** * An enumeration of valid SystemInstructionTypes */ @@ -157,18 +146,6 @@ const SystemInstructionLayout = Object.freeze({ }, }); -/** - * Populate a buffer of instruction data using the SystemInstructionType - */ -function encodeData(type: SystemInstructionType, fields: Object): Buffer { - const allocLength = - type.layout.span >= 0 ? type.layout.span : Layout.getAlloc(type, fields); - const data = Buffer.alloc(allocLength); - const layoutFields = Object.assign({instruction: type.index}, fields); - type.layout.encode(layoutFields, data); - return data; -} - /** * Factory class for transactions to interact with the System program */ diff --git a/web3.js/src/sysvar-rent.js b/web3.js/src/sysvar-rent.js deleted file mode 100644 index 3b9abbe64b..0000000000 --- a/web3.js/src/sysvar-rent.js +++ /dev/null @@ -1,6 +0,0 @@ -// @flow -import {PublicKey} from './publickey'; - -export const SYSVAR_RENT_PUBKEY = new PublicKey( - 'SysvarRent111111111111111111111111111111111', -); diff --git a/web3.js/src/sysvar.js b/web3.js/src/sysvar.js new file mode 100644 index 0000000000..47f445a42c --- /dev/null +++ b/web3.js/src/sysvar.js @@ -0,0 +1,18 @@ +// @flow +import {PublicKey} from './publickey'; + +export const SYSVAR_CLOCK_PUBKEY = new PublicKey( + 'SysvarC1ock11111111111111111111111111111111', +); + +export const SYSVAR_RENT_PUBKEY = new PublicKey( + 'SysvarRent111111111111111111111111111111111', +); + +export const SYSVAR_REWARDS_PUBKEY = new PublicKey( + 'SysvarRewards111111111111111111111111111111', +); + +export const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey( + 'SysvarStakeHistory1111111111111111111111111', +); diff --git a/web3.js/src/vote-account.js b/web3.js/src/vote-account.js index fbedb511e9..b75415bf92 100644 --- a/web3.js/src/vote-account.js +++ b/web3.js/src/vote-account.js @@ -4,7 +4,7 @@ import * as BufferLayout from 'buffer-layout'; import * as Layout from './layout'; import {PublicKey} from './publickey'; -export const VOTE_ACCOUNT_KEY = new PublicKey( +export const VOTE_PROGRAM_ID = new PublicKey( 'Vote111111111111111111111111111111111111111', ); diff --git a/web3.js/test/publickey.test.js b/web3.js/test/publickey.test.js index 4cdc38ef30..c58a5923f7 100644 --- a/web3.js/test/publickey.test.js +++ b/web3.js/test/publickey.test.js @@ -259,7 +259,15 @@ test('createWithSeed', () => { 0, 0, ]); - const derivedKey = PublicKey.createWithSeed(defaultPublicKey, 'limber chicken: 4/45', defaultPublicKey); + const derivedKey = PublicKey.createWithSeed( + defaultPublicKey, + 'limber chicken: 4/45', + defaultPublicKey, + ); - expect(derivedKey.equals(new PublicKey('9h1HyLCW5dZnBVap8C5egQ9Z6pHyjsh5MNy83iPqqRuq'))).toBe(true); + expect( + derivedKey.equals( + new PublicKey('9h1HyLCW5dZnBVap8C5egQ9Z6pHyjsh5MNy83iPqqRuq'), + ), + ).toBe(true); });