588 lines
21 KiB
JavaScript
588 lines
21 KiB
JavaScript
/**
|
|
*
|
|
* Pricecaster Service Utility Library.
|
|
*
|
|
* Copyright 2022 Wormhole Project Contributors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*/
|
|
|
|
const algosdk = require('algosdk')
|
|
const fs = require('fs')
|
|
// eslint-disable-next-line camelcase
|
|
const tools = require('../tools/app-tools')
|
|
const crypto = require('crypto')
|
|
|
|
const ContractInfo = {
|
|
pricekeeper: {
|
|
approvalProgramFile: 'teal/wormhole/build/pricekeeper-v2-approval.teal',
|
|
clearStateProgramFile: 'teal/wormhole/build/pricekeeper-v2-clear.teal',
|
|
compiledApproval: {
|
|
bytes: undefined,
|
|
hash: undefined
|
|
},
|
|
compiledClearState: {
|
|
bytes: undefined,
|
|
hash: undefined
|
|
},
|
|
appId: 0
|
|
},
|
|
vaaProcessor: {
|
|
approvalProgramFile: 'teal/wormhole/build/vaa-processor-approval.teal',
|
|
clearStateProgramFile: 'teal/wormhole/build/vaa-processor-clear.teal',
|
|
approvalProgramHash: '',
|
|
compiledApproval: {
|
|
bytes: undefined,
|
|
hash: undefined
|
|
},
|
|
compiledClearState: {
|
|
bytes: undefined,
|
|
hash: undefined
|
|
},
|
|
appId: 0
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
|
|
class PricecasterLib {
|
|
constructor(algodClient, ownerAddr = undefined) {
|
|
this.algodClient = algodClient
|
|
this.ownerAddr = ownerAddr
|
|
this.minFee = 1000
|
|
this.groupTxSet = {}
|
|
this.lsigs = {}
|
|
this.dumpFailedTx = false
|
|
this.dumpFailedTxDirectory = './'
|
|
|
|
/** Set the file dumping feature on failed group transactions
|
|
* @param {boolean} f Set to true to enable function, false to disable.
|
|
*/
|
|
this.enableDumpFailedTx = function (f) {
|
|
this.dumpFailedTx = f
|
|
}
|
|
|
|
/** Set the file dumping feature output directory
|
|
* @param {string} dir The output directory.
|
|
*/
|
|
this.setDumpFailedTxDirectory = function (dir) {
|
|
this.dumpFailedTxDirectory = dir
|
|
}
|
|
|
|
/** Sets a contract approval program filename
|
|
* @param {string} filename New file name to use.
|
|
*/
|
|
this.setApprovalProgramFile = function (contract, filename) {
|
|
ContractInfo[contract].approvalProgramFile = filename
|
|
}
|
|
|
|
/** Sets a contract clear state program filename
|
|
* @param {string} filename New file name to use.
|
|
*/
|
|
this.setClearStateProgramFile = function (contract, filename) {
|
|
ContractInfo[contract].clearStateProgramFile = filename
|
|
}
|
|
|
|
/**
|
|
* Set Application Id for a contract.
|
|
* @param {number} applicationId application id
|
|
* @returns {void}
|
|
*/
|
|
this.setAppId = function (contract, applicationId) {
|
|
ContractInfo[contract].appId = applicationId
|
|
}
|
|
|
|
/**
|
|
* Get the Application id for a specific contract
|
|
* @returns The requested application Id
|
|
*/
|
|
this.getAppId = function (contract) {
|
|
return ContractInfo[contract].appId
|
|
}
|
|
|
|
/**
|
|
* Get minimum fee to pay for transactions.
|
|
* @return {Number} minimum transaction fee
|
|
*/
|
|
this.minTransactionFee = function () {
|
|
return this.minFee
|
|
}
|
|
|
|
/**
|
|
* Internal function.
|
|
* Read application local state related to the account.
|
|
* @param {String} accountAddr account to retrieve local state
|
|
* @return {Array} an array containing all the {key: value} pairs of the local state
|
|
*/
|
|
this.readLocalState = function (accountAddr) {
|
|
return tools.readAppLocalState(this.algodClient, this.appId, accountAddr)
|
|
}
|
|
|
|
/**
|
|
* Internal function.
|
|
* Read application global state.
|
|
* @return {Array} an array containing all the {key: value} pairs of the global state
|
|
* @returns {void}
|
|
*/
|
|
this.readGlobalState = function () {
|
|
return tools.readAppGlobalState(this.algodClient, this.appId, this.ownerAddr)
|
|
}
|
|
|
|
/**
|
|
* Print local state of accountAddr on stdout.
|
|
* @param {String} accountAddr account to retrieve local state
|
|
* @returns {void}
|
|
*/
|
|
this.printLocalState = async function (accountAddr) {
|
|
await tools.printAppLocalState(this.algodClient, this.appId, accountAddr)
|
|
}
|
|
|
|
/**
|
|
* Print application global state on stdout.
|
|
* @returns {void}
|
|
*/
|
|
this.printGlobalState = async function () {
|
|
await tools.printAppGlobalState(this.algodClient, this.appId, this.ownerAddr)
|
|
}
|
|
|
|
/**
|
|
* Internal function.
|
|
* Read application local state variable related to accountAddr.
|
|
* @param {String} accountAddr account to retrieve local state
|
|
* @param {String} key variable key to get the value associated
|
|
* @return {String/Number} it returns the value associated to the key that could be an address, a number or a
|
|
* base64 string containing a ByteArray
|
|
*/
|
|
this.readLocalStateByKey = function (accountAddr, key) {
|
|
return tools.readAppLocalStateByKey(this.algodClient, this.appId, accountAddr, key)
|
|
}
|
|
|
|
/**
|
|
* Internal function.
|
|
* Read application global state variable.
|
|
* @param {String} key variable key to get the value associated
|
|
* @return {String/Number} it returns the value associated to the key that could be an address,
|
|
* a number or a base64 string containing a ByteArray
|
|
*/
|
|
this.readGlobalStateByKey = function (key) {
|
|
return tools.readAppGlobalStateByKey(this.algodClient, this.appId, this.ownerAddr, key)
|
|
}
|
|
|
|
/**
|
|
* Compile program that programFilename contains.
|
|
* @param {String} programFilename filepath to the program to compile
|
|
* @return {String} base64 string containing the compiled program
|
|
*/
|
|
this.compileProgram = async function (programBytes) {
|
|
const compileResponse = await this.algodClient.compile(programBytes).do()
|
|
const compiledBytes = new Uint8Array(Buffer.from(compileResponse.result, 'base64'))
|
|
return { bytes: compiledBytes, hash: compileResponse.hash }
|
|
}
|
|
|
|
/**
|
|
* Compile clear state program.
|
|
*/
|
|
this.compileClearProgram = async function (contract) {
|
|
const program = fs.readFileSync(ContractInfo[contract].clearStateProgramFile, 'utf8')
|
|
ContractInfo[contract].compiledClearState = await this.compileProgram(program)
|
|
}
|
|
|
|
/**
|
|
* Compile approval program.
|
|
*/
|
|
this.compileApprovalProgram = async function (contract) {
|
|
const program = fs.readFileSync(ContractInfo[contract].approvalProgramFile, 'utf8')
|
|
ContractInfo[contract].compiledApproval = await this.compileProgram(program)
|
|
}
|
|
|
|
/**
|
|
* Helper function to retrieve the application id from a createApp transaction response.
|
|
* @param {Object} txResponse object containig the transactionResponse of the createApp call
|
|
* @return {Number} application id of the created application
|
|
*/
|
|
this.appIdFromCreateAppResponse = function (txResponse) {
|
|
return txResponse['application-index']
|
|
}
|
|
|
|
/**
|
|
* Create an application based on the default approval and clearState programs or based on the specified files.
|
|
* @param {String} sender account used to sign the createApp transaction
|
|
* @param {Function} signCallback callback with prototype signCallback(sender, tx) used to sign transactions
|
|
* @return {String} transaction id of the created application
|
|
*/
|
|
this.createApp = async function (sender, contract, localInts, localBytes, globalInts, globalBytes, appArgs, signCallback) {
|
|
const onComplete = algosdk.OnApplicationComplete.NoOpOC
|
|
|
|
// get node suggested parameters
|
|
const params = await algodClient.getTransactionParams().do()
|
|
params.fee = this.minFee
|
|
params.flatFee = true
|
|
|
|
await this.compileApprovalProgram(contract)
|
|
await this.compileClearProgram(contract)
|
|
|
|
// create unsigned transaction
|
|
const txApp = algosdk.makeApplicationCreateTxn(
|
|
sender, params, onComplete,
|
|
ContractInfo[contract].compiledApproval.bytes,
|
|
ContractInfo[contract].compiledClearState.bytes,
|
|
localInts, localBytes, globalInts, globalBytes, appArgs
|
|
)
|
|
const txId = txApp.txID().toString()
|
|
|
|
// Sign the transaction
|
|
const txAppSigned = signCallback(sender, txApp)
|
|
|
|
// Submit the transaction
|
|
await algodClient.sendRawTransaction(txAppSigned).do()
|
|
return txId
|
|
}
|
|
|
|
/**
|
|
* Create the VAA Processor application based on the default approval and clearState programs or based on the specified files.
|
|
* @param {String} sender account used to sign the createApp transaction
|
|
* @param {String} gexpTime Guardian key set expiration time
|
|
* @param {String} gsindex Index of the guardian key set
|
|
* @param {String} gkeys Guardian keys listed as a single array
|
|
* @param {Function} signCallback callback with prototype signCallback(sender, tx) used to sign transactions
|
|
* @return {String} transaction id of the created application
|
|
*/
|
|
this.createVaaProcessorApp = async function (sender, gexpTime, gsindex, gkeys, signCallback) {
|
|
return await this.createApp(sender, 'vaaProcessor', 0, 0, 5, 20,
|
|
[new Uint8Array(Buffer.from(gkeys, 'hex')),
|
|
algosdk.encodeUint64(parseInt(gexpTime)),
|
|
algosdk.encodeUint64(parseInt(gsindex))], signCallback)
|
|
}
|
|
|
|
/**
|
|
* Create the Pricekeeper application based on the default approval and clearState programs or based on the specified files.
|
|
* @param {String} sender account used to sign the createApp transaction
|
|
* @param {String} vaaProcessorAppId The application id of the VAA Processor program associated.
|
|
* @param {Function} signCallback callback with prototype signCallback(sender, tx) used to sign transactions
|
|
* @return {String} transaction id of the created application
|
|
*/
|
|
this.createPricekeeperApp = async function (sender, vaaProcessorAppId, signCallback) {
|
|
return await this.createApp(sender, 'pricekeeper', 0, 0, 1, 63,
|
|
[algosdk.encodeUint64(parseInt(vaaProcessorAppId))], signCallback)
|
|
}
|
|
|
|
/**
|
|
* Internal function.
|
|
* Call application specifying args and accounts.
|
|
* @param {String} sender caller address
|
|
* @param {Array} appArgs array of arguments to pass to application call
|
|
* @param {Array} appAccounts array of accounts to pass to application call
|
|
* @param {Function} signCallback callback with prototype signCallback(sender, tx) used to sign transactions
|
|
* @return {String} transaction id of the transaction
|
|
*/
|
|
this.callApp = async function (sender, contract, appArgs, appAccounts, signCallback) {
|
|
// get node suggested parameters
|
|
const params = await this.algodClient.getTransactionParams().do()
|
|
|
|
params.fee = this.minFee
|
|
params.flatFee = true
|
|
|
|
// create unsigned transaction
|
|
const txApp = algosdk.makeApplicationNoOpTxn(sender, params, ContractInfo[contract].appId, appArgs, appAccounts.length === 0 ? undefined : appAccounts)
|
|
const txId = txApp.txID().toString()
|
|
|
|
// Sign the transaction
|
|
const txAppSigned = signCallback(sender, txApp)
|
|
|
|
// Submit the transaction
|
|
await this.algodClient.sendRawTransaction(txAppSigned).do()
|
|
|
|
return txId
|
|
}
|
|
|
|
/**
|
|
* ClearState sender. Remove all the sender associated local data.
|
|
* @param {String} sender account to ClearState
|
|
* @param {Function} signCallback callback with prototype signCallback(sender, tx) used to sign transactions
|
|
* @return {[String]} transaction id of one of the transactions of the group
|
|
*/
|
|
this.clearApp = async function (sender, signCallback, forcedAppId) {
|
|
// get node suggested parameters
|
|
const params = await this.algodClient.getTransactionParams().do()
|
|
|
|
params.fee = this.minFee
|
|
params.flatFee = true
|
|
|
|
let appId = this.appId
|
|
if (forcedAppId) {
|
|
appId = forcedAppId
|
|
}
|
|
|
|
// create unsigned transaction
|
|
const txApp = algosdk.makeApplicationClearStateTxn(sender, params, appId)
|
|
const txId = txApp.txID().toString()
|
|
|
|
// Sign the transaction
|
|
const txAppSigned = signCallback(sender, txApp)
|
|
|
|
// Submit the transaction
|
|
await this.algodClient.sendRawTransaction(txAppSigned).do()
|
|
|
|
return txId
|
|
}
|
|
|
|
/**
|
|
* Permanent delete the application.
|
|
* @param {String} sender owner account
|
|
* @param {Function} signCallback callback with prototype signCallback(sender, tx) used to sign transactions
|
|
* @param {Function} applicationId use this application id instead of the one set
|
|
* @return {String} transaction id of one of the transactions of the group
|
|
*/
|
|
this.deleteApp = async function (sender, signCallback, applicationId) {
|
|
// get node suggested parameters
|
|
const params = await this.algodClient.getTransactionParams().do()
|
|
|
|
params.fee = this.minFee
|
|
params.flatFee = true
|
|
|
|
if (!applicationId) {
|
|
applicationId = this.appId
|
|
}
|
|
|
|
// create unsigned transaction
|
|
const txApp = algosdk.makeApplicationDeleteTxn(sender, params, applicationId)
|
|
const txId = txApp.txID().toString()
|
|
|
|
// Sign the transaction
|
|
const txAppSigned = signCallback(sender, txApp)
|
|
|
|
// Submit the transaction
|
|
await this.algodClient.sendRawTransaction(txAppSigned).do()
|
|
|
|
return txId
|
|
}
|
|
|
|
/**
|
|
* Helper function to wait until transaction txId is included in a block/round.
|
|
* @param {String} txId transaction id to wait for
|
|
* @return {VOID} VOID
|
|
*/
|
|
this.waitForConfirmation = async function (txId) {
|
|
const status = (await this.algodClient.status().do())
|
|
let lastRound = status['last-round']
|
|
// eslint-disable-next-line no-constant-condition
|
|
while (true) {
|
|
const pendingInfo = await this.algodClient.pendingTransactionInformation(txId).do()
|
|
if (pendingInfo['confirmed-round'] !== null && pendingInfo['confirmed-round'] > 0) {
|
|
// Got the completed Transaction
|
|
|
|
return pendingInfo['confirmed-round']
|
|
}
|
|
lastRound += 1
|
|
await this.algodClient.statusAfterBlock(lastRound).do()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function to wait until transaction txId is included in a block/round
|
|
* and returns the transaction response associated to the transaction.
|
|
* @param {String} txId transaction id to get transaction response
|
|
* @return {Object} returns an object containing response information
|
|
*/
|
|
this.waitForTransactionResponse = async function (txId) {
|
|
// Wait for confirmation
|
|
await this.waitForConfirmation(txId)
|
|
|
|
// display results
|
|
return this.algodClient.pendingTransactionInformation(txId).do()
|
|
}
|
|
|
|
/**
|
|
* VAA Processor: Sets the stateless logic program hash
|
|
* @param {*} sender Sender account
|
|
* @param {*} hash The stateless logic program hash
|
|
* @returns Transaction identifier.
|
|
*/
|
|
this.setVAAVerifyProgramHash = async function (sender, hash, signCallback) {
|
|
if (!algosdk.isValidAddress(sender)) {
|
|
throw new Error('Invalid sender address: ' + sender)
|
|
}
|
|
const appArgs = []
|
|
appArgs.push(new Uint8Array(Buffer.from('setvphash')),
|
|
algosdk.decodeAddress(hash).publicKey)
|
|
return await this.callApp(sender, 'vaaProcessor', appArgs, [], signCallback)
|
|
}
|
|
|
|
/**
|
|
* VAA Processor: Sets the authorized application id for last call
|
|
* @param {*} sender Sender account
|
|
* @param {*} appId The assigned appId
|
|
* @returns Transaction identifier.
|
|
*/
|
|
this.setAuthorizedAppId = async function (sender, appId, signCallback) {
|
|
if (!algosdk.isValidAddress(sender)) {
|
|
throw new Error('Invalid sender address: ' + sender)
|
|
}
|
|
const appArgs = []
|
|
appArgs.push(new Uint8Array(Buffer.from('setauthid')),
|
|
algosdk.encodeUint64(appId))
|
|
return await this.callApp(sender, 'vaaProcessor', appArgs, [], signCallback)
|
|
}
|
|
|
|
/**
|
|
* Starts a begin...commit section for commiting grouped transactions.
|
|
*/
|
|
this.beginTxGroup = function () {
|
|
const gid = crypto.randomBytes(16).toString('hex')
|
|
this.groupTxSet[gid] = []
|
|
return gid
|
|
}
|
|
|
|
/**
|
|
* Adds a transaction to the group.
|
|
* @param {} tx Transaction to add.
|
|
*/
|
|
this.addTxToGroup = function (gid, tx) {
|
|
if (this.groupTxSet[gid] === undefined) {
|
|
throw new Error('unknown tx group id')
|
|
}
|
|
this.groupTxSet[gid].push(tx)
|
|
}
|
|
|
|
/**
|
|
* @param {*} sender The sender account.
|
|
* @param {function} signCallback The sign callback routine.
|
|
* @returns Transaction id.
|
|
*/
|
|
this.commitTxGroup = async function (gid, sender, signCallback) {
|
|
if (this.groupTxSet[gid] === undefined) {
|
|
throw new Error('unknown tx group id')
|
|
}
|
|
algosdk.assignGroupID(this.groupTxSet[gid])
|
|
|
|
// Sign the transactions
|
|
const signedTxns = []
|
|
for (const tx of this.groupTxSet[gid]) {
|
|
signedTxns.push(signCallback(sender, tx))
|
|
}
|
|
|
|
// Submit the transaction
|
|
const tx = await this.algodClient.sendRawTransaction(signedTxns).do()
|
|
delete this.groupTxSet[gid]
|
|
return tx.txId
|
|
}
|
|
|
|
/**
|
|
* @param {*} sender The sender account.
|
|
* @param {*} programBytes Compiled program bytes.
|
|
* @param {*} totalSignatureCount Total signatures present in the VAA.
|
|
* @param {*} sigSubsets An hex string with the signature subsets i..j for logicsig arguments.
|
|
* @param {*} lastTxSender The sender of the last TX in the group.
|
|
* @param {*} signCallback The signing callback function to use in the last TX of the group.
|
|
* @returns Transaction id.
|
|
*/
|
|
this.commitVerifyTxGroup = async function (gid, programBytes, totalSignatureCount, sigSubsets, lastTxSender, signCallback) {
|
|
if (this.groupTxSet[gid] === undefined) {
|
|
throw new Error('unknown group id')
|
|
}
|
|
algosdk.assignGroupID(this.groupTxSet[gid])
|
|
const signedGroup = []
|
|
let i = 0
|
|
for (const tx of this.groupTxSet[gid]) {
|
|
// All transactions except last must be signed by stateless code.
|
|
|
|
// console.log(`sigSubsets[${i}]: ${sigSubsets[i])
|
|
|
|
if (i === this.groupTxSet[gid].length - 1) {
|
|
signedGroup.push(signCallback(lastTxSender, tx))
|
|
} else {
|
|
const lsig = new algosdk.LogicSigAccount(programBytes, [Buffer.from(sigSubsets[i], 'hex'), algosdk.encodeUint64(totalSignatureCount)])
|
|
const stxn = algosdk.signLogicSigTransaction(tx, lsig)
|
|
signedGroup.push(stxn.blob)
|
|
}
|
|
i++
|
|
}
|
|
|
|
// Submit the transaction
|
|
let tx
|
|
try {
|
|
tx = await this.algodClient.sendRawTransaction(signedGroup).do()
|
|
} catch (e) {
|
|
if (this.dumpFailedTx) {
|
|
const id = tx ? tx.txId : Date.now().toString()
|
|
const filename = `${this.dumpFailedTxDirectory}/failed-${id}.stxn`
|
|
if (fs.existsSync(filename)) {
|
|
fs.unlinkSync(filename)
|
|
}
|
|
for (let i = 0; i < signedGroup.length; ++i) {
|
|
fs.appendFileSync(filename, signedGroup[i])
|
|
}
|
|
}
|
|
throw e
|
|
}
|
|
delete this.groupTxSet[gid]
|
|
return tx.txId
|
|
}
|
|
|
|
/**
|
|
* VAA Processor: Add a verification step to a transaction group.
|
|
* @param {*} sender The sender account (typically the VAA verification stateless program)
|
|
* @param {*} payload The VAA payload.
|
|
* @param {*} gksubset An hex string containing the keys for the guardian subset in this step.
|
|
* @param {*} totalguardians The total number of known guardians.
|
|
*/
|
|
this.addVerifyTx = function (gid, sender, params, payload, gksubset, totalguardians) {
|
|
if (this.groupTxSet[gid] === undefined) {
|
|
throw new Error('unknown group id')
|
|
}
|
|
const appArgs = []
|
|
appArgs.push(new Uint8Array(Buffer.from('verify')),
|
|
new Uint8Array(Buffer.from(gksubset.join(''), 'hex')),
|
|
algosdk.encodeUint64(parseInt(totalguardians)))
|
|
|
|
const tx = algosdk.makeApplicationNoOpTxn(sender,
|
|
params,
|
|
ContractInfo.vaaProcessor.appId,
|
|
appArgs, undefined, undefined, undefined,
|
|
new Uint8Array(payload))
|
|
this.groupTxSet[gid].push(tx)
|
|
|
|
return tx.txID()
|
|
}
|
|
|
|
/**
|
|
* Pricekeeper-V2: Add store price transaction to TX Group.
|
|
* @param {*} sender The sender account (typically the VAA verification stateless program)
|
|
* @param {*} sym The symbol identifying the product to store price for.
|
|
* @param {*} payload The VAA payload.
|
|
*/
|
|
this.addPriceStoreTx = function (gid, sender, params, sym, payload) {
|
|
if (this.groupTxSet[gid] === undefined) {
|
|
throw new Error('unknown group id')
|
|
}
|
|
const appArgs = []
|
|
appArgs.push(new Uint8Array(Buffer.from('store')),
|
|
new Uint8Array(Buffer.from(sym)),
|
|
new Uint8Array(payload))
|
|
|
|
const tx = algosdk.makeApplicationNoOpTxn(sender,
|
|
params,
|
|
ContractInfo.pricekeeper.appId,
|
|
appArgs)
|
|
this.groupTxSet[gid].push(tx)
|
|
|
|
return tx.txID()
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
PricecasterLib
|
|
}
|