From 64d05a3903c8674a4b85ff4177908688b432db72 Mon Sep 17 00:00:00 2001 From: dafuga Date: Wed, 30 Aug 2023 15:36:43 -0700 Subject: [PATCH 01/10] refactor: using the contract kit for action generation --- package.json | 6 +- src/account.ts | 148 +++ src/accounts.ts | 203 --- src/accounts/actions/permissions.ts | 46 - src/accounts/actions/resources.ts | 191 --- src/contracts/eosio.ts | 1539 ++++++++++++++++++++++ src/index.ts | 16 +- src/kit.ts | 42 + src/{permissions.ts => permission.ts} | 16 +- src/tmp/contract.ts | 107 -- test/{accounts.ts => account.ts} | 6 +- test/data/account_data/teamgreymass.json | 259 ++++ test/permissions.ts | 2 +- yarn.lock | 39 + 14 files changed, 2052 insertions(+), 568 deletions(-) create mode 100644 src/account.ts delete mode 100644 src/accounts.ts delete mode 100644 src/accounts/actions/permissions.ts delete mode 100644 src/accounts/actions/resources.ts create mode 100644 src/contracts/eosio.ts create mode 100644 src/kit.ts rename src/{permissions.ts => permission.ts} (96%) delete mode 100644 src/tmp/contract.ts rename test/{accounts.ts => account.ts} (97%) create mode 100644 test/data/account_data/teamgreymass.json diff --git a/package.json b/package.json index 03f4332..c3f74eb 100644 --- a/package.json +++ b/package.json @@ -16,11 +16,15 @@ "prepare": "make" }, "dependencies": { - "@greymass/eosio": "^0.6.4", + "@wharfkit/antelope": "^0.7.3", "@wharfkit/session": "^0.2.0", + "@wharfkit/contract": "0.4.2", "git": "^0.1.5", "tslib": "^2.1.0" }, + "resolutions": { + "@wharfkit/antelope": "^0.7.3" + }, "devDependencies": { "@rollup/plugin-alias": "^4.0.2", "@rollup/plugin-commonjs": "^23.0.2", diff --git a/src/account.ts b/src/account.ts new file mode 100644 index 0000000..c61e578 --- /dev/null +++ b/src/account.ts @@ -0,0 +1,148 @@ +import { + Action, + API, + APIClient, + Asset, + AssetType, + Checksum256, + Checksum256Type, + Name, + NameType, +} from '@wharfkit/antelope' + +import {Permission} from './permission' +import {Eosio} from './contracts/eosio' + +export interface AccountArgs { + accountData: API.v1.AccountObject + client: APIClient +} + +export interface Resources { + cpu_available: number + cpu_used: number + net_available: number + net_used: number + ram_quota: number + ram_usage: number +} + +export class Account { + readonly account_data: API.v1.AccountObject + readonly eosioContract: Eosio.Contract + readonly client: APIClient + + constructor({ accountData, client }: AccountArgs) { + this.account_data = accountData + this.eosioContract = new Eosio.Contract({ client }) + this.client = client + } + + get accountName(): NameType { + return String(this.account_data.account_name) + } + + getPermission(permissionName: NameType): Permission { + return Permission.from({permissionName, accountData: this.account_data}) + } + + updatePermission(permission: Permission): Action { + return this.eosioContract.action('updateauth', permission.actionData) + } + + removePermission(permissionName: NameType): Action { + return this.eosioContract.action('deleteauth', { + account: "............1", + authorized_by: "............1", + permission: permissionName, + }) + } + + buyRam(amount: AssetType): Action { + return this.eosioContract.action('buyram', { + payer: "............1", + receiver: "............1", + quant: amount, + }) + } + + buyRamBytes(bytes: number): Action { + return this.eosioContract.action('buyrambytes', { + payer: "............1", + receiver: "............1", + bytes, + }) + } + + sellRam(bytes: number): Action { + return this.eosioContract.action('sellram', { + account: "............1", + bytes, + }) + } + + delegateResources(cpu: AssetType, net: AssetType): Action { + return this.eosioContract.action( + 'delegatebw', + { + from: "............1", + receiver: "............1", + stake_cpu_quantity: cpu, + stake_net_quantity: net, + transfer: false, + } + ) + } + + undelegateResources(cpu: AssetType, net: AssetType): Action { + return this.eosioContract.action( + 'undelegatebw', + { + from: "............1", + receiver: "............1", + unstake_cpu_quantity: cpu, + unstake_net_quantity: net, + } + ) + } + + getResources(): Resources { + return { + net_available: Number(this.account_data.net_limit.available), + net_used: Number(this.account_data.net_limit.available), + cpu_available: Number(this.account_data.cpu_limit.available), + cpu_used: Number(this.account_data.cpu_limit.used), + ram_quota: Number(this.account_data.ram_quota), + ram_usage: Number(this.account_data.ram_usage), + } + } + + getBalance(contract: NameType = 'eosio.token', symbol?: Asset.SymbolType): Promise { + return new Promise((resolve, reject) => { + this.client.v1.chain + .get_currency_balance(contract, String(this.accountName), symbol && String(symbol)) + .then((balances) => { + const balance = (balances as any)[0] + + if (!balance) { + reject( + new Error( + `No balance found for ${symbol} token of ${contract} contract.` + ) + ) + } + + resolve(balance) + }) + .catch((err) => { + if ( + err.message.includes('No data') || + err.message.includes('Account Query Exception') + ) { + reject(new Error(`Token contract ${contract} does not exist.`)) + } + reject(err) + }) + }) + } +} diff --git a/src/accounts.ts b/src/accounts.ts deleted file mode 100644 index 0fd056d..0000000 --- a/src/accounts.ts +++ /dev/null @@ -1,203 +0,0 @@ -import { - API, - APIClient, - Asset, - AssetType, - Checksum256, - Checksum256Type, - Name, - NameType, -} from '@greymass/eosio' - -import {PermissionActions} from './accounts/actions/permissions' -import {Permission} from './permissions' -import {ResourceActions} from './accounts/actions/resources' - -import type {Session, TransactResult} from '@wharfkit/session' - -export interface Resources { - cpu_available: number - cpu_used: number - net_available: number - net_used: number - ram_quota: number - ram_usage: number -} - -export class Account { - account_name: Name - chain_id: Checksum256 - api_client: APIClient - account_data: API.v1.AccountObject | undefined - account_data_timestamp: number | undefined - // contract: Contract | undefined - cache_duration: number = 1000 * 60 * 5 // 5 minutes - - constructor(accountName: Name, chainId: Checksum256Type, apiClient: APIClient) { - this.account_name = accountName - this.chain_id = Checksum256.from(chainId) - this.api_client = apiClient - // this.contract = new Contract(chainId, this, options?.session) - } - - static from(accountName: NameType, chain: Checksum256Type, apiClient: APIClient): Account { - return new Account(Name.from(accountName), Checksum256.from(chain), apiClient) - } - - get accountName(): Name { - return this.account_name - } - - get chainId(): Checksum256 { - return this.chain_id - } - - async getPermission(permissionName: NameType): Promise { - const accountData = await this.getAccountData() - - return Permission.from({permissionName, accountData}) - } - - updatePermission( - permission: Permission, - {session}: {session: Session} - ): Promise { - return PermissionActions.shared().updateAuth(permission.actionData, { - account: this, - session, - }) - } - - removePermission( - permissionName: NameType, - {session}: {session: Session} - ): Promise { - return PermissionActions.shared().deleteAuth( - Name.from(permissionName), - Name.from(this.account_name), - {account: this, session} - ) - } - - buyRam(amount: AssetType, {session}: {session: Session}): Promise { - return ResourceActions.shared().buyRam(this.accountName, this.accountName, amount, { - account: this, - session, - }) - } - - buyRamBytes(bytes: number, {session}: {session: Session}): Promise { - return ResourceActions.shared().buyRamBytes(this.accountName, this.accountName, bytes, { - account: this, - session, - }) - } - - sellRam(bytes: number, {session}: {session: Session}): Promise { - return ResourceActions.shared().sellRam(this.accountName, bytes, {account: this, session}) - } - - delegateResources( - cpu: AssetType, - net: AssetType, - transfer: boolean, - {session}: {session: Session} - ): Promise { - return ResourceActions.shared().delegateResources( - this.accountName, - this.accountName, - net, - cpu, - transfer, - {account: this, session} - ) - } - - undelegateResources( - cpu: AssetType, - net: AssetType, - {session}: {session: Session} - ): Promise { - return ResourceActions.shared().undelegateResources( - this.accountName, - this.accountName, - cpu, - net, - {account: this, session} - ) - } - - async getResources(): Promise { - return new Promise((resolve, reject) => { - this.getAccountData() - .then((accountData) => { - resolve({ - net_available: Number(accountData.net_limit.available), - net_used: Number(accountData.net_limit.available), - cpu_available: Number(accountData.cpu_limit.available), - cpu_used: Number(accountData.cpu_limit.used), - ram_quota: Number(accountData.ram_quota), - ram_usage: Number(accountData.ram_usage), - }) - }) - .catch((err) => { - reject(err) - }) - }) - } - - getBalance(contract: NameType = 'eosio.token', symbol?: Asset.SymbolType): Promise { - return new Promise((resolve, reject) => { - this.api_client.v1.chain - .get_currency_balance(contract, String(this.accountName), symbol && String(symbol)) - .then((balances) => { - const balance = (balances as any)[0] - - if (!balance) { - reject( - new Error( - `No balance found for ${symbol} token of ${contract} contract.` - ) - ) - } - - resolve(balance) - }) - .catch((err) => { - if ( - err.message.includes('No data') || - err.message.includes('Account Query Exception') - ) { - reject(new Error(`Token contract ${contract} does not exist.`)) - } - reject(err) - }) - }) - } - - getAccountData(): Promise { - return new Promise((resolve, reject) => { - if ( - this.account_data && - this.account_data_timestamp && - this.account_data_timestamp + this.cache_duration > Date.now() - ) { - return resolve(this.account_data) - } - - this.api_client.v1.chain - .get_account(String(this.accountName)) - .then((accountData) => { - this.account_data = accountData - this.account_data_timestamp = Date.now() - resolve(accountData) - }) - .catch((error) => { - if (error.message.includes('Account not found')) { - return reject(new Error(`Account ${this.account_name} does not exist.`)) - } - reject(error) - }) - }) - } -} diff --git a/src/accounts/actions/permissions.ts b/src/accounts/actions/permissions.ts deleted file mode 100644 index 9f4a479..0000000 --- a/src/accounts/actions/permissions.ts +++ /dev/null @@ -1,46 +0,0 @@ -import {Authority, AuthorityType, Name, NameType, Struct} from '@greymass/eosio' - -// Temporarily use a custom version of Contract class. -import {Contract} from '../../tmp/contract' - -class PermissionActions extends Contract { - static account = Name.from('eosio') - - async updateAuth( - permissionData: { - account: NameType - permission: NameType - parent: NameType - auth: AuthorityType - }, - sessionData?: any - ) { - return this.call('updateauth', PermissionActions.Types.UpdateAuth.from(permissionData)) - } - - async deleteAuth(account: NameType, permission: NameType, sessionData?: any) { - return this.call( - 'deleteauth', - PermissionActions.Types.DeleteAuth.from({account, permission}) - ) - } -} - -namespace PermissionActions { - export namespace Types { - @Struct.type('updateauth') - export class UpdateAuth extends Struct { - @Struct.field('name') declare account: Name - @Struct.field('name') declare permission: Name - @Struct.field('string') declare parent: Name - @Struct.field('authorization_object') declare auth: Authority - } - - export class DeleteAuth extends Struct { - @Struct.field('name') declare account: Name - @Struct.field('name') declare permission: Name - } - } -} - -export {PermissionActions} diff --git a/src/accounts/actions/resources.ts b/src/accounts/actions/resources.ts deleted file mode 100644 index 90d328f..0000000 --- a/src/accounts/actions/resources.ts +++ /dev/null @@ -1,191 +0,0 @@ -import {Action, Asset, AssetType, Name, NameType, Struct} from '@greymass/eosio' - -// Temporarily use a custom version of Contract class. -import {Contract} from '../../tmp/contract' - -class ResourceActions extends Contract { - static account = Name.from('eosio') - - async buyRam(payer: NameType, receiver: NameType, quant: AssetType, sessionData?: any) { - return this.call('buyram', ResourceActions.Types.BuyRam.from({payer, receiver, quant})) - } - - async buyRamBytes(payer: NameType, receiver: NameType, bytes: number, sessionData?: any) { - return this.call( - 'buyrambytes', - ResourceActions.Types.BuyRamBytes.from({payer, receiver, bytes}) - ) - } - - async sellRam(account: NameType, bytes: number, sessionData?: any) { - return this.call('sellram', ResourceActions.Types.SellRam.from({account, bytes})) - } - - async delegateResources( - from: NameType, - receiver: NameType, - stake_net_quantity: AssetType, - stake_cpu_quantity: AssetType, - transfer = false, - sessionData?: any - ) { - return this.call( - 'delegatebw', - ResourceActions.Types.DelegateCpu.from({ - from, - receiver, - stake_net_quantity, - stake_cpu_quantity, - transfer, - }) - ) - } - - async undelegateResources( - from: NameType, - receiver: NameType, - unstake_net_quantity: AssetType, - unstake_cpu_quantity: AssetType, - sessionData?: any - ) { - return this.call( - 'undelegatebw', - ResourceActions.Types.UndelegateCpu.from({ - from, - receiver, - unstake_net_quantity, - unstake_cpu_quantity, - }) - ) - } - - async refundCpu(owner: NameType, sessionData?: any) { - return this.call('refund', ResourceActions.Types.Refund.from({owner})) - } - - async buyRamAction( - payer: NameType, - receiver: NameType, - quant: AssetType, - sessionData?: any - ): Promise { - return this.getAction('buyram', ResourceActions.Types.BuyRam.from({payer, receiver, quant})) - } - - async buyRamBytesAction( - payer: NameType, - receiver: NameType, - bytes: number, - sessionData?: any - ): Promise { - return this.getAction( - 'buyrambytes', - ResourceActions.Types.BuyRamBytes.from({payer, receiver, bytes}) - ) - } - - async sellRamAction(account: NameType, bytes: number, sessionData?: any): Promise { - return this.getAction('sellram', ResourceActions.Types.SellRam.from({account, bytes})) - } - - async delegateResourcesAction( - from: NameType, - receiver: NameType, - stake_net_quantity: AssetType, - stake_cpu_quantity: AssetType, - transfer: boolean, - sessionData?: any - ): Promise { - return this.getAction( - 'delegatebw', - ResourceActions.Types.DelegateCpu.from({ - from, - receiver, - stake_net_quantity, - stake_cpu_quantity, - transfer, - }) - ) - } - - async undelegateResourcesAction( - from: NameType, - receiver: NameType, - unstake_net_quantity: AssetType, - unstake_cpu_quantity: AssetType, - sessionData?: any - ): Promise { - return this.getAction( - 'undelegatebw', - ResourceActions.Types.UndelegateCpu.from({ - from, - receiver, - unstake_net_quantity, - unstake_cpu_quantity, - }) - ) - } -} - -namespace ResourceActions { - export namespace Types { - @Struct.type('buyram') - export class BuyRam extends Struct { - @Struct.field('name') declare payer: Name - @Struct.field('name') declare receiver: Name - @Struct.field('asset') declare quant: Asset - } - - @Struct.type('buyrambytes') - export class BuyRamBytes extends Struct { - @Struct.field('name') declare payer: Name - @Struct.field('name') declare receiver: Name - @Struct.field('uint32') declare bytes: number - } - - @Struct.type('sellram') - export class SellRam extends Struct { - @Struct.field('name') declare account: Name - @Struct.field('uint64') declare bytes: number - } - - @Struct.type('delegatecpu') - export class DelegateCpu extends Struct { - @Struct.field('name') declare from: Name - @Struct.field('name') declare receiver: Name - @Struct.field('asset') declare stake_cpu_quantity: Asset - @Struct.field('bool') declare transfer: boolean - } - - @Struct.type('undelegatecpu') - export class UndelegateCpu extends Struct { - @Struct.field('name') declare from: Name - @Struct.field('name') declare receiver: Name - @Struct.field('asset') declare unstake_cpu_quantity: Asset - } - - @Struct.type('delegatebw') - export class DelegateBandwidth extends Struct { - @Struct.field('name') declare from: Name - @Struct.field('name') declare receiver: Name - @Struct.field('asset') declare stake_net_quantity: Asset - @Struct.field('asset') declare stake_cpu_quantity: Asset - @Struct.field('bool') declare transfer: boolean - } - - @Struct.type('undelegatebw') - export class UndelegateBandwidth extends Struct { - @Struct.field('name') declare from: Name - @Struct.field('name') declare receiver: Name - @Struct.field('asset') declare unstake_net_quantity: Asset - @Struct.field('asset') declare unstake_cpu_quantity: Asset - } - - @Struct.type('refund') - export class Refund extends Struct { - @Struct.field('name') declare owner: Name - } - } -} - -export {ResourceActions} diff --git a/src/contracts/eosio.ts b/src/contracts/eosio.ts new file mode 100644 index 0000000..c15c6bf --- /dev/null +++ b/src/contracts/eosio.ts @@ -0,0 +1,1539 @@ +import { + ABI, + Action, + Asset, + AssetType, + Blob, + BlockTimestamp, + Bytes, + BytesType, + Checksum256, + Checksum256Type, + Float64, + Int64, + Int64Type, + Name, + NameType, + PublicKey, + PublicKeyType, + Struct, + TimePoint, + TimePointSec, + UInt128, + UInt128Type, + UInt16, + UInt16Type, + UInt32, + UInt32Type, + UInt64, + UInt64Type, + UInt8, + UInt8Type, + VarUInt, + VarUIntType, +} from '@wharfkit/antelope' +import {ActionOptions, Contract as BaseContract, ContractArgs, PartialBy} from '@wharfkit/contract' +export namespace Eosio { + export const abiBlob = Blob.from( + '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' + ) + export const abi = ABI.from(abiBlob) + export class Contract extends BaseContract { + constructor(args: PartialBy) { + super({ + client: args.client, + abi: abi, + account: Name.from('eosio'), + }) + } + action< + T extends + | 'activate' + | 'bidname' + | 'bidrefund' + | 'buyram' + | 'buyrambytes' + | 'buyrex' + | 'canceldelay' + | 'cfgpowerup' + | 'claimrewards' + | 'closerex' + | 'cnclrexorder' + | 'consolidate' + | 'defcpuloan' + | 'defnetloan' + | 'delegatebw' + | 'deleteauth' + | 'deposit' + | 'fundcpuloan' + | 'fundnetloan' + | 'init' + | 'limitauthchg' + | 'linkauth' + | 'mvfrsavings' + | 'mvtosavings' + | 'newaccount' + | 'onblock' + | 'onerror' + | 'powerup' + | 'powerupexec' + | 'refund' + | 'regproducer' + | 'regproducer2' + | 'regproxy' + | 'rentcpu' + | 'rentnet' + | 'rexexec' + | 'rmvproducer' + | 'sellram' + | 'sellrex' + | 'setabi' + | 'setacctcpu' + | 'setacctnet' + | 'setacctram' + | 'setalimits' + | 'setcode' + | 'setinflation' + | 'setparams' + | 'setpriv' + | 'setram' + | 'setramrate' + | 'setrex' + | 'undelegatebw' + | 'unlinkauth' + | 'unregprod' + | 'unstaketorex' + | 'updateauth' + | 'updaterex' + | 'updtrevision' + | 'voteproducer' + | 'voteupdate' + | 'wasmcfg' + | 'withdraw' + >(name: T, data: ActionNameParams[T], options?: ActionOptions): Action { + return super.action(name, data, options) + } + table< + T extends + | 'abihash' + | 'bidrefunds' + | 'blockinfo' + | 'cpuloan' + | 'delband' + | 'global' + | 'global2' + | 'global3' + | 'global4' + | 'namebids' + | 'netloan' + | 'powup.order' + | 'powup.state' + | 'producers' + | 'producers2' + | 'rammarket' + | 'refunds' + | 'retbuckets' + | 'rexbal' + | 'rexfund' + | 'rexpool' + | 'rexqueue' + | 'rexretpool' + | 'userres' + | 'voters' + | 'limitauthchg' + >(name: T, scope?: NameType) { + return super.table(name, scope, TableMap[name]) + } + } + export interface ActionNameParams { + activate: ActionParams.Activate + bidname: ActionParams.Bidname + bidrefund: ActionParams.Bidrefund + buyram: ActionParams.Buyram + buyrambytes: ActionParams.Buyrambytes + buyrex: ActionParams.Buyrex + canceldelay: ActionParams.Canceldelay + cfgpowerup: ActionParams.Cfgpowerup + claimrewards: ActionParams.Claimrewards + closerex: ActionParams.Closerex + cnclrexorder: ActionParams.Cnclrexorder + consolidate: ActionParams.Consolidate + defcpuloan: ActionParams.Defcpuloan + defnetloan: ActionParams.Defnetloan + delegatebw: ActionParams.Delegatebw + deleteauth: ActionParams.Deleteauth + deposit: ActionParams.Deposit + fundcpuloan: ActionParams.Fundcpuloan + fundnetloan: ActionParams.Fundnetloan + init: ActionParams.Init + limitauthchg: ActionParams.Limitauthchg + linkauth: ActionParams.Linkauth + mvfrsavings: ActionParams.Mvfrsavings + mvtosavings: ActionParams.Mvtosavings + newaccount: ActionParams.Newaccount + onblock: ActionParams.Onblock + onerror: ActionParams.Onerror + powerup: ActionParams.Powerup + powerupexec: ActionParams.Powerupexec + refund: ActionParams.Refund + regproducer: ActionParams.Regproducer + regproducer2: ActionParams.Regproducer2 + regproxy: ActionParams.Regproxy + rentcpu: ActionParams.Rentcpu + rentnet: ActionParams.Rentnet + rexexec: ActionParams.Rexexec + rmvproducer: ActionParams.Rmvproducer + sellram: ActionParams.Sellram + sellrex: ActionParams.Sellrex + setabi: ActionParams.Setabi + setacctcpu: ActionParams.Setacctcpu + setacctnet: ActionParams.Setacctnet + setacctram: ActionParams.Setacctram + setalimits: ActionParams.Setalimits + setcode: ActionParams.Setcode + setinflation: ActionParams.Setinflation + setparams: ActionParams.Setparams + setpriv: ActionParams.Setpriv + setram: ActionParams.Setram + setramrate: ActionParams.Setramrate + setrex: ActionParams.Setrex + undelegatebw: ActionParams.Undelegatebw + unlinkauth: ActionParams.Unlinkauth + unregprod: ActionParams.Unregprod + unstaketorex: ActionParams.Unstaketorex + updateauth: ActionParams.Updateauth + updaterex: ActionParams.Updaterex + updtrevision: ActionParams.Updtrevision + voteproducer: ActionParams.Voteproducer + voteupdate: ActionParams.Voteupdate + wasmcfg: ActionParams.Wasmcfg + withdraw: ActionParams.Withdraw + } + export namespace ActionParams { + export interface Activate { + feature_digest: Checksum256Type + } + export interface Bidname { + bidder: NameType + newname: NameType + bid: AssetType + } + export interface Bidrefund { + bidder: NameType + newname: NameType + } + export interface Buyram { + payer: NameType + receiver: NameType + quant: AssetType + } + export interface Buyrambytes { + payer: NameType + receiver: NameType + bytes: UInt32Type + } + export interface Buyrex { + from: NameType + amount: AssetType + } + export interface Canceldelay { + canceling_auth: Types.PermissionLevel + trx_id: Checksum256Type + } + export interface Cfgpowerup { + args: Types.PowerupConfig + } + export interface Claimrewards { + owner: NameType + } + export interface Closerex { + owner: NameType + } + export interface Cnclrexorder { + owner: NameType + } + export interface Consolidate { + owner: NameType + } + export interface Defcpuloan { + from: NameType + loan_num: UInt64Type + amount: AssetType + } + export interface Defnetloan { + from: NameType + loan_num: UInt64Type + amount: AssetType + } + export interface Delegatebw { + from: NameType + receiver: NameType + stake_net_quantity: AssetType + stake_cpu_quantity: AssetType + transfer: boolean + } + export interface Deleteauth { + account: NameType + permission: NameType + authorized_by: NameType + } + export interface Deposit { + owner: NameType + amount: AssetType + } + export interface Fundcpuloan { + from: NameType + loan_num: UInt64Type + payment: AssetType + } + export interface Fundnetloan { + from: NameType + loan_num: UInt64Type + payment: AssetType + } + export interface Init { + version: VarUIntType + core: Asset.SymbolType + } + export interface Limitauthchg { + account: NameType + allow_perms: NameType[] + disallow_perms: NameType[] + } + export interface Linkauth { + account: NameType + code: NameType + type: NameType + requirement: NameType + authorized_by: NameType + } + export interface Mvfrsavings { + owner: NameType + rex: AssetType + } + export interface Mvtosavings { + owner: NameType + rex: AssetType + } + export interface Newaccount { + creator: NameType + name: NameType + owner: Types.Authority + active: Types.Authority + } + export interface Onblock { + header: Types.BlockHeader + } + export interface Onerror { + sender_id: UInt128Type + sent_trx: BytesType + } + export interface Powerup { + payer: NameType + receiver: NameType + days: UInt32Type + net_frac: Int64Type + cpu_frac: Int64Type + max_payment: AssetType + } + export interface Powerupexec { + user: NameType + max: UInt16Type + } + export interface Refund { + owner: NameType + } + export interface Regproducer { + producer: NameType + producer_key: PublicKeyType + url: string + location: UInt16Type + } + export interface Regproducer2 { + producer: NameType + producer_authority: Types.BlockSigningAuthorityV0 + url: string + location: UInt16Type + } + export interface Regproxy { + proxy: NameType + isproxy: boolean + } + export interface Rentcpu { + from: NameType + receiver: NameType + loan_payment: AssetType + loan_fund: AssetType + } + export interface Rentnet { + from: NameType + receiver: NameType + loan_payment: AssetType + loan_fund: AssetType + } + export interface Rexexec { + user: NameType + max: UInt16Type + } + export interface Rmvproducer { + producer: NameType + } + export interface Sellram { + account: NameType + bytes: Int64Type + } + export interface Sellrex { + from: NameType + rex: AssetType + } + export interface Setabi { + account: NameType + abi: BytesType + memo: string + } + export interface Setacctcpu { + account: NameType + cpu_weight?: Int64Type + } + export interface Setacctnet { + account: NameType + net_weight?: Int64Type + } + export interface Setacctram { + account: NameType + ram_bytes?: Int64Type + } + export interface Setalimits { + account: NameType + ram_bytes: Int64Type + net_weight: Int64Type + cpu_weight: Int64Type + } + export interface Setcode { + account: NameType + vmtype: UInt8Type + vmversion: UInt8Type + code: BytesType + memo: string + } + export interface Setinflation { + annual_rate: Int64Type + inflation_pay_factor: Int64Type + votepay_factor: Int64Type + } + export interface Setparams { + params: Types.BlockchainParametersV1 + } + export interface Setpriv { + account: NameType + is_priv: UInt8Type + } + export interface Setram { + max_ram_size: UInt64Type + } + export interface Setramrate { + bytes_per_block: UInt16Type + } + export interface Setrex { + balance: AssetType + } + export interface Undelegatebw { + from: NameType + receiver: NameType + unstake_net_quantity: AssetType + unstake_cpu_quantity: AssetType + } + export interface Unlinkauth { + account: NameType + code: NameType + type: NameType + authorized_by: NameType + } + export interface Unregprod { + producer: NameType + } + export interface Unstaketorex { + owner: NameType + receiver: NameType + from_net: AssetType + from_cpu: AssetType + } + export interface Updateauth { + account: NameType + permission: NameType + parent: NameType + auth: Types.Authority + authorized_by: NameType + } + export interface Updaterex { + owner: NameType + } + export interface Updtrevision { + revision: UInt8Type + } + export interface Voteproducer { + voter: NameType + proxy: NameType + producers: NameType[] + } + export interface Voteupdate { + voter_name: NameType + } + export interface Wasmcfg { + settings: NameType + } + export interface Withdraw { + owner: NameType + amount: AssetType + } + } + export namespace Types { + @Struct.type('abi_hash') + export class AbiHash extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Checksum256) + hash!: Checksum256 + } + @Struct.type('activate') + export class Activate extends Struct { + @Struct.field(Checksum256) + feature_digest!: Checksum256 + } + @Struct.type('key_weight') + export class KeyWeight extends Struct { + @Struct.field(PublicKey) + key!: PublicKey + @Struct.field(UInt16) + weight!: UInt16 + } + @Struct.type('permission_level') + export class PermissionLevel extends Struct { + @Struct.field(Name) + actor!: Name + @Struct.field(Name) + permission!: Name + } + @Struct.type('permission_level_weight') + export class PermissionLevelWeight extends Struct { + @Struct.field(PermissionLevel) + permission!: PermissionLevel + @Struct.field(UInt16) + weight!: UInt16 + } + @Struct.type('wait_weight') + export class WaitWeight extends Struct { + @Struct.field(UInt32) + wait_sec!: UInt32 + @Struct.field(UInt16) + weight!: UInt16 + } + @Struct.type('authority') + export class Authority extends Struct { + @Struct.field(UInt32) + threshold!: UInt32 + @Struct.field(KeyWeight, {array: true}) + keys!: KeyWeight[] + @Struct.field(PermissionLevelWeight, {array: true}) + accounts!: PermissionLevelWeight[] + @Struct.field(WaitWeight, {array: true}) + waits!: WaitWeight[] + } + @Struct.type('bid_refund') + export class BidRefund extends Struct { + @Struct.field(Name) + bidder!: Name + @Struct.field(Asset) + amount!: Asset + } + @Struct.type('bidname') + export class Bidname extends Struct { + @Struct.field(Name) + bidder!: Name + @Struct.field(Name) + newname!: Name + @Struct.field(Asset) + bid!: Asset + } + @Struct.type('bidrefund') + export class Bidrefund extends Struct { + @Struct.field(Name) + bidder!: Name + @Struct.field(Name) + newname!: Name + } + @Struct.type('producer_key') + export class ProducerKey extends Struct { + @Struct.field(Name) + producer_name!: Name + @Struct.field(PublicKey) + block_signing_key!: PublicKey + } + @Struct.type('producer_schedule') + export class ProducerSchedule extends Struct { + @Struct.field(UInt32) + version!: UInt32 + @Struct.field(ProducerKey, {array: true}) + producers!: ProducerKey[] + } + @Struct.type('block_header') + export class BlockHeader extends Struct { + @Struct.field(UInt32) + timestamp!: UInt32 + @Struct.field(Name) + producer!: Name + @Struct.field(UInt16) + confirmed!: UInt16 + @Struct.field(Checksum256) + previous!: Checksum256 + @Struct.field(Checksum256) + transaction_mroot!: Checksum256 + @Struct.field(Checksum256) + action_mroot!: Checksum256 + @Struct.field(UInt32) + schedule_version!: UInt32 + @Struct.field(ProducerSchedule, {optional: true}) + new_producers?: ProducerSchedule + } + @Struct.type('block_info_record') + export class BlockInfoRecord extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(UInt32) + block_height!: UInt32 + @Struct.field(TimePoint) + block_timestamp!: TimePoint + } + @Struct.type('block_signing_authority_v0') + export class BlockSigningAuthorityV0 extends Struct { + @Struct.field(UInt32) + threshold!: UInt32 + @Struct.field(KeyWeight, {array: true}) + keys!: KeyWeight[] + } + @Struct.type('blockchain_parameters') + export class BlockchainParameters extends Struct { + @Struct.field(UInt64) + max_block_net_usage!: UInt64 + @Struct.field(UInt32) + target_block_net_usage_pct!: UInt32 + @Struct.field(UInt32) + max_transaction_net_usage!: UInt32 + @Struct.field(UInt32) + base_per_transaction_net_usage!: UInt32 + @Struct.field(UInt32) + net_usage_leeway!: UInt32 + @Struct.field(UInt32) + context_free_discount_net_usage_num!: UInt32 + @Struct.field(UInt32) + context_free_discount_net_usage_den!: UInt32 + @Struct.field(UInt32) + max_block_cpu_usage!: UInt32 + @Struct.field(UInt32) + target_block_cpu_usage_pct!: UInt32 + @Struct.field(UInt32) + max_transaction_cpu_usage!: UInt32 + @Struct.field(UInt32) + min_transaction_cpu_usage!: UInt32 + @Struct.field(UInt32) + max_transaction_lifetime!: UInt32 + @Struct.field(UInt32) + deferred_trx_expiration_window!: UInt32 + @Struct.field(UInt32) + max_transaction_delay!: UInt32 + @Struct.field(UInt32) + max_inline_action_size!: UInt32 + @Struct.field(UInt16) + max_inline_action_depth!: UInt16 + @Struct.field(UInt16) + max_authority_depth!: UInt16 + } + @Struct.type('blockchain_parameters_v1') + export class BlockchainParametersV1 extends Struct { + @Struct.field(UInt32) + max_action_return_value_size!: UInt32 + } + @Struct.type('buyram') + export class Buyram extends Struct { + @Struct.field(Name) + payer!: Name + @Struct.field(Name) + receiver!: Name + @Struct.field(Asset) + quant!: Asset + } + @Struct.type('buyrambytes') + export class Buyrambytes extends Struct { + @Struct.field(Name) + payer!: Name + @Struct.field(Name) + receiver!: Name + @Struct.field(UInt32) + bytes!: UInt32 + } + @Struct.type('buyrex') + export class Buyrex extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(Asset) + amount!: Asset + } + @Struct.type('canceldelay') + export class Canceldelay extends Struct { + @Struct.field(PermissionLevel) + canceling_auth!: PermissionLevel + @Struct.field(Checksum256) + trx_id!: Checksum256 + } + @Struct.type('powerup_config_resource') + export class PowerupConfigResource extends Struct { + @Struct.field(Int64, {optional: true}) + current_weight_ratio?: Int64 + @Struct.field(Int64, {optional: true}) + target_weight_ratio?: Int64 + @Struct.field(Int64, {optional: true}) + assumed_stake_weight?: Int64 + @Struct.field(TimePointSec, {optional: true}) + target_timestamp?: TimePointSec + @Struct.field(Float64, {optional: true}) + exponent?: Float64 + @Struct.field(UInt32, {optional: true}) + decay_secs?: UInt32 + @Struct.field(Asset, {optional: true}) + min_price?: Asset + @Struct.field(Asset, {optional: true}) + max_price?: Asset + } + @Struct.type('powerup_config') + export class PowerupConfig extends Struct { + @Struct.field(PowerupConfigResource) + net!: PowerupConfigResource + @Struct.field(PowerupConfigResource) + cpu!: PowerupConfigResource + @Struct.field(UInt32, {optional: true}) + powerup_days?: UInt32 + @Struct.field(Asset, {optional: true}) + min_powerup_fee?: Asset + } + @Struct.type('cfgpowerup') + export class Cfgpowerup extends Struct { + @Struct.field(PowerupConfig) + args!: PowerupConfig + } + @Struct.type('claimrewards') + export class Claimrewards extends Struct { + @Struct.field(Name) + owner!: Name + } + @Struct.type('closerex') + export class Closerex extends Struct { + @Struct.field(Name) + owner!: Name + } + @Struct.type('cnclrexorder') + export class Cnclrexorder extends Struct { + @Struct.field(Name) + owner!: Name + } + @Struct.type('connector') + export class Connector extends Struct { + @Struct.field(Asset) + balance!: Asset + @Struct.field(Float64) + weight!: Float64 + } + @Struct.type('consolidate') + export class Consolidate extends Struct { + @Struct.field(Name) + owner!: Name + } + @Struct.type('defcpuloan') + export class Defcpuloan extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(UInt64) + loan_num!: UInt64 + @Struct.field(Asset) + amount!: Asset + } + @Struct.type('defnetloan') + export class Defnetloan extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(UInt64) + loan_num!: UInt64 + @Struct.field(Asset) + amount!: Asset + } + @Struct.type('delegatebw') + export class Delegatebw extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(Name) + receiver!: Name + @Struct.field(Asset) + stake_net_quantity!: Asset + @Struct.field(Asset) + stake_cpu_quantity!: Asset + @Struct.field('boolean') + transfer!: boolean + } + @Struct.type('delegated_bandwidth') + export class DelegatedBandwidth extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(Name) + to!: Name + @Struct.field(Asset) + net_weight!: Asset + @Struct.field(Asset) + cpu_weight!: Asset + } + @Struct.type('deleteauth') + export class Deleteauth extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Name) + permission!: Name + @Struct.field(Name) + authorized_by!: Name + } + @Struct.type('deposit') + export class Deposit extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Asset) + amount!: Asset + } + @Struct.type('eosio_global_state') + export class EosioGlobalState extends Struct { + @Struct.field(UInt64) + max_ram_size!: UInt64 + @Struct.field(UInt64) + total_ram_bytes_reserved!: UInt64 + @Struct.field(Int64) + total_ram_stake!: Int64 + @Struct.field(BlockTimestamp) + last_producer_schedule_update!: BlockTimestamp + @Struct.field(TimePoint) + last_pervote_bucket_fill!: TimePoint + @Struct.field(Int64) + pervote_bucket!: Int64 + @Struct.field(Int64) + perblock_bucket!: Int64 + @Struct.field(UInt32) + total_unpaid_blocks!: UInt32 + @Struct.field(Int64) + total_activated_stake!: Int64 + @Struct.field(TimePoint) + thresh_activated_stake_time!: TimePoint + @Struct.field(UInt16) + last_producer_schedule_size!: UInt16 + @Struct.field(Float64) + total_producer_vote_weight!: Float64 + @Struct.field(BlockTimestamp) + last_name_close!: BlockTimestamp + } + @Struct.type('eosio_global_state2') + export class EosioGlobalState2 extends Struct { + @Struct.field(UInt16) + new_ram_per_block!: UInt16 + @Struct.field(BlockTimestamp) + last_ram_increase!: BlockTimestamp + @Struct.field(BlockTimestamp) + last_block_num!: BlockTimestamp + @Struct.field(Float64) + total_producer_votepay_share!: Float64 + @Struct.field(UInt8) + revision!: UInt8 + } + @Struct.type('eosio_global_state3') + export class EosioGlobalState3 extends Struct { + @Struct.field(TimePoint) + last_vpay_state_update!: TimePoint + @Struct.field(Float64) + total_vpay_share_change_rate!: Float64 + } + @Struct.type('eosio_global_state4') + export class EosioGlobalState4 extends Struct { + @Struct.field(Float64) + continuous_rate!: Float64 + @Struct.field(Int64) + inflation_pay_factor!: Int64 + @Struct.field(Int64) + votepay_factor!: Int64 + } + @Struct.type('exchange_state') + export class ExchangeState extends Struct { + @Struct.field(Asset) + supply!: Asset + @Struct.field(Connector) + base!: Connector + @Struct.field(Connector) + quote!: Connector + } + @Struct.type('fundcpuloan') + export class Fundcpuloan extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(UInt64) + loan_num!: UInt64 + @Struct.field(Asset) + payment!: Asset + } + @Struct.type('fundnetloan') + export class Fundnetloan extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(UInt64) + loan_num!: UInt64 + @Struct.field(Asset) + payment!: Asset + } + @Struct.type('init') + export class Init extends Struct { + @Struct.field(VarUInt) + version!: VarUInt + @Struct.field(Asset.Symbol) + core!: Asset.Symbol + } + @Struct.type('limitauthchg') + export class Limitauthchg extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Name, {array: true}) + allow_perms!: Name[] + @Struct.field(Name, {array: true}) + disallow_perms!: Name[] + } + @Struct.type('linkauth') + export class Linkauth extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Name) + code!: Name + @Struct.field(Name) + type!: Name + @Struct.field(Name) + requirement!: Name + @Struct.field(Name) + authorized_by!: Name + } + @Struct.type('mvfrsavings') + export class Mvfrsavings extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Asset) + rex!: Asset + } + @Struct.type('mvtosavings') + export class Mvtosavings extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Asset) + rex!: Asset + } + @Struct.type('name_bid') + export class NameBid extends Struct { + @Struct.field(Name) + newname!: Name + @Struct.field(Name) + high_bidder!: Name + @Struct.field(Int64) + high_bid!: Int64 + @Struct.field(TimePoint) + last_bid_time!: TimePoint + } + @Struct.type('newaccount') + export class Newaccount extends Struct { + @Struct.field(Name) + creator!: Name + @Struct.field(Name) + name!: Name + @Struct.field(Authority) + owner!: Authority + @Struct.field(Authority) + active!: Authority + } + @Struct.type('onblock') + export class Onblock extends Struct { + @Struct.field(BlockHeader) + header!: BlockHeader + } + @Struct.type('onerror') + export class Onerror extends Struct { + @Struct.field(UInt128) + sender_id!: UInt128 + @Struct.field(Bytes) + sent_trx!: Bytes + } + @Struct.type('pair_time_point_sec_int64') + export class PairTimePointSecInt64 extends Struct { + @Struct.field(TimePointSec) + first!: TimePointSec + @Struct.field(Int64) + second!: Int64 + } + @Struct.type('powerup') + export class Powerup extends Struct { + @Struct.field(Name) + payer!: Name + @Struct.field(Name) + receiver!: Name + @Struct.field(UInt32) + days!: UInt32 + @Struct.field(Int64) + net_frac!: Int64 + @Struct.field(Int64) + cpu_frac!: Int64 + @Struct.field(Asset) + max_payment!: Asset + } + @Struct.type('powerup_order') + export class PowerupOrder extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(UInt64) + id!: UInt64 + @Struct.field(Name) + owner!: Name + @Struct.field(Int64) + net_weight!: Int64 + @Struct.field(Int64) + cpu_weight!: Int64 + @Struct.field(TimePointSec) + expires!: TimePointSec + } + @Struct.type('powerup_state_resource') + export class PowerupStateResource extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(Int64) + weight!: Int64 + @Struct.field(Int64) + weight_ratio!: Int64 + @Struct.field(Int64) + assumed_stake_weight!: Int64 + @Struct.field(Int64) + initial_weight_ratio!: Int64 + @Struct.field(Int64) + target_weight_ratio!: Int64 + @Struct.field(TimePointSec) + initial_timestamp!: TimePointSec + @Struct.field(TimePointSec) + target_timestamp!: TimePointSec + @Struct.field(Float64) + exponent!: Float64 + @Struct.field(UInt32) + decay_secs!: UInt32 + @Struct.field(Asset) + min_price!: Asset + @Struct.field(Asset) + max_price!: Asset + @Struct.field(Int64) + utilization!: Int64 + @Struct.field(Int64) + adjusted_utilization!: Int64 + @Struct.field(TimePointSec) + utilization_timestamp!: TimePointSec + } + @Struct.type('powerup_state') + export class PowerupState extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(PowerupStateResource) + net!: PowerupStateResource + @Struct.field(PowerupStateResource) + cpu!: PowerupStateResource + @Struct.field(UInt32) + powerup_days!: UInt32 + @Struct.field(Asset) + min_powerup_fee!: Asset + } + @Struct.type('powerupexec') + export class Powerupexec extends Struct { + @Struct.field(Name) + user!: Name + @Struct.field(UInt16) + max!: UInt16 + } + @Struct.type('producer_info') + export class ProducerInfo extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Float64) + total_votes!: Float64 + @Struct.field(PublicKey) + producer_key!: PublicKey + @Struct.field('boolean') + is_active!: boolean + @Struct.field('string') + url!: string + @Struct.field(UInt32) + unpaid_blocks!: UInt32 + @Struct.field(TimePoint) + last_claim_time!: TimePoint + @Struct.field(UInt16) + location!: UInt16 + @Struct.field(BlockSigningAuthorityV0) + producer_authority!: BlockSigningAuthorityV0 + } + @Struct.type('producer_info2') + export class ProducerInfo2 extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Float64) + votepay_share!: Float64 + @Struct.field(TimePoint) + last_votepay_share_update!: TimePoint + } + @Struct.type('refund') + export class Refund extends Struct { + @Struct.field(Name) + owner!: Name + } + @Struct.type('refund_request') + export class RefundRequest extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(TimePointSec) + request_time!: TimePointSec + @Struct.field(Asset) + net_amount!: Asset + @Struct.field(Asset) + cpu_amount!: Asset + } + @Struct.type('regproducer') + export class Regproducer extends Struct { + @Struct.field(Name) + producer!: Name + @Struct.field(PublicKey) + producer_key!: PublicKey + @Struct.field('string') + url!: string + @Struct.field(UInt16) + location!: UInt16 + } + @Struct.type('regproducer2') + export class Regproducer2 extends Struct { + @Struct.field(Name) + producer!: Name + @Struct.field(BlockSigningAuthorityV0) + producer_authority!: BlockSigningAuthorityV0 + @Struct.field('string') + url!: string + @Struct.field(UInt16) + location!: UInt16 + } + @Struct.type('regproxy') + export class Regproxy extends Struct { + @Struct.field(Name) + proxy!: Name + @Struct.field('boolean') + isproxy!: boolean + } + @Struct.type('rentcpu') + export class Rentcpu extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(Name) + receiver!: Name + @Struct.field(Asset) + loan_payment!: Asset + @Struct.field(Asset) + loan_fund!: Asset + } + @Struct.type('rentnet') + export class Rentnet extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(Name) + receiver!: Name + @Struct.field(Asset) + loan_payment!: Asset + @Struct.field(Asset) + loan_fund!: Asset + } + @Struct.type('rex_balance') + export class RexBalance extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(Name) + owner!: Name + @Struct.field(Asset) + vote_stake!: Asset + @Struct.field(Asset) + rex_balance!: Asset + @Struct.field(Int64) + matured_rex!: Int64 + @Struct.field(PairTimePointSecInt64, {array: true}) + rex_maturities!: PairTimePointSecInt64[] + } + @Struct.type('rex_fund') + export class RexFund extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(Name) + owner!: Name + @Struct.field(Asset) + balance!: Asset + } + @Struct.type('rex_loan') + export class RexLoan extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(Name) + from!: Name + @Struct.field(Name) + receiver!: Name + @Struct.field(Asset) + payment!: Asset + @Struct.field(Asset) + balance!: Asset + @Struct.field(Asset) + total_staked!: Asset + @Struct.field(UInt64) + loan_num!: UInt64 + @Struct.field(TimePoint) + expiration!: TimePoint + } + @Struct.type('rex_order') + export class RexOrder extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(Name) + owner!: Name + @Struct.field(Asset) + rex_requested!: Asset + @Struct.field(Asset) + proceeds!: Asset + @Struct.field(Asset) + stake_change!: Asset + @Struct.field(TimePoint) + order_time!: TimePoint + @Struct.field('boolean') + is_open!: boolean + } + @Struct.type('rex_pool') + export class RexPool extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(Asset) + total_lent!: Asset + @Struct.field(Asset) + total_unlent!: Asset + @Struct.field(Asset) + total_rent!: Asset + @Struct.field(Asset) + total_lendable!: Asset + @Struct.field(Asset) + total_rex!: Asset + @Struct.field(Asset) + namebid_proceeds!: Asset + @Struct.field(UInt64) + loan_num!: UInt64 + } + @Struct.type('rex_return_buckets') + export class RexReturnBuckets extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(PairTimePointSecInt64, {array: true}) + return_buckets!: PairTimePointSecInt64[] + } + @Struct.type('rex_return_pool') + export class RexReturnPool extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(TimePointSec) + last_dist_time!: TimePointSec + @Struct.field(TimePointSec) + pending_bucket_time!: TimePointSec + @Struct.field(TimePointSec) + oldest_bucket_time!: TimePointSec + @Struct.field(Int64) + pending_bucket_proceeds!: Int64 + @Struct.field(Int64) + current_rate_of_increase!: Int64 + @Struct.field(Int64) + proceeds!: Int64 + } + @Struct.type('rexexec') + export class Rexexec extends Struct { + @Struct.field(Name) + user!: Name + @Struct.field(UInt16) + max!: UInt16 + } + @Struct.type('rmvproducer') + export class Rmvproducer extends Struct { + @Struct.field(Name) + producer!: Name + } + @Struct.type('sellram') + export class Sellram extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Int64) + bytes!: Int64 + } + @Struct.type('sellrex') + export class Sellrex extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(Asset) + rex!: Asset + } + @Struct.type('setabi') + export class Setabi extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Bytes) + abi!: Bytes + @Struct.field('string') + memo!: string + } + @Struct.type('setacctcpu') + export class Setacctcpu extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Int64, {optional: true}) + cpu_weight?: Int64 + } + @Struct.type('setacctnet') + export class Setacctnet extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Int64, {optional: true}) + net_weight?: Int64 + } + @Struct.type('setacctram') + export class Setacctram extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Int64, {optional: true}) + ram_bytes?: Int64 + } + @Struct.type('setalimits') + export class Setalimits extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Int64) + ram_bytes!: Int64 + @Struct.field(Int64) + net_weight!: Int64 + @Struct.field(Int64) + cpu_weight!: Int64 + } + @Struct.type('setcode') + export class Setcode extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(UInt8) + vmtype!: UInt8 + @Struct.field(UInt8) + vmversion!: UInt8 + @Struct.field(Bytes) + code!: Bytes + @Struct.field('string') + memo!: string + } + @Struct.type('setinflation') + export class Setinflation extends Struct { + @Struct.field(Int64) + annual_rate!: Int64 + @Struct.field(Int64) + inflation_pay_factor!: Int64 + @Struct.field(Int64) + votepay_factor!: Int64 + } + @Struct.type('setparams') + export class Setparams extends Struct { + @Struct.field(BlockchainParametersV1) + params!: BlockchainParametersV1 + } + @Struct.type('setpriv') + export class Setpriv extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(UInt8) + is_priv!: UInt8 + } + @Struct.type('setram') + export class Setram extends Struct { + @Struct.field(UInt64) + max_ram_size!: UInt64 + } + @Struct.type('setramrate') + export class Setramrate extends Struct { + @Struct.field(UInt16) + bytes_per_block!: UInt16 + } + @Struct.type('setrex') + export class Setrex extends Struct { + @Struct.field(Asset) + balance!: Asset + } + @Struct.type('undelegatebw') + export class Undelegatebw extends Struct { + @Struct.field(Name) + from!: Name + @Struct.field(Name) + receiver!: Name + @Struct.field(Asset) + unstake_net_quantity!: Asset + @Struct.field(Asset) + unstake_cpu_quantity!: Asset + } + @Struct.type('unlinkauth') + export class Unlinkauth extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Name) + code!: Name + @Struct.field(Name) + type!: Name + @Struct.field(Name) + authorized_by!: Name + } + @Struct.type('unregprod') + export class Unregprod extends Struct { + @Struct.field(Name) + producer!: Name + } + @Struct.type('unstaketorex') + export class Unstaketorex extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Name) + receiver!: Name + @Struct.field(Asset) + from_net!: Asset + @Struct.field(Asset) + from_cpu!: Asset + } + @Struct.type('updateauth') + export class Updateauth extends Struct { + @Struct.field(Name) + account!: Name + @Struct.field(Name) + permission!: Name + @Struct.field(Name) + parent!: Name + @Struct.field(Authority) + auth!: Authority + @Struct.field(Name) + authorized_by!: Name + } + @Struct.type('updaterex') + export class Updaterex extends Struct { + @Struct.field(Name) + owner!: Name + } + @Struct.type('updtrevision') + export class Updtrevision extends Struct { + @Struct.field(UInt8) + revision!: UInt8 + } + @Struct.type('user_resources') + export class UserResources extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Asset) + net_weight!: Asset + @Struct.field(Asset) + cpu_weight!: Asset + @Struct.field(Int64) + ram_bytes!: Int64 + } + @Struct.type('voteproducer') + export class Voteproducer extends Struct { + @Struct.field(Name) + voter!: Name + @Struct.field(Name) + proxy!: Name + @Struct.field(Name, {array: true}) + producers!: Name[] + } + @Struct.type('voter_info') + export class VoterInfo extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Name) + proxy!: Name + @Struct.field(Name, {array: true}) + producers!: Name[] + @Struct.field(Int64) + staked!: Int64 + @Struct.field(Float64) + last_vote_weight!: Float64 + @Struct.field(Float64) + proxied_vote_weight!: Float64 + @Struct.field('boolean') + is_proxy!: boolean + @Struct.field(UInt32) + flags1!: UInt32 + @Struct.field(UInt32) + reserved2!: UInt32 + @Struct.field(Asset) + reserved3!: Asset + } + @Struct.type('voteupdate') + export class Voteupdate extends Struct { + @Struct.field(Name) + voter_name!: Name + } + @Struct.type('wasmcfg') + export class Wasmcfg extends Struct { + @Struct.field(Name) + settings!: Name + } + @Struct.type('withdraw') + export class Withdraw extends Struct { + @Struct.field(Name) + owner!: Name + @Struct.field(Asset) + amount!: Asset + } + @Struct.type('limit_auth_change') + export class LimitAuthChange extends Struct { + @Struct.field(UInt8) + version!: UInt8 + @Struct.field(Name) + account!: Name + @Struct.field(Name, {array: true}) + allow_perms!: Name[] + @Struct.field(Name, {array: true}) + disallow_perms!: Name[] + } + } + const TableMap = { + abihash: Types.AbiHash, + bidrefunds: Types.BidRefund, + blockinfo: Types.BlockInfoRecord, + cpuloan: Types.RexLoan, + delband: Types.DelegatedBandwidth, + global: Types.EosioGlobalState, + global2: Types.EosioGlobalState2, + global3: Types.EosioGlobalState3, + global4: Types.EosioGlobalState4, + namebids: Types.NameBid, + netloan: Types.RexLoan, + 'powup.order': Types.PowerupOrder, + 'powup.state': Types.PowerupState, + producers: Types.ProducerInfo, + producers2: Types.ProducerInfo2, + rammarket: Types.ExchangeState, + refunds: Types.RefundRequest, + retbuckets: Types.RexReturnBuckets, + rexbal: Types.RexBalance, + rexfund: Types.RexFund, + rexpool: Types.RexPool, + rexqueue: Types.RexOrder, + rexretpool: Types.RexReturnPool, + userres: Types.UserResources, + voters: Types.VoterInfo, + limitauthchg: Types.LimitAuthChange, + } +} +export default Eosio + diff --git a/src/index.ts b/src/index.ts index 09398ec..54519ef 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,9 +1,7 @@ -/** - * Solve for completeness. - * @param n The number. - * @param p The problem. - * @param hard Set to true for super hard problem. - * @returns The solution. - */ -export * from './accounts' -export * from './permissions' +export * from './account' +export * from './permission' +export * from './kit' + +import {AccountKit} from './kit' + +export default AccountKit diff --git a/src/kit.ts b/src/kit.ts new file mode 100644 index 0000000..738574b --- /dev/null +++ b/src/kit.ts @@ -0,0 +1,42 @@ + +import {APIClient, Name, NameType} from '@wharfkit/antelope' +import {Account} from './account' + +export interface AccountKitArgs { + client: APIClient +} + +export class AccountKit { + readonly client: APIClient + + constructor(args: AccountKitArgs) { + if (args.client) { + this.client = args.client + } else { + throw new Error('A `client` must be passed when initializing the AccountKit.') + } + } + + /** + * Load an Account by name from an API endpoint + * + * @param account The name of the account to load + * @returns + */ + async load(accountName: NameType): Promise { + const account = Name.from(accountName) + + let accountData + + try { + accountData = await this.client.v1.chain.get_account(account) + } catch (error) { + throw new Error(`Account ${account} does not exist`) + } + + return new Account({ + accountData: accountData, + client: this.client, + }) + } +} \ No newline at end of file diff --git a/src/permissions.ts b/src/permission.ts similarity index 96% rename from src/permissions.ts rename to src/permission.ts index 2b501c9..3b708e5 100644 --- a/src/permissions.ts +++ b/src/permission.ts @@ -1,4 +1,5 @@ import { + API, Authority, AuthorityType, KeyWeight, @@ -9,11 +10,10 @@ import { PublicKeyType, UInt32Type, WaitWeight, -} from '@greymass/eosio' -import {API} from '@greymass/eosio' +} from '@wharfkit/antelope' -import type {Account} from './accounts' import type {Session} from '@wharfkit/session' +import type {Account} from './account' export type PermissionParams = | {permissionName: NameType; accountData: API.v1.AccountObject} @@ -24,7 +24,7 @@ export interface PermissionData { parent: NameType permission: NameType auth: AuthorityType | Authority - authorized_by?: NameType + authorized_by: NameType } export interface ActionParam { @@ -41,7 +41,8 @@ export interface ActionData { account: NameType parent: NameType permission: NameType - auth: AuthorityType + auth: Authority + authorized_by: NameType } export function instanceOfPermissionData(object: any): object is PermissionData { @@ -80,6 +81,7 @@ export class Permission { parent: permissionObject.parent, permission: permissionObject.perm_name, auth: Authority.from(permissionObject.required_auth), + authorized_by: "............1", }) } @@ -90,7 +92,7 @@ export class Permission { get actionData(): ActionData { return { ...this.permission_data, - auth: { + auth: Authority.from({ keys: this.permission_data.auth?.keys?.map(({key, weight}) => { return { key: String(key), @@ -109,7 +111,7 @@ export class Permission { weight: Number(weight), })), threshold: Number(this.permission_data.auth?.threshold), - }, + }), } } diff --git a/src/tmp/contract.ts b/src/tmp/contract.ts deleted file mode 100644 index d9e7a22..0000000 --- a/src/tmp/contract.ts +++ /dev/null @@ -1,107 +0,0 @@ -import { - ABISerializableObject, - Action, - AnyAction, - Checksum256, - Name, - NameType, - PermissionLevel, - PrivateKey, -} from '@greymass/eosio' - -import {Session, TransactArgs, TransactResult, WalletPluginPrivateKey} from '@wharfkit/session' - -// TODO: move this to core -export function isABISerializableObject(value: any): value is ABISerializableObject { - return value.constructor && typeof value.constructor.abiName === 'string' -} - -function mockFetch(data) { - return Promise.resolve({ - json: () => Promise.resolve(data), - text: () => Promise.resolve(JSON.stringify(data)), - }) -} - -// TODO: Remove this mock session once a real one exists -const mockSession = new Session({ - broadcast: false, // Disable broadcasting by default for tests, enable when required. - chain: { - id: '73e4385a2708e6d7048834fbc1079f2fabb17b3c125b146af438971e90716c4d', - url: 'https://jungle4.greymass.com', - }, - permissionLevel: PermissionLevel.from('foo@active'), - walletPlugin: new WalletPluginPrivateKey({ - privateKey: PrivateKey.from('5Jtoxgny5tT7NiNFp1MLogviuPJ9NniWjnU4wKzaX4t7pL4kJ8s'), - }), - fetch: mockFetch, -}) - -export class Contract { - /** Account where contract is deployed. */ - static account: Name - - private static _shared: Contract | null = null - private static _session: Session | null = null - - /** Shared instance of the contract. */ - static shared(this: T): InstanceType { - const self = this as unknown as typeof Contract - if (!self._shared) { - self._shared = new self() - } - return self._shared as InstanceType - } - - /** Account where contract is deployed. */ - get account() { - return (this.constructor as typeof Contract).account - } - - /** Call a contract action. */ - async call(name: NameType, data: ABISerializableObject | {[key: string]: any}) { - let action: Action - if (isABISerializableObject(data)) { - action = Action.from({ - account: this.account, - name, - authorization: [], - data, - }) - - return mockSession.transact( - { - action, - }, - {broadcast: false} - ) - } else { - // TODO: here we need to fetch the ABI and construct the action - throw new Error('Not implemented') - } - // TODO: resolve session and transact - throw new Error('Not implemented') - } - - /** Generate a contract action. */ - - async getAction( - name: NameType, - data: ABISerializableObject | {[key: string]: any} - ): Promise { - let action: Action - if (isABISerializableObject(data)) { - action = Action.from({ - account: this.account, - name, - authorization: [], - data, - }) - } else { - // TODO: here we need to fetch the ABI and construct the action - throw new Error('Not implemented') - } - // TODO: resolve session and transact - throw new Error('Not implemented') - } -} diff --git a/test/accounts.ts b/test/account.ts similarity index 97% rename from test/accounts.ts rename to test/account.ts index de079a9..b92d498 100644 --- a/test/accounts.ts +++ b/test/account.ts @@ -1,8 +1,8 @@ import {assert} from 'chai' import {API, APIClient, Asset, Checksum256, Name} from '@greymass/eosio' -import {Account} from '../src/accounts' -import {Permission} from '../src/permissions' +import {Account} from '../src/account' +import {Permission} from '../src/permission' import {MockProvider} from './utils/mock-provider' const eosApiClient = new APIClient({ @@ -14,7 +14,7 @@ const chainId = Checksum256.from('aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119f suite('accounts', function () { suite('Account', function () { test('construct', function () { - const account = new Account(Name.from('teamgreymass'), chainId, eosApiClient) + const account = new Account() assert.instanceOf(account, Account) }) diff --git a/test/data/account_data/teamgreymass.json b/test/data/account_data/teamgreymass.json new file mode 100644 index 0000000..a81d9a7 --- /dev/null +++ b/test/data/account_data/teamgreymass.json @@ -0,0 +1,259 @@ +{ + "account_name": "teamgreymass", + "head_block_num": 285149732, + "head_block_time": "2022-12-23T00:12:29.000", + "privileged": false, + "last_code_update": "1970-01-01T00:00:00.000", + "created": "2018-06-10T13:04:15.000", + "core_liquid_balance": "20853.0388 EOS", + "ram_quota": 67988, + "net_weight": 4503864, + "cpu_weight": "11797752803", + "net_limit": { + "used": 219778, + "available": 8253324, + "max": 8473102 + }, + "cpu_limit": { + "used": 826079, + "available": 236250, + "max": 1062329 + }, + "ram_usage": 17086, + "permissions": [ + { + "perm_name": "active", + "parent": "owner", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6gqJ7sdPgjHLFLtks9cRPs5qYHa9U3CwK4P2JasTLWKQ9kXZK1", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [] + }, + { + "perm_name": "claim", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6DLD9HxMcwn73U41jjdGsNe9vDFRKB26um6qTAqrtYcJFtED4C", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "eosio", + "action": "claimrewards" + } + ] + }, + { + "perm_name": "decentium", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS7knG7M5TUEdRv1bkVjTPddVoDQnwS7oEZXAgFk3A4hhocA3eJf", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "decentiumorg" + } + ] + }, + { + "perm_name": "killswitch", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS7CjC7GL71msPzAuAzd2WwiBEAzTcPL47ACrjSuiNmnnGGufYSn", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "eosio", + "action": "unregprod" + } + ] + }, + { + "perm_name": "oracle", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS88VqmDmJJ9S23eNqdeWYf2zySxv3ckQrWBKy7EvVRCUuhSU4f3", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "delphioracle", + "action": "write" + } + ] + }, + { + "perm_name": "owner", + "parent": "", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS8QzGtCea2thiqcTVeXGdyRZpdKYptQznbcWSMj73FD5RgwKN82", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [] + }, + { + "perm_name": "producerjson", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS5JCEciUdfXnQmTyj85T98bXTAZZ1g7Nmajseu7ZWB8DrDa6Etp", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "producerjson", + "action": "set" + } + ] + }, + { + "perm_name": "transfer", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6AkZZ5YZ6G5eCQGJBAPbkmouEaiSKFkdM289wEMKcf2rnx7mrb", + "weight": 1 + }, + { + "key": "EOS6RWZ1CmDL4B6LdixuertnzxcRuUDac3NQspJEvMnebGcUwhvfX", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "eosio.token", + "action": "transfer" + } + ] + }, + { + "perm_name": "vote", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS65NrHPVXaV4voxepQREmYCmnMJm4tAWdxPaK46CbUN1rrVmRzg", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "eosio", + "action": "voteproducer" + } + ] + }, + { + "perm_name": "voting", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS7pn6P5FftyNAKRfx9VcUzBFMvC4UitNbnoKbfxNe8SShELo2it", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "eosio.forum", + "action": "vote" + }, + { + "account": "eosio.forum", + "action": "unvote" + } + ] + } + ], + "total_resources": { + "owner": "teamgreymass", + "net_weight": "450.3864 EOS", + "cpu_weight": "1179775.2803 EOS", + "ram_bytes": 66588 + }, + "self_delegated_bandwidth": null, + "refund_request": null, + "voter_info": { + "owner": "teamgreymass", + "proxy": "greymassvote", + "producers": [], + "staked": 100202, + "last_vote_weight": "697460718699.94543457031250000", + "proxied_vote_weight": "0.00000000000000000", + "is_proxy": 0, + "flags1": 0, + "reserved2": 0, + "reserved3": "0.0000 EOS" + }, + "rex_info": null, + "subjective_cpu_bill_limit": { + "used": 0, + "available": 0, + "max": 0 + }, + "eosio_any_linked_actions": [] +} \ No newline at end of file diff --git a/test/permissions.ts b/test/permissions.ts index 51644ec..3d8c196 100644 --- a/test/permissions.ts +++ b/test/permissions.ts @@ -1,7 +1,7 @@ import {assert} from 'chai' import {Authority, Name} from '@greymass/eosio' -import {Permission} from '../src/permissions' +import {Permission} from '../src/permission' const authorityExample = { threshold: 1, diff --git a/yarn.lock b/yarn.lock index 4a119ae..69f2a9e 100644 --- a/yarn.lock +++ b/yarn.lock @@ -533,6 +533,37 @@ "@typescript-eslint/types" "5.49.0" eslint-visitor-keys "^3.3.0" +"@wharfkit/abicache@^1.1.1": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@wharfkit/abicache/-/abicache-1.1.1.tgz#03624d03d9466e7def278786aaf074d274fc5650" + integrity sha512-CfpHzCLxFATcfReqdJDUxEDSHIeBF3jFx0cP8RcTDyhC2jX4cd+Q/wqjw/kCni3xrBM7cIGUp9c9NZdvdTK9Cg== + dependencies: + "@wharfkit/antelope" "^0.7.3" + "@wharfkit/signing-request" "^3.0.0" + pako "^2.0.4" + tslib "^2.1.0" + +"@wharfkit/antelope@^0.7.3": + version "0.7.3" + resolved "https://registry.yarnpkg.com/@wharfkit/antelope/-/antelope-0.7.3.tgz#408f6c587f4f5990d4b55596c10be2e976798641" + integrity sha512-pyUmuXUpLQh1RVpJVIcbVUHTwV/DQ+MI0nlfWDBHIICdYf6XidZtQmaHB7JEXiFzlS8T7S9Xc5VOTOQU8dnl3Q== + dependencies: + bn.js "^4.11.9" + brorand "^1.1.0" + elliptic "^6.5.4" + hash.js "^1.0.0" + tslib "^2.0.3" + +"@wharfkit/contract@0.4.2": + version "0.4.2" + resolved "https://registry.yarnpkg.com/@wharfkit/contract/-/contract-0.4.2.tgz#cec2ca9585bf1c63b9458089cbd0388b727b800f" + integrity sha512-jSnxaaIy8ZyXljfO2DrR7ytG7VFZX6ml8b6tncZE7GvkPpEt3zEfR3YJmUfYCvbwJTn5Zk6/EWtIl5YTrEaxOA== + dependencies: + "@wharfkit/abicache" "^1.1.1" + "@wharfkit/antelope" "^0.7.3" + "@wharfkit/signing-request" "^3.0.0" + tslib "^2.1.0" + "@wharfkit/session@^0.2.0": version "0.2.0" resolved "https://registry.yarnpkg.com/@wharfkit/session/-/session-0.2.0.tgz#2293dc2582f003292c419152a64735c1f6a6e455" @@ -543,6 +574,14 @@ pako "^2.0.4" tslib "^2.1.0" +"@wharfkit/signing-request@^3.0.0": + version "3.0.0" + resolved "https://registry.yarnpkg.com/@wharfkit/signing-request/-/signing-request-3.0.0.tgz#3464cdc76c0690ab241d805116101e3ed63ba846" + integrity sha512-+9UaznhYlZSgdZGG/LF5GkH7P9dCVh+b32cR1PYHKG6KuOsPlLqfv1DuWkqsxQyi3kGT1fXG1i8sl39ItgwLzg== + dependencies: + "@wharfkit/antelope" "^0.7.3" + tslib "^2.0.3" + acorn-jsx@^5.3.2: version "5.3.2" resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937" From 399a913bd855180d43b98952efacae21dd04314f Mon Sep 17 00:00:00 2001 From: dafuga Date: Wed, 30 Aug 2023 21:37:02 -0700 Subject: [PATCH 02/10] chore: adjusted unit test --- src/account.ts | 25 +- src/permission.ts | 44 +- test/account.ts | 248 ++-- ...1da8f80bbe7dabe0df2e6b0fc52b366a9b1f6.json | 16 - ...d475cb302bf300d91e7d08ea5735d5d4e57dd.json | 31 - ...1c245a5d42af12f5b988ea258c5e46257bd33.json | 31 - ...bfb5d12c7491faabd3d5487c2e048e69f35aa.json | 6 +- ...456242556fa9312c31f04a68796be5801aba6.json | 31 - ...5e40a973fe2860ad803d3c20a76541d3b9392.json | 50 +- test/data/account_data/teamgreymass.json | 259 ----- ...1e7695d5c028152f877e9d67b3b8a570ed634.json | 32 - ...8c2bd04287275a7b872877c4a07bba57a701b.json | 16 - ...d9d71a7787aac0e342e10f4be8f132415095f.json | 2 +- ...cc893613f746d952457e3586da99c7a92b18b.json | 31 - ...1788b4346c10216d7d62b8e73982725769867.json | 31 - ...17d312f52e009a605e668a07af7b68f5c8fdd.json | 2 +- ...6e7528200581cc18d9d6586cac3b8e09b7663.json | 8 +- test/mock-data.ts | 34 +- test/permissions.ts | 180 +-- test/utils/helpers.ts | 3 + yarn.lock | 1022 +++++++++-------- 21 files changed, 779 insertions(+), 1323 deletions(-) delete mode 100644 test/data/0231da8f80bbe7dabe0df2e6b0fc52b366a9b1f6.json delete mode 100644 test/data/064d475cb302bf300d91e7d08ea5735d5d4e57dd.json delete mode 100644 test/data/1481c245a5d42af12f5b988ea258c5e46257bd33.json delete mode 100644 test/data/6a7456242556fa9312c31f04a68796be5801aba6.json delete mode 100644 test/data/account_data/teamgreymass.json delete mode 100644 test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json delete mode 100644 test/data/c318c2bd04287275a7b872877c4a07bba57a701b.json delete mode 100644 test/data/ca8cc893613f746d952457e3586da99c7a92b18b.json delete mode 100644 test/data/d891788b4346c10216d7d62b8e73982725769867.json create mode 100644 test/utils/helpers.ts diff --git a/src/account.ts b/src/account.ts index c61e578..8fcf175 100644 --- a/src/account.ts +++ b/src/account.ts @@ -4,8 +4,7 @@ import { APIClient, Asset, AssetType, - Checksum256, - Checksum256Type, + Authority, Name, NameType, } from '@wharfkit/antelope' @@ -38,12 +37,28 @@ export class Account { this.client = client } - get accountName(): NameType { - return String(this.account_data.account_name) + get accountName() { + return Name.from(this.account_data.account_name) } getPermission(permissionName: NameType): Permission { - return Permission.from({permissionName, accountData: this.account_data}) + const permissionObject = this.account_data.permissions.find( + (permission) => permission.perm_name.equals(permissionName) + ) + + if (!permissionObject) { + throw new Error( + `Permission ${permissionName} does not exist on account ${this.accountName}.` + ) + } + + return new Permission(permissionName, { + account: this.accountName, + parent: permissionObject.parent, + permission: permissionObject.perm_name, + auth: Authority.from(permissionObject.required_auth), + authorized_by: "............1", + }) } updatePermission(permission: Permission): Action { diff --git a/src/permission.ts b/src/permission.ts index 3b708e5..b737d9f 100644 --- a/src/permission.ts +++ b/src/permission.ts @@ -15,10 +15,6 @@ import { import type {Session} from '@wharfkit/session' import type {Account} from './account' -export type PermissionParams = - | {permissionName: NameType; accountData: API.v1.AccountObject} - | PermissionData - export interface PermissionData { account: NameType parent: NameType @@ -27,11 +23,6 @@ export interface PermissionData { authorized_by: NameType } -export interface ActionParam { - session: Session - account: Account -} - export interface AddKeyActionParam { permission: Permission key: string @@ -45,46 +36,15 @@ export interface ActionData { authorized_by: NameType } -export function instanceOfPermissionData(object: any): object is PermissionData { - return 'account' in object -} - export class Permission { permission_name: Name permission_data: PermissionData - constructor(permissionName: Name, permissionData: PermissionData) { - this.permission_name = permissionName + constructor(permissionName: NameType, permissionData: PermissionData) { + this.permission_name = Name.from(permissionName) this.permission_data = permissionData } - static from(permissionParams: PermissionParams): Permission { - if (instanceOfPermissionData(permissionParams)) { - return new Permission(Name.from(permissionParams.permission), { - ...permissionParams, - auth: Authority.from(permissionParams.auth), - }) - } - - const {permissionName, accountData} = permissionParams - - const permissionObject = accountData.getPermission(permissionName) - - if (!permissionObject) { - throw new Error( - `Permission ${permissionName} does not exist on account ${accountData.account_name}` - ) - } - - return new Permission(Name.from(permissionName), { - account: accountData.account_name, - parent: permissionObject.parent, - permission: permissionObject.perm_name, - auth: Authority.from(permissionObject.required_auth), - authorized_by: "............1", - }) - } - get permissionName(): Name { return this.permission_name } diff --git a/test/account.ts b/test/account.ts index b92d498..44aac5f 100644 --- a/test/account.ts +++ b/test/account.ts @@ -1,193 +1,115 @@ import {assert} from 'chai' -import {API, APIClient, Asset, Checksum256, Name} from '@greymass/eosio' +import {API, APIClient} from '@wharfkit/antelope' import {Account} from '../src/account' +import {AccountKit} from '../src/kit' import {Permission} from '../src/permission' import {MockProvider} from './utils/mock-provider' +import {deserializedMockAccountObject} from './mock-data' const eosApiClient = new APIClient({ provider: new MockProvider('https://eos.greymass.com'), }) -const chainId = Checksum256.from('aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119ffbeaef943642f0e906') +suite('Account', function () { + let testAccount: Account -suite('accounts', function () { - suite('Account', function () { - test('construct', function () { - const account = new Account() - - assert.instanceOf(account, Account) - }) - test('from', function () { - assert.instanceOf(testAccount(), Account) - }) - test('accountName', function () { - assert(testAccount().accountName.equals('teamgreymass')) - }) - test('chainId', function () { - assert.equal(testAccount().chainId, chainId) - }) - - suite('getAccountData', function () { - this.slow(200) - this.timeout(5 * 1000) - - test('returns account data', async function () { - const account = testAccount() + this.beforeAll(async function () { + testAccount = await (new AccountKit({client: eosApiClient})).load('teamgreymass') + }) - assert.instanceOf(await account.getAccountData(), API.v1.AccountObject) - }) + test('construct', function () { + const account = new Account({ client: eosApiClient, accountData: deserializedMockAccountObject}) - test('throws error when account does not exist', function (done) { - const account = nonExistentTestAccount() + assert.instanceOf(account, Account) + }) + test('accountName', function () { + assert.isTrue(testAccount.accountName.equals('teamgreymass')) + }) - account.getAccountData().catch((error) => { - assert((error as Error).message, 'Account does not exist') - done() - }) - }) + suite('account_data', function () { + test('returns account data', async function () { + assert.instanceOf(testAccount.account_data, API.v1.AccountObject) }) + }) - suite('getPermission', function () { - this.slow(200) - this.timeout(5 * 1000) + suite('getPermission', function () { + test('returns permission object', async function () { + assert.instanceOf(testAccount.getPermission('active'), Permission) + }) - test('returns permission object', async function () { - const account = testAccount() + test('throws error when permission does not exist', function () { + try { + testAccount.getPermission('nonexistent') + assert.fail() + } catch (error) { + assert.equal( + (error as Error).message, + 'Permission nonexistent does not exist on account teamgreymass.' + ) + } + }) + }) - assert.instanceOf(await account.getPermission('active'), Permission) + suite('getResources', function () { + this.slow(200) + this.timeout(5 * 1000) + + test('returns resources data', async function () { + assert.deepEqual(testAccount.getResources(), { + cpu_available: 400021, + cpu_used: 1018013, + net_available: 8225481, + net_used: 8225481, + ram_quota: 67988, + ram_usage: 18101, }) + }) + }) - test('throws error when account does not exist', function (done) { - const account = nonExistentTestAccount() - - account - .getPermission('active') - .catch((error) => { - assert.equal( - (error as Error).message, - 'Account nonexistent does not exist.' - ) - done() - }) - .then(() => { - assert.fail() - }) - }) + suite('getBalance', function () { + this.slow(200) + this.timeout(5 * 1000) - test('throws error when permission does not exist', function (done) { - const account = testAccount() - - account - .getPermission('nonexistent') - .catch((error) => { - assert.equal( - (error as Error).message, - 'Unknown permission nonexistent on account teamgreymass.' - ) - done() - }) - .then(() => { - assert.fail() - }) - }) + test('returns resources object for system token', async function () { + assert.equal(String(await testAccount.getBalance()), '4968.2348 EOS') }) - suite('getResources', function () { - this.slow(200) - this.timeout(5 * 1000) - - test('returns resources data', async function () { - const account = testAccount() + test('returns resources object for secondary token', async function () { + assert.equal( + String(await testAccount.getBalance('bingobetoken', 'BINGO')), + '1000.0000 BINGO' + ) + }) - assert.deepEqual(await account.getResources(), { - cpu_available: 236250, - cpu_used: 826079, - net_available: 8253324, - net_used: 8253324, - ram_quota: 67988, - ram_usage: 17086, + test('throws error when token does not exist for given contract', function (done) { + testAccount + .getBalance('eosio.token', 'nonexist') + .catch((error) => { + assert.equal( + (error as Error).message, + 'No balance found for nonexist token of eosio.token contract.' + ) + done() + }) + .then((data) => { + assert.fail() }) - }) - - test('throws error when account does not exist', function (done) { - const account = nonExistentTestAccount() - - account - .getResources() - .catch((error) => { - assert.equal( - (error as Error).message, - 'Account nonexistent does not exist.' - ) - done() - }) - .then(() => { - assert.fail() - }) - }) }) - suite('getBalance', function () { - this.slow(200) - this.timeout(5 * 1000) - - test('returns resources object for system token', async function () { - const account = testAccount() - - assert.equal(String(await account.getBalance()), '20853.0388 EOS') - }) - - test('returns resources object for secondary token', async function () { - const account = testAccount() - - assert.equal( - String(await account.getBalance('bingobetoken', 'BINGO')), - '1000.0000 BINGO' - ) - }) - - test('throws error when token does not exist for given contract', function (done) { - const account = testAccount() - - account - .getBalance('eosio.token', 'nonexist') - .catch((error) => { - assert.equal( - (error as Error).message, - 'No balance found for nonexist token of eosio.token contract.' - ) - done() - }) - .then((data) => { - assert.fail() - }) - }) - - test('throws error when token contract does not exist', function (done) { - const account = testAccount() - - account - .getBalance('nonexist') - .catch((error) => { - assert.equal( - (error as Error).message, - 'Token contract nonexist does not exist.' - ) - done() - }) - .then(() => { - assert.fail() - }) - }) + test('throws error when token contract does not exist', function (done) { + testAccount + .getBalance('nonexist') + .catch((error) => { + assert.equal( + (error as Error).message, + 'Token contract nonexist does not exist.' + ) + done() + }) + .then(() => { + assert.fail() + }) }) }) }) - -function testAccount() { - return Account.from('teamgreymass', chainId, eosApiClient) -} - -function nonExistentTestAccount() { - return Account.from('nonexistent', chainId, eosApiClient) -} diff --git a/test/data/0231da8f80bbe7dabe0df2e6b0fc52b366a9b1f6.json b/test/data/0231da8f80bbe7dabe0df2e6b0fc52b366a9b1f6.json deleted file mode 100644 index e2d985a..0000000 --- a/test/data/0231da8f80bbe7dabe0df2e6b0fc52b366a9b1f6.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "2", - "content-type": "application/json", - "date": "Fri, 23 Dec 2022 00:29:15 GMT", - "host": "eos.greymass.com", - "server": "nginx" - }, - "status": 200, - "json": [], - "text": "[]" -} \ No newline at end of file diff --git a/test/data/064d475cb302bf300d91e7d08ea5735d5d4e57dd.json b/test/data/064d475cb302bf300d91e7d08ea5735d5d4e57dd.json deleted file mode 100644 index c4550f9..0000000 --- a/test/data/064d475cb302bf300d91e7d08ea5735d5d4e57dd.json +++ /dev/null @@ -1,31 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "262", - "content-type": "application/json", - "date": "Fri, 23 Dec 2022 00:29:16 GMT", - "server": "nginx" - }, - "status": 500, - "json": { - "code": 500, - "message": "Internal Service Error", - "error": { - "code": 3060002, - "name": "account_query_exception", - "what": "Account Query Exception", - "details": [ - { - "message": "Fail to retrieve account for rndm", - "file": "chain_plugin.cpp", - "line_number": 1664, - "method": "get_abi" - } - ] - } - }, - "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":3060002,\"name\":\"account_query_exception\",\"what\":\"Account Query Exception\",\"details\":[{\"message\":\"Fail to retrieve account for rndm\",\"file\":\"chain_plugin.cpp\",\"line_number\":1664,\"method\":\"get_abi\"}]}}" -} \ No newline at end of file diff --git a/test/data/1481c245a5d42af12f5b988ea258c5e46257bd33.json b/test/data/1481c245a5d42af12f5b988ea258c5e46257bd33.json deleted file mode 100644 index 7b59ce3..0000000 --- a/test/data/1481c245a5d42af12f5b988ea258c5e46257bd33.json +++ /dev/null @@ -1,31 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "292", - "content-type": "application/json", - "date": "Fri, 23 Dec 2022 00:12:29 GMT", - "server": "nginx" - }, - "status": 500, - "json": { - "code": 500, - "message": "Internal Service Error", - "error": { - "code": 3060003, - "name": "contract_table_query_exception", - "what": "Contract Table Query Exception", - "details": [ - { - "message": "Table accounts is not specified in the ABI", - "file": "chain_plugin.cpp", - "line_number": 1676, - "method": "get_table_type" - } - ] - } - }, - "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":3060003,\"name\":\"contract_table_query_exception\",\"what\":\"Contract Table Query Exception\",\"details\":[{\"message\":\"Table accounts is not specified in the ABI\",\"file\":\"chain_plugin.cpp\",\"line_number\":1676,\"method\":\"get_table_type\"}]}}" -} \ No newline at end of file diff --git a/test/data/2e1bfb5d12c7491faabd3d5487c2e048e69f35aa.json b/test/data/2e1bfb5d12c7491faabd3d5487c2e048e69f35aa.json index 6202418..760e902 100644 --- a/test/data/2e1bfb5d12c7491faabd3d5487c2e048e69f35aa.json +++ b/test/data/2e1bfb5d12c7491faabd3d5487c2e048e69f35aa.json @@ -6,7 +6,7 @@ "connection": "close", "content-length": "266", "content-type": "application/json", - "date": "Fri, 23 Dec 2022 01:23:41 GMT", + "date": "Thu, 31 Aug 2023 05:54:25 GMT", "server": "nginx" }, "status": 500, @@ -21,11 +21,11 @@ { "message": "Fail to retrieve account for nonexist", "file": "chain_plugin.cpp", - "line_number": 1664, + "line_number": 1695, "method": "get_abi" } ] } }, - "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":3060002,\"name\":\"account_query_exception\",\"what\":\"Account Query Exception\",\"details\":[{\"message\":\"Fail to retrieve account for nonexist\",\"file\":\"chain_plugin.cpp\",\"line_number\":1664,\"method\":\"get_abi\"}]}}" + "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":3060002,\"name\":\"account_query_exception\",\"what\":\"Account Query Exception\",\"details\":[{\"message\":\"Fail to retrieve account for nonexist\",\"file\":\"chain_plugin.cpp\",\"line_number\":1695,\"method\":\"get_abi\"}]}}" } \ No newline at end of file diff --git a/test/data/6a7456242556fa9312c31f04a68796be5801aba6.json b/test/data/6a7456242556fa9312c31f04a68796be5801aba6.json deleted file mode 100644 index 35a6675..0000000 --- a/test/data/6a7456242556fa9312c31f04a68796be5801aba6.json +++ /dev/null @@ -1,31 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "262", - "content-type": "application/json", - "date": "Fri, 23 Dec 2022 00:12:30 GMT", - "server": "nginx" - }, - "status": 500, - "json": { - "code": 500, - "message": "Internal Service Error", - "error": { - "code": 3060002, - "name": "account_query_exception", - "what": "Account Query Exception", - "details": [ - { - "message": "Fail to retrieve account for rndm", - "file": "chain_plugin.cpp", - "line_number": 1664, - "method": "get_abi" - } - ] - } - }, - "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":3060002,\"name\":\"account_query_exception\",\"what\":\"Account Query Exception\",\"details\":[{\"message\":\"Fail to retrieve account for rndm\",\"file\":\"chain_plugin.cpp\",\"line_number\":1664,\"method\":\"get_abi\"}]}}" -} \ No newline at end of file diff --git a/test/data/8745e40a973fe2860ad803d3c20a76541d3b9392.json b/test/data/8745e40a973fe2860ad803d3c20a76541d3b9392.json index d6b0b61..be62b02 100644 --- a/test/data/8745e40a973fe2860ad803d3c20a76541d3b9392.json +++ b/test/data/8745e40a973fe2860ad803d3c20a76541d3b9392.json @@ -4,9 +4,9 @@ "access-control-allow-methods": "GET, POST, OPTIONS", "access-control-allow-origin": "*", "connection": "close", - "content-length": "3462", + "content-length": "3602", "content-type": "application/json", - "date": "Fri, 23 Dec 2022 00:12:29 GMT", + "date": "Thu, 31 Aug 2023 05:54:24 GMT", "host": "eos.greymass.com", "server": "nginx", "x-cached": "EXPIRED" @@ -14,26 +14,30 @@ "status": 200, "json": { "account_name": "teamgreymass", - "head_block_num": 285149732, - "head_block_time": "2022-12-23T00:12:29.000", + "head_block_num": 328546110, + "head_block_time": "2023-08-31T05:54:25.000", "privileged": false, "last_code_update": "1970-01-01T00:00:00.000", "created": "2018-06-10T13:04:15.000", - "core_liquid_balance": "20853.0388 EOS", + "core_liquid_balance": "4968.2348 EOS", "ram_quota": 67988, - "net_weight": 4503864, - "cpu_weight": "11797752803", + "net_weight": 4496537, + "cpu_weight": "15730337072", "net_limit": { - "used": 219778, - "available": 8253324, - "max": 8473102 + "used": 247633, + "available": 8225481, + "max": 8473114, + "last_usage_update_time": "2023-08-31T05:54:00.000", + "current_used": 247561 }, "cpu_limit": { - "used": 826079, - "available": 236250, - "max": 1062329 + "used": 1018013, + "available": 400021, + "max": 1418034, + "last_usage_update_time": "2023-08-31T05:54:00.000", + "current_used": 1017718 }, - "ram_usage": 17086, + "ram_usage": 18101, "permissions": [ { "perm_name": "active", @@ -178,11 +182,7 @@ "threshold": 1, "keys": [ { - "key": "EOS6AkZZ5YZ6G5eCQGJBAPbkmouEaiSKFkdM289wEMKcf2rnx7mrb", - "weight": 1 - }, - { - "key": "EOS6RWZ1CmDL4B6LdixuertnzxcRuUDac3NQspJEvMnebGcUwhvfX", + "key": "EOS7qZ8nnmn6KBnjQL4oukyZFWCj8DmC9nJE2nkAYAZbwgKhMu8cW", "weight": 1 } ], @@ -245,8 +245,8 @@ ], "total_resources": { "owner": "teamgreymass", - "net_weight": "450.3864 EOS", - "cpu_weight": "1179775.2803 EOS", + "net_weight": "449.6537 EOS", + "cpu_weight": "1573033.7072 EOS", "ram_bytes": 66588 }, "self_delegated_bandwidth": null, @@ -256,7 +256,7 @@ "proxy": "greymassvote", "producers": [], "staked": 100202, - "last_vote_weight": "697460718699.94543457031250000", + "last_vote_weight": "863265464502.93908691406250000", "proxied_vote_weight": "0.00000000000000000", "is_proxy": 0, "flags1": 0, @@ -267,9 +267,11 @@ "subjective_cpu_bill_limit": { "used": 0, "available": 0, - "max": 0 + "max": 0, + "last_usage_update_time": "2000-01-01T00:00:00.000", + "current_used": 0 }, "eosio_any_linked_actions": [] }, - "text": "{\"account_name\":\"teamgreymass\",\"head_block_num\":285149732,\"head_block_time\":\"2022-12-23T00:12:29.000\",\"privileged\":false,\"last_code_update\":\"1970-01-01T00:00:00.000\",\"created\":\"2018-06-10T13:04:15.000\",\"core_liquid_balance\":\"20853.0388 EOS\",\"ram_quota\":67988,\"net_weight\":4503864,\"cpu_weight\":\"11797752803\",\"net_limit\":{\"used\":219778,\"available\":8253324,\"max\":8473102},\"cpu_limit\":{\"used\":826079,\"available\":236250,\"max\":1062329},\"ram_usage\":17086,\"permissions\":[{\"perm_name\":\"active\",\"parent\":\"owner\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6gqJ7sdPgjHLFLtks9cRPs5qYHa9U3CwK4P2JasTLWKQ9kXZK1\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"claim\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6DLD9HxMcwn73U41jjdGsNe9vDFRKB26um6qTAqrtYcJFtED4C\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio\",\"action\":\"claimrewards\"}]},{\"perm_name\":\"decentium\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7knG7M5TUEdRv1bkVjTPddVoDQnwS7oEZXAgFk3A4hhocA3eJf\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"decentiumorg\"}]},{\"perm_name\":\"killswitch\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7CjC7GL71msPzAuAzd2WwiBEAzTcPL47ACrjSuiNmnnGGufYSn\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio\",\"action\":\"unregprod\"}]},{\"perm_name\":\"oracle\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS88VqmDmJJ9S23eNqdeWYf2zySxv3ckQrWBKy7EvVRCUuhSU4f3\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"delphioracle\",\"action\":\"write\"}]},{\"perm_name\":\"owner\",\"parent\":\"\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS8QzGtCea2thiqcTVeXGdyRZpdKYptQznbcWSMj73FD5RgwKN82\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"producerjson\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS5JCEciUdfXnQmTyj85T98bXTAZZ1g7Nmajseu7ZWB8DrDa6Etp\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"producerjson\",\"action\":\"set\"}]},{\"perm_name\":\"transfer\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6AkZZ5YZ6G5eCQGJBAPbkmouEaiSKFkdM289wEMKcf2rnx7mrb\",\"weight\":1},{\"key\":\"EOS6RWZ1CmDL4B6LdixuertnzxcRuUDac3NQspJEvMnebGcUwhvfX\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio.token\",\"action\":\"transfer\"}]},{\"perm_name\":\"vote\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS65NrHPVXaV4voxepQREmYCmnMJm4tAWdxPaK46CbUN1rrVmRzg\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio\",\"action\":\"voteproducer\"}]},{\"perm_name\":\"voting\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7pn6P5FftyNAKRfx9VcUzBFMvC4UitNbnoKbfxNe8SShELo2it\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio.forum\",\"action\":\"vote\"},{\"account\":\"eosio.forum\",\"action\":\"unvote\"}]}],\"total_resources\":{\"owner\":\"teamgreymass\",\"net_weight\":\"450.3864 EOS\",\"cpu_weight\":\"1179775.2803 EOS\",\"ram_bytes\":66588},\"self_delegated_bandwidth\":null,\"refund_request\":null,\"voter_info\":{\"owner\":\"teamgreymass\",\"proxy\":\"greymassvote\",\"producers\":[],\"staked\":100202,\"last_vote_weight\":\"697460718699.94543457031250000\",\"proxied_vote_weight\":\"0.00000000000000000\",\"is_proxy\":0,\"flags1\":0,\"reserved2\":0,\"reserved3\":\"0.0000 EOS\"},\"rex_info\":null,\"subjective_cpu_bill_limit\":{\"used\":0,\"available\":0,\"max\":0},\"eosio_any_linked_actions\":[]}" + "text": "{\"account_name\":\"teamgreymass\",\"head_block_num\":328546110,\"head_block_time\":\"2023-08-31T05:54:25.000\",\"privileged\":false,\"last_code_update\":\"1970-01-01T00:00:00.000\",\"created\":\"2018-06-10T13:04:15.000\",\"core_liquid_balance\":\"4968.2348 EOS\",\"ram_quota\":67988,\"net_weight\":4496537,\"cpu_weight\":\"15730337072\",\"net_limit\":{\"used\":247633,\"available\":8225481,\"max\":8473114,\"last_usage_update_time\":\"2023-08-31T05:54:00.000\",\"current_used\":247561},\"cpu_limit\":{\"used\":1018013,\"available\":400021,\"max\":1418034,\"last_usage_update_time\":\"2023-08-31T05:54:00.000\",\"current_used\":1017718},\"ram_usage\":18101,\"permissions\":[{\"perm_name\":\"active\",\"parent\":\"owner\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6gqJ7sdPgjHLFLtks9cRPs5qYHa9U3CwK4P2JasTLWKQ9kXZK1\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"claim\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6DLD9HxMcwn73U41jjdGsNe9vDFRKB26um6qTAqrtYcJFtED4C\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio\",\"action\":\"claimrewards\"}]},{\"perm_name\":\"decentium\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7knG7M5TUEdRv1bkVjTPddVoDQnwS7oEZXAgFk3A4hhocA3eJf\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"decentiumorg\"}]},{\"perm_name\":\"killswitch\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7CjC7GL71msPzAuAzd2WwiBEAzTcPL47ACrjSuiNmnnGGufYSn\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio\",\"action\":\"unregprod\"}]},{\"perm_name\":\"oracle\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS88VqmDmJJ9S23eNqdeWYf2zySxv3ckQrWBKy7EvVRCUuhSU4f3\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"delphioracle\",\"action\":\"write\"}]},{\"perm_name\":\"owner\",\"parent\":\"\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS8QzGtCea2thiqcTVeXGdyRZpdKYptQznbcWSMj73FD5RgwKN82\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"producerjson\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS5JCEciUdfXnQmTyj85T98bXTAZZ1g7Nmajseu7ZWB8DrDa6Etp\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"producerjson\",\"action\":\"set\"}]},{\"perm_name\":\"transfer\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7qZ8nnmn6KBnjQL4oukyZFWCj8DmC9nJE2nkAYAZbwgKhMu8cW\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio.token\",\"action\":\"transfer\"}]},{\"perm_name\":\"vote\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS65NrHPVXaV4voxepQREmYCmnMJm4tAWdxPaK46CbUN1rrVmRzg\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio\",\"action\":\"voteproducer\"}]},{\"perm_name\":\"voting\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7pn6P5FftyNAKRfx9VcUzBFMvC4UitNbnoKbfxNe8SShELo2it\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio.forum\",\"action\":\"vote\"},{\"account\":\"eosio.forum\",\"action\":\"unvote\"}]}],\"total_resources\":{\"owner\":\"teamgreymass\",\"net_weight\":\"449.6537 EOS\",\"cpu_weight\":\"1573033.7072 EOS\",\"ram_bytes\":66588},\"self_delegated_bandwidth\":null,\"refund_request\":null,\"voter_info\":{\"owner\":\"teamgreymass\",\"proxy\":\"greymassvote\",\"producers\":[],\"staked\":100202,\"last_vote_weight\":\"863265464502.93908691406250000\",\"proxied_vote_weight\":\"0.00000000000000000\",\"is_proxy\":0,\"flags1\":0,\"reserved2\":0,\"reserved3\":\"0.0000 EOS\"},\"rex_info\":null,\"subjective_cpu_bill_limit\":{\"used\":0,\"available\":0,\"max\":0,\"last_usage_update_time\":\"2000-01-01T00:00:00.000\",\"current_used\":0},\"eosio_any_linked_actions\":[]}" } \ No newline at end of file diff --git a/test/data/account_data/teamgreymass.json b/test/data/account_data/teamgreymass.json deleted file mode 100644 index a81d9a7..0000000 --- a/test/data/account_data/teamgreymass.json +++ /dev/null @@ -1,259 +0,0 @@ -{ - "account_name": "teamgreymass", - "head_block_num": 285149732, - "head_block_time": "2022-12-23T00:12:29.000", - "privileged": false, - "last_code_update": "1970-01-01T00:00:00.000", - "created": "2018-06-10T13:04:15.000", - "core_liquid_balance": "20853.0388 EOS", - "ram_quota": 67988, - "net_weight": 4503864, - "cpu_weight": "11797752803", - "net_limit": { - "used": 219778, - "available": 8253324, - "max": 8473102 - }, - "cpu_limit": { - "used": 826079, - "available": 236250, - "max": 1062329 - }, - "ram_usage": 17086, - "permissions": [ - { - "perm_name": "active", - "parent": "owner", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS6gqJ7sdPgjHLFLtks9cRPs5qYHa9U3CwK4P2JasTLWKQ9kXZK1", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [] - }, - { - "perm_name": "claim", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS6DLD9HxMcwn73U41jjdGsNe9vDFRKB26um6qTAqrtYcJFtED4C", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio", - "action": "claimrewards" - } - ] - }, - { - "perm_name": "decentium", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS7knG7M5TUEdRv1bkVjTPddVoDQnwS7oEZXAgFk3A4hhocA3eJf", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "decentiumorg" - } - ] - }, - { - "perm_name": "killswitch", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS7CjC7GL71msPzAuAzd2WwiBEAzTcPL47ACrjSuiNmnnGGufYSn", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio", - "action": "unregprod" - } - ] - }, - { - "perm_name": "oracle", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS88VqmDmJJ9S23eNqdeWYf2zySxv3ckQrWBKy7EvVRCUuhSU4f3", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "delphioracle", - "action": "write" - } - ] - }, - { - "perm_name": "owner", - "parent": "", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS8QzGtCea2thiqcTVeXGdyRZpdKYptQznbcWSMj73FD5RgwKN82", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [] - }, - { - "perm_name": "producerjson", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS5JCEciUdfXnQmTyj85T98bXTAZZ1g7Nmajseu7ZWB8DrDa6Etp", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "producerjson", - "action": "set" - } - ] - }, - { - "perm_name": "transfer", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS6AkZZ5YZ6G5eCQGJBAPbkmouEaiSKFkdM289wEMKcf2rnx7mrb", - "weight": 1 - }, - { - "key": "EOS6RWZ1CmDL4B6LdixuertnzxcRuUDac3NQspJEvMnebGcUwhvfX", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio.token", - "action": "transfer" - } - ] - }, - { - "perm_name": "vote", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS65NrHPVXaV4voxepQREmYCmnMJm4tAWdxPaK46CbUN1rrVmRzg", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio", - "action": "voteproducer" - } - ] - }, - { - "perm_name": "voting", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS7pn6P5FftyNAKRfx9VcUzBFMvC4UitNbnoKbfxNe8SShELo2it", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio.forum", - "action": "vote" - }, - { - "account": "eosio.forum", - "action": "unvote" - } - ] - } - ], - "total_resources": { - "owner": "teamgreymass", - "net_weight": "450.3864 EOS", - "cpu_weight": "1179775.2803 EOS", - "ram_bytes": 66588 - }, - "self_delegated_bandwidth": null, - "refund_request": null, - "voter_info": { - "owner": "teamgreymass", - "proxy": "greymassvote", - "producers": [], - "staked": 100202, - "last_vote_weight": "697460718699.94543457031250000", - "proxied_vote_weight": "0.00000000000000000", - "is_proxy": 0, - "flags1": 0, - "reserved2": 0, - "reserved3": "0.0000 EOS" - }, - "rex_info": null, - "subjective_cpu_bill_limit": { - "used": 0, - "available": 0, - "max": 0 - }, - "eosio_any_linked_actions": [] -} \ No newline at end of file diff --git a/test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json b/test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json deleted file mode 100644 index d88848b..0000000 --- a/test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json +++ /dev/null @@ -1,32 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "489", - "content-type": "application/json", - "date": "Fri, 23 Dec 2022 00:12:29 GMT", - "server": "nginx", - "x-cached": "EXPIRED" - }, - "status": 500, - "json": { - "code": 500, - "message": "Internal Service Error", - "error": { - "code": 0, - "name": "exception", - "what": "unspecified", - "details": [ - { - "message": "unknown key (boost::tuples::tuple): (0 nonexistent)", - "file": "http_plugin.cpp", - "line_number": 947, - "method": "handle_exception" - } - ] - } - }, - "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":0,\"name\":\"exception\",\"what\":\"unspecified\",\"details\":[{\"message\":\"unknown key (boost::tuples::tuple): (0 nonexistent)\",\"file\":\"http_plugin.cpp\",\"line_number\":947,\"method\":\"handle_exception\"}]}}" -} \ No newline at end of file diff --git a/test/data/c318c2bd04287275a7b872877c4a07bba57a701b.json b/test/data/c318c2bd04287275a7b872877c4a07bba57a701b.json deleted file mode 100644 index 58d289d..0000000 --- a/test/data/c318c2bd04287275a7b872877c4a07bba57a701b.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "2", - "content-type": "application/json", - "date": "Fri, 23 Dec 2022 00:32:32 GMT", - "host": "eos.greymass.com", - "server": "nginx" - }, - "status": 200, - "json": [], - "text": "[]" -} \ No newline at end of file diff --git a/test/data/c53d9d71a7787aac0e342e10f4be8f132415095f.json b/test/data/c53d9d71a7787aac0e342e10f4be8f132415095f.json index 8086944..63282cd 100644 --- a/test/data/c53d9d71a7787aac0e342e10f4be8f132415095f.json +++ b/test/data/c53d9d71a7787aac0e342e10f4be8f132415095f.json @@ -6,7 +6,7 @@ "connection": "close", "content-length": "19", "content-type": "application/json", - "date": "Fri, 23 Dec 2022 01:04:27 GMT", + "date": "Thu, 31 Aug 2023 05:54:25 GMT", "host": "eos.greymass.com", "server": "nginx" }, diff --git a/test/data/ca8cc893613f746d952457e3586da99c7a92b18b.json b/test/data/ca8cc893613f746d952457e3586da99c7a92b18b.json deleted file mode 100644 index 48b150d..0000000 --- a/test/data/ca8cc893613f746d952457e3586da99c7a92b18b.json +++ /dev/null @@ -1,31 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "292", - "content-type": "application/json", - "date": "Fri, 23 Dec 2022 00:29:16 GMT", - "server": "nginx" - }, - "status": 500, - "json": { - "code": 500, - "message": "Internal Service Error", - "error": { - "code": 3060003, - "name": "contract_table_query_exception", - "what": "Contract Table Query Exception", - "details": [ - { - "message": "Table accounts is not specified in the ABI", - "file": "chain_plugin.cpp", - "line_number": 1676, - "method": "get_table_type" - } - ] - } - }, - "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":3060003,\"name\":\"contract_table_query_exception\",\"what\":\"Contract Table Query Exception\",\"details\":[{\"message\":\"Table accounts is not specified in the ABI\",\"file\":\"chain_plugin.cpp\",\"line_number\":1676,\"method\":\"get_table_type\"}]}}" -} \ No newline at end of file diff --git a/test/data/d891788b4346c10216d7d62b8e73982725769867.json b/test/data/d891788b4346c10216d7d62b8e73982725769867.json deleted file mode 100644 index fb64105..0000000 --- a/test/data/d891788b4346c10216d7d62b8e73982725769867.json +++ /dev/null @@ -1,31 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "269", - "content-type": "application/json", - "date": "Fri, 23 Dec 2022 01:09:01 GMT", - "server": "nginx" - }, - "status": 500, - "json": { - "code": 500, - "message": "Internal Service Error", - "error": { - "code": 3060002, - "name": "account_query_exception", - "what": "Account Query Exception", - "details": [ - { - "message": "Fail to retrieve account for nonexistent", - "file": "chain_plugin.cpp", - "line_number": 1664, - "method": "get_abi" - } - ] - } - }, - "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":3060002,\"name\":\"account_query_exception\",\"what\":\"Account Query Exception\",\"details\":[{\"message\":\"Fail to retrieve account for nonexistent\",\"file\":\"chain_plugin.cpp\",\"line_number\":1664,\"method\":\"get_abi\"}]}}" -} \ No newline at end of file diff --git a/test/data/de917d312f52e009a605e668a07af7b68f5c8fdd.json b/test/data/de917d312f52e009a605e668a07af7b68f5c8fdd.json index 52f730a..7c0b7ae 100644 --- a/test/data/de917d312f52e009a605e668a07af7b68f5c8fdd.json +++ b/test/data/de917d312f52e009a605e668a07af7b68f5c8fdd.json @@ -6,7 +6,7 @@ "connection": "close", "content-length": "2", "content-type": "application/json", - "date": "Fri, 23 Dec 2022 01:26:32 GMT", + "date": "Thu, 31 Aug 2023 05:54:25 GMT", "host": "eos.greymass.com", "server": "nginx" }, diff --git a/test/data/dfd6e7528200581cc18d9d6586cac3b8e09b7663.json b/test/data/dfd6e7528200581cc18d9d6586cac3b8e09b7663.json index b7a6d90..5f7af26 100644 --- a/test/data/dfd6e7528200581cc18d9d6586cac3b8e09b7663.json +++ b/test/data/dfd6e7528200581cc18d9d6586cac3b8e09b7663.json @@ -4,15 +4,15 @@ "access-control-allow-methods": "GET, POST, OPTIONS", "access-control-allow-origin": "*", "connection": "close", - "content-length": "18", + "content-length": "17", "content-type": "application/json", - "date": "Fri, 23 Dec 2022 00:48:25 GMT", + "date": "Thu, 31 Aug 2023 05:54:25 GMT", "host": "eos.greymass.com", "server": "nginx" }, "status": 200, "json": [ - "20853.0388 EOS" + "4968.2348 EOS" ], - "text": "[\"20853.0388 EOS\"]" + "text": "[\"4968.2348 EOS\"]" } \ No newline at end of file diff --git a/test/mock-data.ts b/test/mock-data.ts index 30c8f4b..5846496 100644 --- a/test/mock-data.ts +++ b/test/mock-data.ts @@ -1,9 +1,10 @@ -import {API, Asset, Int64, Name, TimePoint, UInt32, UInt64} from '@greymass/eosio' +import {API, Asset, Name, TimePoint, UInt32, UInt64} from '@greymass/eosio' +import { deserialize } from './utils/helpers' -const mockAccountObject = API.v1.AccountObject.from({ - cpu_weight: UInt64.from(333), - net_weight: UInt64.from(222), - ram_quota: UInt64.from(111), +export const mockAccountObject = API.v1.AccountObject.from({ + cpu_weight: UInt64.from(236250), + net_weight: UInt64.from(8253324), + ram_quota: UInt64.from(67988), account_name: Name.from('test'), head_block_num: UInt32.from(0), head_block_time: TimePoint.from(new Date()), @@ -12,22 +13,22 @@ const mockAccountObject = API.v1.AccountObject.from({ created: TimePoint.from(new Date()), core_liquid_balance: Asset.from('0.0000 EOS'), net_limit: API.v1.AccountResourceLimit.from({ - used: UInt64.from(0), - available: UInt64.from(0), - max: UInt64.from(0), + used: UInt64.from(8253324), + available: UInt64.from(8253324), + max: UInt64.from(8253324 + 8253324), }), cpu_limit: API.v1.AccountResourceLimit.from({ - used: UInt64.from(0), - available: UInt64.from(0), - max: UInt64.from(0), + used: UInt64.from(826079), + available: UInt64.from(236250), + max: UInt64.from(826079 + 236250), }), - ram_usage: UInt64.from(0), + ram_usage: UInt64.from(17086), permissions: [], total_resources: API.v1.AccountTotalResources.from({ owner: Name.from('test'), - net_weight: Asset.from('0.0000 EOS'), - cpu_weight: Asset.from('0.0000 EOS'), - ram_bytes: UInt64.from(0), + net_weight: Asset.from('1.0000 EOS'), + cpu_weight: Asset.from('1.0000 EOS'), + ram_bytes: UInt64.from(1000), }), self_delegated_bandwidth: API.v1.AccountSelfDelegatedBandwidth.from({ from: Name.from('test'), @@ -41,6 +42,7 @@ const mockAccountObject = API.v1.AccountObject.from({ net_amount: Asset.from('0.0000 EOS'), cpu_amount: Asset.from('0.0000 EOS'), }), + getPermission: () => undefined, }) -export {mockAccountObject} +export const deserializedMockAccountObject = deserialize(mockAccountObject) diff --git a/test/permissions.ts b/test/permissions.ts index 3d8c196..3fcd556 100644 --- a/test/permissions.ts +++ b/test/permissions.ts @@ -1,7 +1,8 @@ import {assert} from 'chai' -import {Authority, Name} from '@greymass/eosio' +import {Authority, Name, NameType, AuthorityType} from '@wharfkit/antelope' -import {Permission} from '../src/permission' +import {ActionData, Permission} from '../src/permission' +import { deserialize } from './utils/helpers' const authorityExample = { threshold: 1, @@ -44,115 +45,113 @@ const expectedAuthorityData = { keys: [expectedKeyData], threshold: expectedThresholdData, } + interface DeserializedActionData { + account: NameType + parent: NameType + permission: NameType + auth: AuthorityType + authorized_by: NameType +} -suite('accounts', function () { - suite('Permission', function () { - test('construct', function () { - const permission = new Permission(Name.from('active'), { - account: 'teamgreymass', - parent: 'owner', - permission: 'active', - auth: Authority.from(authorityExample), - }) - assert.instanceOf(permission, Permission) - }) - - test('from', function () { - const permission = Permission.from({ - account: 'teamgreymass', - parent: 'owner', - permission: 'active', - auth: authorityExample, - }) - assert.instanceOf(permission, Permission) - }) - - test('permissionName', function () { - assert.equal(String(testPermission().permissionName), 'active') - }) - - test('actionData', function () { - assert.deepEqual(testPermission().actionData, { - account: 'teamgreymass', - permission: 'active', - parent: 'owner', - auth: { - accounts: [], - keys: [ - { - key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', - weight: 1, - }, - ], - threshold: 1, - waits: [], - }, - }) - }) - - test('addKey', function () { - const permission = testPermission() - permission.addKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') - assert.equal(permission.actionData.auth.keys?.length, 2) +suite('Permission', function () { + test('construct', function () { + const permission = new Permission(Name.from('active'), { + account: 'teamgreymass', + parent: 'owner', + permission: 'active', + auth: Authority.from(authorityExample), + authorized_by: 'teamgreymass', }) + assert.instanceOf(permission, Permission) + }) - test('removeKey', function () { - const permission = testPermission() - assert.equal(permission.actionData.auth.keys?.length, 1) - permission.removeKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') - assert.equal(permission.actionData.auth.keys?.length, 0) - }) + test('permissionName', function () { + assert.equal(String(testPermission().permissionName), 'active') + }) - test('addAccount', function () { - const permission = testPermission() - permission.addAccount({actor: 'trust.gm', permission: 'active'}) - assert.deepEqual(permission.actionData.auth, { - ...authorityExample, - accounts: [ + test('actionData', function () { + assert.deepEqual(deserialize(testPermission().actionData), { + account: 'teamgreymass', + permission: 'active', + authorized_by: 'teamgreymass', + parent: 'owner', + auth: { + accounts: [], + keys: [ { - permission: { - actor: 'trust.gm', - permission: 'active', - }, + key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', weight: 1, }, ], - }) + threshold: 1, + waits: [], + }, }) + }) - test('removeAccount', function () { - const permission = testPermission() - permission.addAccount({actor: 'trust.gm', permission: 'active'}) - permission.removeAccount('trust.gm') - assert.deepEqual(permission.actionData.auth, { - ...authorityExample, - accounts: [], - }) - }) + test('addKey', function () { + const permission = testPermission() + permission.addKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') + assert.equal(permission.actionData.auth.keys?.length, 2) + }) + + test('removeKey', function () { + const permission = testPermission() + assert.equal(permission.actionData.auth.keys?.length, 1) + permission.removeKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') + assert.equal(permission.actionData.auth.keys?.length, 0) + }) - test('addWait', function () { - const permission = testPermission() - permission.addWait(100) - assert.deepEqual(JSON.parse(JSON.stringify(permission.actionData.auth.waits)), [ - {wait_sec: 100, weight: 1}, - ]) + test('addAccount', function () { + const permission = testPermission() + permission.addAccount({actor: 'trust.gm', permission: 'active'}) + assert.deepEqual(deserialize(permission.actionData.auth), { + ...authorityExample, + accounts: [ + { + permission: { + actor: 'trust.gm', + permission: 'active', + }, + weight: 1, + }, + ], }) + }) - test('removeWait', function () { - const permission = testPermission() - permission.addWait(100) - assert.equal(permission.actionData.auth.waits?.length, 1) - permission.removeWait(100) - assert.equal(permission.actionData.auth.waits?.length, 0) + test('removeAccount', function () { + const permission = testPermission() + permission.addAccount({actor: 'trust.gm', permission: 'active'}) + permission.removeAccount('trust.gm') + assert.deepEqual(deserialize(permission.actionData.auth), { + ...authorityExample, + accounts: [], }) }) + + test('addWait', function () { + const permission = testPermission() + permission.addWait(100) + assert.deepEqual(JSON.parse(JSON.stringify(permission.actionData.auth.waits)), [ + {wait_sec: 100, weight: 1}, + ]) + }) + + test('removeWait', function () { + const permission = testPermission() + permission.addWait(100) + assert.equal(permission.actionData.auth.waits?.length, 1) + permission.removeWait(100) + assert.equal(permission.actionData.auth.waits?.length, 0) + }) }) function testPermission() { - return new Permission(Name.from('active'), { + return new Permission('active', { account: 'teamgreymass', parent: 'owner', permission: 'active', + authorized_by: 'teamgreymass', auth: Authority.from({ threshold: 1, keys: [ @@ -166,3 +165,4 @@ function testPermission() { }), }) } + diff --git a/test/utils/helpers.ts b/test/utils/helpers.ts new file mode 100644 index 0000000..cdfc0c0 --- /dev/null +++ b/test/utils/helpers.ts @@ -0,0 +1,3 @@ +export function deserialize(data: DataType) { + return JSON.parse(JSON.stringify(data)) +} \ No newline at end of file diff --git a/yarn.lock b/yarn.lock index 69f2a9e..033d6ff 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2,192 +2,196 @@ # yarn lockfile v1 -"@ampproject/remapping@^2.1.0": - version "2.2.0" - resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.0.tgz#56c133824780de3174aed5ab6834f3026790154d" - integrity sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w== +"@aashutoshrathi/word-wrap@^1.2.3": + version "1.2.6" + resolved "https://registry.yarnpkg.com/@aashutoshrathi/word-wrap/-/word-wrap-1.2.6.tgz#bd9154aec9983f77b3a034ecaa015c2e4201f6cf" + integrity sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA== + +"@ampproject/remapping@^2.2.0": + version "2.2.1" + resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.1.tgz#99e8e11851128b8702cd57c33684f1d0f260b630" + integrity sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg== dependencies: - "@jridgewell/gen-mapping" "^0.1.0" + "@jridgewell/gen-mapping" "^0.3.0" "@jridgewell/trace-mapping" "^0.3.9" -"@babel/code-frame@^7.10.4", "@babel/code-frame@^7.18.6": - version "7.18.6" - resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.18.6.tgz#3b25d38c89600baa2dcc219edfa88a74eb2c427a" - integrity sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q== +"@babel/code-frame@^7.10.4", "@babel/code-frame@^7.22.10", "@babel/code-frame@^7.22.5": + version "7.22.13" + resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.22.13.tgz#e3c1c099402598483b7a8c46a721d1038803755e" + integrity sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w== dependencies: - "@babel/highlight" "^7.18.6" + "@babel/highlight" "^7.22.13" + chalk "^2.4.2" -"@babel/compat-data@^7.20.5": - version "7.20.10" - resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.20.10.tgz#9d92fa81b87542fff50e848ed585b4212c1d34ec" - integrity sha512-sEnuDPpOJR/fcafHMjpcpGN5M2jbUGUHwmuWKM/YdPzeEDJg8bgmbcWQFUfE32MQjti1koACvoPVsDe8Uq+idg== +"@babel/compat-data@^7.22.9": + version "7.22.9" + resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.22.9.tgz#71cdb00a1ce3a329ce4cbec3a44f9fef35669730" + integrity sha512-5UamI7xkUcJ3i9qVDS+KFDEK8/7oJ55/sJMB1Ge7IEapr7KfdfV/HErR+koZwOfd+SgtFKOKRhRakdg++DcJpQ== "@babel/core@^7.7.5": - version "7.20.12" - resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.20.12.tgz#7930db57443c6714ad216953d1356dac0eb8496d" - integrity sha512-XsMfHovsUYHFMdrIHkZphTN/2Hzzi78R08NuHfDBehym2VsPDL6Zn/JAD/JQdnRvbSsbQc4mVaU1m6JgtTEElg== - dependencies: - "@ampproject/remapping" "^2.1.0" - "@babel/code-frame" "^7.18.6" - "@babel/generator" "^7.20.7" - "@babel/helper-compilation-targets" "^7.20.7" - "@babel/helper-module-transforms" "^7.20.11" - "@babel/helpers" "^7.20.7" - "@babel/parser" "^7.20.7" - "@babel/template" "^7.20.7" - "@babel/traverse" "^7.20.12" - "@babel/types" "^7.20.7" + version "7.22.11" + resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.22.11.tgz#8033acaa2aa24c3f814edaaa057f3ce0ba559c24" + integrity sha512-lh7RJrtPdhibbxndr6/xx0w8+CVlY5FJZiaSz908Fpy+G0xkBFTvwLcKJFF4PJxVfGhVWNebikpWGnOoC71juQ== + dependencies: + "@ampproject/remapping" "^2.2.0" + "@babel/code-frame" "^7.22.10" + "@babel/generator" "^7.22.10" + "@babel/helper-compilation-targets" "^7.22.10" + "@babel/helper-module-transforms" "^7.22.9" + "@babel/helpers" "^7.22.11" + "@babel/parser" "^7.22.11" + "@babel/template" "^7.22.5" + "@babel/traverse" "^7.22.11" + "@babel/types" "^7.22.11" convert-source-map "^1.7.0" debug "^4.1.0" gensync "^1.0.0-beta.2" - json5 "^2.2.2" - semver "^6.3.0" + json5 "^2.2.3" + semver "^6.3.1" -"@babel/generator@^7.20.7": - version "7.20.7" - resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.20.7.tgz#f8ef57c8242665c5929fe2e8d82ba75460187b4a" - integrity sha512-7wqMOJq8doJMZmP4ApXTzLxSr7+oO2jroJURrVEp6XShrQUObV8Tq/D0NCcoYg2uHqUrjzO0zwBjoYzelxK+sw== +"@babel/generator@^7.22.10": + version "7.22.10" + resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.22.10.tgz#c92254361f398e160645ac58831069707382b722" + integrity sha512-79KIf7YiWjjdZ81JnLujDRApWtl7BxTqWD88+FFdQEIOG8LJ0etDOM7CXuIgGJa55sGOwZVwuEsaLEm0PJ5/+A== dependencies: - "@babel/types" "^7.20.7" + "@babel/types" "^7.22.10" "@jridgewell/gen-mapping" "^0.3.2" + "@jridgewell/trace-mapping" "^0.3.17" jsesc "^2.5.1" -"@babel/helper-compilation-targets@^7.20.7": - version "7.20.7" - resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.7.tgz#a6cd33e93629f5eb473b021aac05df62c4cd09bb" - integrity sha512-4tGORmfQcrc+bvrjb5y3dG9Mx1IOZjsHqQVUz7XCNHO+iTmqxWnVg3KRygjGmpRLJGdQSKuvFinbIb0CnZwHAQ== +"@babel/helper-compilation-targets@^7.22.10": + version "7.22.10" + resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.10.tgz#01d648bbc25dd88f513d862ee0df27b7d4e67024" + integrity sha512-JMSwHD4J7SLod0idLq5PKgI+6g/hLD/iuWBq08ZX49xE14VpVEojJ5rHWptpirV2j020MvypRLAXAO50igCJ5Q== dependencies: - "@babel/compat-data" "^7.20.5" - "@babel/helper-validator-option" "^7.18.6" - browserslist "^4.21.3" + "@babel/compat-data" "^7.22.9" + "@babel/helper-validator-option" "^7.22.5" + browserslist "^4.21.9" lru-cache "^5.1.1" - semver "^6.3.0" - -"@babel/helper-environment-visitor@^7.18.9": - version "7.18.9" - resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz#0c0cee9b35d2ca190478756865bb3528422f51be" - integrity sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg== - -"@babel/helper-function-name@^7.19.0": - version "7.19.0" - resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.19.0.tgz#941574ed5390682e872e52d3f38ce9d1bef4648c" - integrity sha512-WAwHBINyrpqywkUH0nTnNgI5ina5TFn85HKS0pbPDfxFfhyR/aNQEn4hGi1P1JyT//I0t4OgXUlofzWILRvS5w== - dependencies: - "@babel/template" "^7.18.10" - "@babel/types" "^7.19.0" - -"@babel/helper-hoist-variables@^7.18.6": - version "7.18.6" - resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz#d4d2c8fb4baeaa5c68b99cc8245c56554f926678" - integrity sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q== - dependencies: - "@babel/types" "^7.18.6" - -"@babel/helper-module-imports@^7.18.6": - version "7.18.6" - resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz#1e3ebdbbd08aad1437b428c50204db13c5a3ca6e" - integrity sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA== - dependencies: - "@babel/types" "^7.18.6" - -"@babel/helper-module-transforms@^7.20.11": - version "7.20.11" - resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.20.11.tgz#df4c7af713c557938c50ea3ad0117a7944b2f1b0" - integrity sha512-uRy78kN4psmji1s2QtbtcCSaj/LILFDp0f/ymhpQH5QY3nljUZCaNWz9X1dEj/8MBdBEFECs7yRhKn8i7NjZgg== - dependencies: - "@babel/helper-environment-visitor" "^7.18.9" - "@babel/helper-module-imports" "^7.18.6" - "@babel/helper-simple-access" "^7.20.2" - "@babel/helper-split-export-declaration" "^7.18.6" - "@babel/helper-validator-identifier" "^7.19.1" - "@babel/template" "^7.20.7" - "@babel/traverse" "^7.20.10" - "@babel/types" "^7.20.7" - -"@babel/helper-simple-access@^7.20.2": - version "7.20.2" - resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz#0ab452687fe0c2cfb1e2b9e0015de07fc2d62dd9" - integrity sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA== - dependencies: - "@babel/types" "^7.20.2" - -"@babel/helper-split-export-declaration@^7.18.6": - version "7.18.6" - resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz#7367949bc75b20c6d5a5d4a97bba2824ae8ef075" - integrity sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA== - dependencies: - "@babel/types" "^7.18.6" - -"@babel/helper-string-parser@^7.19.4": - version "7.19.4" - resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.19.4.tgz#38d3acb654b4701a9b77fb0615a96f775c3a9e63" - integrity sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw== - -"@babel/helper-validator-identifier@^7.18.6", "@babel/helper-validator-identifier@^7.19.1": - version "7.19.1" - resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz#7eea834cf32901ffdc1a7ee555e2f9c27e249ca2" - integrity sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w== - -"@babel/helper-validator-option@^7.18.6": - version "7.18.6" - resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.18.6.tgz#bf0d2b5a509b1f336099e4ff36e1a63aa5db4db8" - integrity sha512-XO7gESt5ouv/LRJdrVjkShckw6STTaB7l9BrpBaAHDeF5YZT+01PCwmR0SJHnkW6i8OwW/EVWRShfi4j2x+KQw== - -"@babel/helpers@^7.20.7": - version "7.20.13" - resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.20.13.tgz#e3cb731fb70dc5337134cadc24cbbad31cc87ad2" - integrity sha512-nzJ0DWCL3gB5RCXbUO3KIMMsBY2Eqbx8mBpKGE/02PgyRQFcPQLbkQ1vyy596mZLaP+dAfD+R4ckASzNVmW3jg== - dependencies: - "@babel/template" "^7.20.7" - "@babel/traverse" "^7.20.13" - "@babel/types" "^7.20.7" - -"@babel/highlight@^7.18.6": - version "7.18.6" - resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.18.6.tgz#81158601e93e2563795adcbfbdf5d64be3f2ecdf" - integrity sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g== - dependencies: - "@babel/helper-validator-identifier" "^7.18.6" - chalk "^2.0.0" + semver "^6.3.1" + +"@babel/helper-environment-visitor@^7.22.5": + version "7.22.5" + resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.5.tgz#f06dd41b7c1f44e1f8da6c4055b41ab3a09a7e98" + integrity sha512-XGmhECfVA/5sAt+H+xpSg0mfrHq6FzNr9Oxh7PSEBBRUb/mL7Kz3NICXb194rCqAEdxkhPT1a88teizAFyvk8Q== + +"@babel/helper-function-name@^7.22.5": + version "7.22.5" + resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.22.5.tgz#ede300828905bb15e582c037162f99d5183af1be" + integrity sha512-wtHSq6jMRE3uF2otvfuD3DIvVhOsSNshQl0Qrd7qC9oQJzHvOL4qQXlQn2916+CXGywIjpGuIkoyZRRxHPiNQQ== + dependencies: + "@babel/template" "^7.22.5" + "@babel/types" "^7.22.5" + +"@babel/helper-hoist-variables@^7.22.5": + version "7.22.5" + resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz#c01a007dac05c085914e8fb652b339db50d823bb" + integrity sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw== + dependencies: + "@babel/types" "^7.22.5" + +"@babel/helper-module-imports@^7.22.5": + version "7.22.5" + resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.22.5.tgz#1a8f4c9f4027d23f520bd76b364d44434a72660c" + integrity sha512-8Dl6+HD/cKifutF5qGd/8ZJi84QeAKh+CEe1sBzz8UayBBGg1dAIJrdHOcOM5b2MpzWL2yuotJTtGjETq0qjXg== + dependencies: + "@babel/types" "^7.22.5" + +"@babel/helper-module-transforms@^7.22.9": + version "7.22.9" + resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.22.9.tgz#92dfcb1fbbb2bc62529024f72d942a8c97142129" + integrity sha512-t+WA2Xn5K+rTeGtC8jCsdAH52bjggG5TKRuRrAGNM/mjIbO4GxvlLMFOEz9wXY5I2XQ60PMFsAG2WIcG82dQMQ== + dependencies: + "@babel/helper-environment-visitor" "^7.22.5" + "@babel/helper-module-imports" "^7.22.5" + "@babel/helper-simple-access" "^7.22.5" + "@babel/helper-split-export-declaration" "^7.22.6" + "@babel/helper-validator-identifier" "^7.22.5" + +"@babel/helper-simple-access@^7.22.5": + version "7.22.5" + resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz#4938357dc7d782b80ed6dbb03a0fba3d22b1d5de" + integrity sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w== + dependencies: + "@babel/types" "^7.22.5" + +"@babel/helper-split-export-declaration@^7.22.6": + version "7.22.6" + resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz#322c61b7310c0997fe4c323955667f18fcefb91c" + integrity sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g== + dependencies: + "@babel/types" "^7.22.5" + +"@babel/helper-string-parser@^7.22.5": + version "7.22.5" + resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz#533f36457a25814cf1df6488523ad547d784a99f" + integrity sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw== + +"@babel/helper-validator-identifier@^7.22.5": + version "7.22.5" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz#9544ef6a33999343c8740fa51350f30eeaaaf193" + integrity sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ== + +"@babel/helper-validator-option@^7.22.5": + version "7.22.5" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.22.5.tgz#de52000a15a177413c8234fa3a8af4ee8102d0ac" + integrity sha512-R3oB6xlIVKUnxNUxbmgq7pKjxpru24zlimpE8WK47fACIlM0II/Hm1RS8IaOI7NgCr6LNS+jl5l75m20npAziw== + +"@babel/helpers@^7.22.11": + version "7.22.11" + resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.22.11.tgz#b02f5d5f2d7abc21ab59eeed80de410ba70b056a" + integrity sha512-vyOXC8PBWaGc5h7GMsNx68OH33cypkEDJCHvYVVgVbbxJDROYVtexSk0gK5iCF1xNjRIN2s8ai7hwkWDq5szWg== + dependencies: + "@babel/template" "^7.22.5" + "@babel/traverse" "^7.22.11" + "@babel/types" "^7.22.11" + +"@babel/highlight@^7.22.13": + version "7.22.13" + resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.22.13.tgz#9cda839e5d3be9ca9e8c26b6dd69e7548f0cbf16" + integrity sha512-C/BaXcnnvBCmHTpz/VGZ8jgtE2aYlW4hxDhseJAWZb7gqGM/qtCK6iZUb0TyKFf7BOUsBH7Q7fkRsDRhg1XklQ== + dependencies: + "@babel/helper-validator-identifier" "^7.22.5" + chalk "^2.4.2" js-tokens "^4.0.0" -"@babel/parser@^7.20.13", "@babel/parser@^7.20.7": - version "7.20.13" - resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.20.13.tgz#ddf1eb5a813588d2fb1692b70c6fce75b945c088" - integrity sha512-gFDLKMfpiXCsjt4za2JA9oTMn70CeseCehb11kRZgvd7+F67Hih3OHOK24cRrWECJ/ljfPGac6ygXAs/C8kIvw== - -"@babel/template@^7.18.10", "@babel/template@^7.20.7": - version "7.20.7" - resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.20.7.tgz#a15090c2839a83b02aa996c0b4994005841fd5a8" - integrity sha512-8SegXApWe6VoNw0r9JHpSteLKTpTiLZ4rMlGIm9JQ18KiCtyQiAMEazujAHrUS5flrcqYZa75ukev3P6QmUwUw== - dependencies: - "@babel/code-frame" "^7.18.6" - "@babel/parser" "^7.20.7" - "@babel/types" "^7.20.7" - -"@babel/traverse@^7.20.10", "@babel/traverse@^7.20.12", "@babel/traverse@^7.20.13": - version "7.20.13" - resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.20.13.tgz#817c1ba13d11accca89478bd5481b2d168d07473" - integrity sha512-kMJXfF0T6DIS9E8cgdLCSAL+cuCK+YEZHWiLK0SXpTo8YRj5lpJu3CDNKiIBCne4m9hhTIqUg6SYTAI39tAiVQ== - dependencies: - "@babel/code-frame" "^7.18.6" - "@babel/generator" "^7.20.7" - "@babel/helper-environment-visitor" "^7.18.9" - "@babel/helper-function-name" "^7.19.0" - "@babel/helper-hoist-variables" "^7.18.6" - "@babel/helper-split-export-declaration" "^7.18.6" - "@babel/parser" "^7.20.13" - "@babel/types" "^7.20.7" +"@babel/parser@^7.22.11", "@babel/parser@^7.22.5": + version "7.22.14" + resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.22.14.tgz#c7de58e8de106e88efca42ce17f0033209dfd245" + integrity sha512-1KucTHgOvaw/LzCVrEOAyXkr9rQlp0A1HiHRYnSUE9dmb8PvPW7o5sscg+5169r54n3vGlbx6GevTE/Iw/P3AQ== + +"@babel/template@^7.22.5": + version "7.22.5" + resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.22.5.tgz#0c8c4d944509875849bd0344ff0050756eefc6ec" + integrity sha512-X7yV7eiwAxdj9k94NEylvbVHLiVG1nvzCV2EAowhxLTwODV1jl9UzZ48leOC0sH7OnuHrIkllaBgneUykIcZaw== + dependencies: + "@babel/code-frame" "^7.22.5" + "@babel/parser" "^7.22.5" + "@babel/types" "^7.22.5" + +"@babel/traverse@^7.22.11": + version "7.22.11" + resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.22.11.tgz#71ebb3af7a05ff97280b83f05f8865ac94b2027c" + integrity sha512-mzAenteTfomcB7mfPtyi+4oe5BZ6MXxWcn4CX+h4IRJ+OOGXBrWU6jDQavkQI9Vuc5P+donFabBfFCcmWka9lQ== + dependencies: + "@babel/code-frame" "^7.22.10" + "@babel/generator" "^7.22.10" + "@babel/helper-environment-visitor" "^7.22.5" + "@babel/helper-function-name" "^7.22.5" + "@babel/helper-hoist-variables" "^7.22.5" + "@babel/helper-split-export-declaration" "^7.22.6" + "@babel/parser" "^7.22.11" + "@babel/types" "^7.22.11" debug "^4.1.0" globals "^11.1.0" -"@babel/types@^7.18.6", "@babel/types@^7.19.0", "@babel/types@^7.20.2", "@babel/types@^7.20.7": - version "7.20.7" - resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.20.7.tgz#54ec75e252318423fc07fb644dc6a58a64c09b7f" - integrity sha512-69OnhBxSSgK0OzTJai4kyPDiKTIe3j+ctaHdIGVbRahTLAT7L3R9oeXHC2aVSuGYt3cVnoAMDmOCgJ2yaiLMvg== +"@babel/types@^7.22.10", "@babel/types@^7.22.11", "@babel/types@^7.22.5": + version "7.22.11" + resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.22.11.tgz#0e65a6a1d4d9cbaa892b2213f6159485fe632ea2" + integrity sha512-siazHiGuZRz9aB9NpHy9GOs9xiQPKnMzgdr493iI1M67vRXpnEq8ZOOKzezC5q7zwuQ6sDhdSp4SD9ixKSqKZg== dependencies: - "@babel/helper-string-parser" "^7.19.4" - "@babel/helper-validator-identifier" "^7.19.1" + "@babel/helper-string-parser" "^7.22.5" + "@babel/helper-validator-identifier" "^7.22.5" to-fast-properties "^2.0.0" "@cspotcode/source-map-support@^0.8.0": @@ -197,14 +201,26 @@ dependencies: "@jridgewell/trace-mapping" "0.3.9" -"@eslint/eslintrc@^1.4.1": - version "1.4.1" - resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-1.4.1.tgz#af58772019a2d271b7e2d4c23ff4ddcba3ccfb3e" - integrity sha512-XXrH9Uarn0stsyldqDYq8r++mROmWRI1xKMXa640Bb//SY1+ECYX6VzT6Lcx5frD0V30XieqJ0oX9I2Xj5aoMA== +"@eslint-community/eslint-utils@^4.2.0": + version "4.4.0" + resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz#a23514e8fb9af1269d5f7788aa556798d61c6b59" + integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA== + dependencies: + eslint-visitor-keys "^3.3.0" + +"@eslint-community/regexpp@^4.4.0", "@eslint-community/regexpp@^4.6.1": + version "4.8.0" + resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.8.0.tgz#11195513186f68d42fbf449f9a7136b2c0c92005" + integrity sha512-JylOEEzDiOryeUnFbQz+oViCXS0KsvR1mvHkoMiu5+UiBvy+RYX7tzlIIIEstF/gVa2tj9AQXk3dgnxv6KxhFg== + +"@eslint/eslintrc@^2.1.2": + version "2.1.2" + resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.1.2.tgz#c6936b4b328c64496692f76944e755738be62396" + integrity sha512-+wvgpDsrB1YqAMdEUCcnTlpfVBH7Vqn6A/NT3D8WVXFIaKMlErPIZT3oCIAVCOtarRpMtelZLqJeU3t7WY6X6g== dependencies: ajv "^6.12.4" debug "^4.3.2" - espree "^9.4.0" + espree "^9.6.0" globals "^13.19.0" ignore "^5.2.0" import-fresh "^3.2.1" @@ -212,10 +228,15 @@ minimatch "^3.1.2" strip-json-comments "^3.1.1" +"@eslint/js@8.48.0": + version "8.48.0" + resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.48.0.tgz#642633964e217905436033a2bd08bf322849b7fb" + integrity sha512-ZSjtmelB7IJfWD2Fvb7+Z+ChTIKWq6kjda95fLcQKNS5aheVHn4IkfgRQE3sIIzTcSLwLcLZUD9UBt+V7+h+Pw== + "@greymass/eosio@^0.6.0", "@greymass/eosio@^0.6.4": - version "0.6.8" - resolved "https://registry.yarnpkg.com/@greymass/eosio/-/eosio-0.6.8.tgz#6f24071eaec6e0df33e3c35ca0704a53146c00d2" - integrity sha512-niWrUjCzQR9bJsl5IhrJIoi9fWCL4gEAOOaBdTmJuUFpOISQYe4zir5TjNlvlfpCC9ajy7o0pUNpDZuVrNaijQ== + version "0.6.11" + resolved "https://registry.yarnpkg.com/@greymass/eosio/-/eosio-0.6.11.tgz#9bd1783f8467834563ac893d41524c01aba0228c" + integrity sha512-Ud6V7+vQJ+OLxqD7QcKTv/ik/Hd5uaRHyGY9Hzc+cJXezYU4sADX4TyQ8sn6XIr8ebVVNZFvWpc5JR0a9lBzKw== dependencies: bn.js "^4.11.9" brorand "^1.1.0" @@ -223,10 +244,10 @@ hash.js "^1.0.0" tslib "^2.0.3" -"@humanwhocodes/config-array@^0.11.8": - version "0.11.8" - resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.8.tgz#03595ac2075a4dc0f191cc2131de14fbd7d410b9" - integrity sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g== +"@humanwhocodes/config-array@^0.11.10": + version "0.11.11" + resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.11.tgz#88a04c570dbbc7dd943e4712429c3df09bc32844" + integrity sha512-N2brEuAadi0CcdeMXUkhbZB84eskAc8MEX1By6qEchoVywSgXPIjou4rYsl0V3Hj0ZnuGycGCjdNgockbzeWNA== dependencies: "@humanwhocodes/object-schema" "^1.2.1" debug "^4.1.1" @@ -258,45 +279,37 @@ resolved "https://registry.yarnpkg.com/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98" integrity sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA== -"@jridgewell/gen-mapping@^0.1.0": - version "0.1.1" - resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz#e5d2e450306a9491e3bd77e323e38d7aff315996" - integrity sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w== - dependencies: - "@jridgewell/set-array" "^1.0.0" - "@jridgewell/sourcemap-codec" "^1.4.10" - "@jridgewell/gen-mapping@^0.3.0", "@jridgewell/gen-mapping@^0.3.2": - version "0.3.2" - resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz#c1aedc61e853f2bb9f5dfe6d4442d3b565b253b9" - integrity sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A== + version "0.3.3" + resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz#7e02e6eb5df901aaedb08514203b096614024098" + integrity sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ== dependencies: "@jridgewell/set-array" "^1.0.1" "@jridgewell/sourcemap-codec" "^1.4.10" "@jridgewell/trace-mapping" "^0.3.9" -"@jridgewell/resolve-uri@3.1.0", "@jridgewell/resolve-uri@^3.0.3": - version "3.1.0" - resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz#2203b118c157721addfe69d47b70465463066d78" - integrity sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w== +"@jridgewell/resolve-uri@^3.0.3", "@jridgewell/resolve-uri@^3.1.0": + version "3.1.1" + resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz#c08679063f279615a3326583ba3a90d1d82cc721" + integrity sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA== -"@jridgewell/set-array@^1.0.0", "@jridgewell/set-array@^1.0.1": +"@jridgewell/set-array@^1.0.1": version "1.1.2" resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72" integrity sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw== -"@jridgewell/source-map@^0.3.2": - version "0.3.2" - resolved "https://registry.yarnpkg.com/@jridgewell/source-map/-/source-map-0.3.2.tgz#f45351aaed4527a298512ec72f81040c998580fb" - integrity sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw== +"@jridgewell/source-map@^0.3.3": + version "0.3.5" + resolved "https://registry.yarnpkg.com/@jridgewell/source-map/-/source-map-0.3.5.tgz#a3bb4d5c6825aab0d281268f47f6ad5853431e91" + integrity sha512-UTYAUj/wviwdsMfzoSJspJxbkH5o1snzwX0//0ENX1u/55kkZZkcTZP6u9bwKGkv+dkk9at4m1Cpt0uY80kcpQ== dependencies: "@jridgewell/gen-mapping" "^0.3.0" "@jridgewell/trace-mapping" "^0.3.9" -"@jridgewell/sourcemap-codec@1.4.14", "@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.13": - version "1.4.14" - resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz#add4c98d341472a289190b424efbdb096991bb24" - integrity sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw== +"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.13", "@jridgewell/sourcemap-codec@^1.4.14", "@jridgewell/sourcemap-codec@^1.4.15": + version "1.4.15" + resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32" + integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg== "@jridgewell/trace-mapping@0.3.9": version "0.3.9" @@ -306,13 +319,13 @@ "@jridgewell/resolve-uri" "^3.0.3" "@jridgewell/sourcemap-codec" "^1.4.10" -"@jridgewell/trace-mapping@^0.3.9": - version "0.3.17" - resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.17.tgz#793041277af9073b0951a7fe0f0d8c4c98c36985" - integrity sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g== +"@jridgewell/trace-mapping@^0.3.17", "@jridgewell/trace-mapping@^0.3.9": + version "0.3.19" + resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.19.tgz#f8a3249862f91be48d3127c3cfe992f79b4b8811" + integrity sha512-kf37QtfW+Hwx/buWGMPcR60iF9ziHa6r/CZJIHbmcm4+0qrXiVdxegAH0F6yddEVQ7zdkjcGCgCzUu+BcbhQxw== dependencies: - "@jridgewell/resolve-uri" "3.1.0" - "@jridgewell/sourcemap-codec" "1.4.14" + "@jridgewell/resolve-uri" "^3.1.0" + "@jridgewell/sourcemap-codec" "^1.4.14" "@nodelib/fs.scandir@2.1.5": version "2.1.5" @@ -336,9 +349,9 @@ fastq "^1.6.0" "@rollup/plugin-alias@^4.0.2": - version "4.0.3" - resolved "https://registry.yarnpkg.com/@rollup/plugin-alias/-/plugin-alias-4.0.3.tgz#571f6fb26387df91d0363905a7fd835757727ae2" - integrity sha512-ZuDWE1q4PQDhvm/zc5Prun8sBpLJy41DMptYrS6MhAy9s9kL/doN1613BWfEchGVfKxzliJ3BjbOPizXX38DbQ== + version "4.0.4" + resolved "https://registry.yarnpkg.com/@rollup/plugin-alias/-/plugin-alias-4.0.4.tgz#67734ec44a7747916aa52a3b1a0e8d459dbf3ae2" + integrity sha512-0CaAY238SMtYAWEXXptWSR8iz8NYZnH7zNBKuJ14xFJSGwLtPgjvXYsoApAHfzYXXH1ejxpVw7WlHss3zhh9SQ== dependencies: slash "^4.0.0" @@ -362,14 +375,14 @@ "@rollup/pluginutils" "^5.0.1" "@rollup/plugin-node-resolve@^15.0.1": - version "15.0.1" - resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.0.1.tgz#72be449b8e06f6367168d5b3cd5e2802e0248971" - integrity sha512-ReY88T7JhJjeRVbfCyNj+NXAG3IIsVMsX9b5/9jC98dRP8/yxlZdz7mHZbHk5zHr24wZZICS5AcXsFZAXYUQEg== + version "15.2.1" + resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.2.1.tgz#a15b14fb7969229e26a30feff2816d39eff503f0" + integrity sha512-nsbUg588+GDSu8/NS8T4UAshO6xeaOfINNuXeVHcKV02LJtoRaM1SiOacClw4kws1SFiNhdLGxlbMY9ga/zs/w== dependencies: "@rollup/pluginutils" "^5.0.1" "@types/resolve" "1.20.2" deepmerge "^4.2.2" - is-builtin-module "^3.2.0" + is-builtin-module "^3.2.1" is-module "^1.0.0" resolve "^1.22.1" @@ -387,9 +400,9 @@ integrity sha512-fK8O0IL5+q+GrsMLuACVNk2x21g3yaw+sG2qn16SnUd3IlBsQyvWxLMGHmCmXRMecPjGRSZ/1LmZB4rjQm68og== "@rollup/pluginutils@^5.0.1": - version "5.0.2" - resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-5.0.2.tgz#012b8f53c71e4f6f9cb317e311df1404f56e7a33" - integrity sha512-pTd9rIsP92h+B6wWwFbW8RkZv4hiR/xKsqre4SIuAOaOEQRxi0lqLke9k2/7WegC85GgUs9pjmOjCUi3In4vwA== + version "5.0.4" + resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-5.0.4.tgz#74f808f9053d33bafec0cc98e7b835c9667d32ba" + integrity sha512-0KJnIoRI8A+a1dqOYLxH8vBf8bphDmty5QvIm2hqm7oFCFYKCAZWWd2hXgMibaPsNDhI0AtpYfQZJG47pt/k4g== dependencies: "@types/estree" "^1.0.0" estree-walker "^2.0.2" @@ -411,34 +424,39 @@ integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow== "@tsconfig/node16@^1.0.2": - version "1.0.3" - resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.3.tgz#472eaab5f15c1ffdd7f8628bd4c4f753995ec79e" - integrity sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ== + version "1.0.4" + resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9" + integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA== "@types/chai@^4.3.1": - version "4.3.4" - resolved "https://registry.yarnpkg.com/@types/chai/-/chai-4.3.4.tgz#e913e8175db8307d78b4e8fa690408ba6b65dee4" - integrity sha512-KnRanxnpfpjUTqTCXslZSEdLfXExwgNxYPdiO2WGUj8+HDjFi8R3k5RVKPeSCzLjCcshCAtVO2QBbVuAV4kTnw== + version "4.3.5" + resolved "https://registry.yarnpkg.com/@types/chai/-/chai-4.3.5.tgz#ae69bcbb1bebb68c4ac0b11e9d8ed04526b3562b" + integrity sha512-mEo1sAde+UCE6b2hxn332f1g1E8WfYRu6p5SvTKr2ZKC1f7gFJXk4h5PyGP9Dt6gCaG8y8XhwnXWC6Iy2cmBng== "@types/estree@*", "@types/estree@^1.0.0": - version "1.0.0" - resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.0.tgz#5fb2e536c1ae9bf35366eed879e827fa59ca41c2" - integrity sha512-WulqXMDUTYAXCjZnk6JtIHPigp55cVtDgDrO2gHRwhyJto21+1zbVCtOYB2L1F9w4qCQ0rOGWBnBe0FNTiEJIQ== + version "1.0.1" + resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.1.tgz#aa22750962f3bf0e79d753d3cc067f010c95f194" + integrity sha512-LG4opVs2ANWZ1TJoKc937iMmNstM/d0ae1vNbnBvBhqCSezgVUOzcLCqbI5elV8Vy6WKwKjaqR+zO9VKirBBCA== "@types/json-schema@^7.0.9": - version "7.0.11" - resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3" - integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ== + version "7.0.12" + resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.12.tgz#d70faba7039d5fca54c83c7dbab41051d2b6f6cb" + integrity sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA== "@types/mocha@^10.0.0": version "10.0.1" resolved "https://registry.yarnpkg.com/@types/mocha/-/mocha-10.0.1.tgz#2f4f65bb08bc368ac39c96da7b2f09140b26851b" integrity sha512-/fvYntiO1GeICvqbQ3doGDIP97vWmvFt83GKguJ6prmQM2iXZfFcq6YE8KteFyRtX2/h5Hf91BYvPodJKFYv5Q== -"@types/node@*", "@types/node@^18.11.9": - version "18.11.18" - resolved "https://registry.yarnpkg.com/@types/node/-/node-18.11.18.tgz#8dfb97f0da23c2293e554c5a50d61ef134d7697f" - integrity sha512-DHQpWGjyQKSHj3ebjFI/wRKcqQcdR+MoFBygntYOZytCqNfkd2ZC4ARDJ2DQqhjH5p85Nnd3jhUJIXrszFX/JA== +"@types/node@*": + version "20.5.7" + resolved "https://registry.yarnpkg.com/@types/node/-/node-20.5.7.tgz#4b8ecac87fbefbc92f431d09c30e176fc0a7c377" + integrity sha512-dP7f3LdZIysZnmvP3ANJYTSwg+wLLl8p7RqniVlV7j+oXSXAbt9h0WIBFmJy5inWZoX9wZN6eXx+YXd9Rh3RBA== + +"@types/node@^18.11.9": + version "18.17.12" + resolved "https://registry.yarnpkg.com/@types/node/-/node-18.17.12.tgz#c6bd7413a13e6ad9cfb7e97dd5c4e904c1821e50" + integrity sha512-d6xjC9fJ/nSnfDeU0AMDsaJyb1iHsqCSOdi84w4u+SlN/UgQdY5tRhpMzaFYsI4mnpvgTivEaQd0yOUhAtOnEQ== "@types/resolve@1.20.2": version "1.20.2" @@ -446,91 +464,92 @@ integrity sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q== "@types/semver@^7.3.12": - version "7.3.13" - resolved "https://registry.yarnpkg.com/@types/semver/-/semver-7.3.13.tgz#da4bfd73f49bd541d28920ab0e2bf0ee80f71c91" - integrity sha512-21cFJr9z3g5dW8B0CVI9g2O9beqaThGQ6ZFBqHfwhzLDKUxaqTIy3vnfah/UPkfOiF2pLq+tGz+W8RyCskuslw== + version "7.5.1" + resolved "https://registry.yarnpkg.com/@types/semver/-/semver-7.5.1.tgz#0480eeb7221eb9bc398ad7432c9d7e14b1a5a367" + integrity sha512-cJRQXpObxfNKkFAZbJl2yjWtJCqELQIdShsogr1d2MilP8dKD9TE/nEKHkJgUNHdGKCQaf9HbIynuV2csLGVLg== "@typescript-eslint/eslint-plugin@^5.20.0": - version "5.49.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.49.0.tgz#d0b4556f0792194bf0c2fb297897efa321492389" - integrity sha512-IhxabIpcf++TBaBa1h7jtOWyon80SXPRLDq0dVz5SLFC/eW6tofkw/O7Ar3lkx5z5U6wzbKDrl2larprp5kk5Q== - dependencies: - "@typescript-eslint/scope-manager" "5.49.0" - "@typescript-eslint/type-utils" "5.49.0" - "@typescript-eslint/utils" "5.49.0" + version "5.62.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz#aeef0328d172b9e37d9bab6dbc13b87ed88977db" + integrity sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag== + dependencies: + "@eslint-community/regexpp" "^4.4.0" + "@typescript-eslint/scope-manager" "5.62.0" + "@typescript-eslint/type-utils" "5.62.0" + "@typescript-eslint/utils" "5.62.0" debug "^4.3.4" + graphemer "^1.4.0" ignore "^5.2.0" natural-compare-lite "^1.4.0" - regexpp "^3.2.0" semver "^7.3.7" tsutils "^3.21.0" "@typescript-eslint/parser@^5.20.0": - version "5.49.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.49.0.tgz#d699734b2f20e16351e117417d34a2bc9d7c4b90" - integrity sha512-veDlZN9mUhGqU31Qiv2qEp+XrJj5fgZpJ8PW30sHU+j/8/e5ruAhLaVDAeznS7A7i4ucb/s8IozpDtt9NqCkZg== + version "5.62.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.62.0.tgz#1b63d082d849a2fcae8a569248fbe2ee1b8a56c7" + integrity sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA== dependencies: - "@typescript-eslint/scope-manager" "5.49.0" - "@typescript-eslint/types" "5.49.0" - "@typescript-eslint/typescript-estree" "5.49.0" + "@typescript-eslint/scope-manager" "5.62.0" + "@typescript-eslint/types" "5.62.0" + "@typescript-eslint/typescript-estree" "5.62.0" debug "^4.3.4" -"@typescript-eslint/scope-manager@5.49.0": - version "5.49.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.49.0.tgz#81b5d899cdae446c26ddf18bd47a2f5484a8af3e" - integrity sha512-clpROBOiMIzpbWNxCe1xDK14uPZh35u4QaZO1GddilEzoCLAEz4szb51rBpdgurs5k2YzPtJeTEN3qVbG+LRUQ== +"@typescript-eslint/scope-manager@5.62.0": + version "5.62.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz#d9457ccc6a0b8d6b37d0eb252a23022478c5460c" + integrity sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w== dependencies: - "@typescript-eslint/types" "5.49.0" - "@typescript-eslint/visitor-keys" "5.49.0" + "@typescript-eslint/types" "5.62.0" + "@typescript-eslint/visitor-keys" "5.62.0" -"@typescript-eslint/type-utils@5.49.0": - version "5.49.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.49.0.tgz#8d5dcc8d422881e2ccf4ebdc6b1d4cc61aa64125" - integrity sha512-eUgLTYq0tR0FGU5g1YHm4rt5H/+V2IPVkP0cBmbhRyEmyGe4XvJ2YJ6sYTmONfjmdMqyMLad7SB8GvblbeESZA== +"@typescript-eslint/type-utils@5.62.0": + version "5.62.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz#286f0389c41681376cdad96b309cedd17d70346a" + integrity sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew== dependencies: - "@typescript-eslint/typescript-estree" "5.49.0" - "@typescript-eslint/utils" "5.49.0" + "@typescript-eslint/typescript-estree" "5.62.0" + "@typescript-eslint/utils" "5.62.0" debug "^4.3.4" tsutils "^3.21.0" -"@typescript-eslint/types@5.49.0": - version "5.49.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.49.0.tgz#ad66766cb36ca1c89fcb6ac8b87ec2e6dac435c3" - integrity sha512-7If46kusG+sSnEpu0yOz2xFv5nRz158nzEXnJFCGVEHWnuzolXKwrH5Bsf9zsNlOQkyZuk0BZKKoJQI+1JPBBg== +"@typescript-eslint/types@5.62.0": + version "5.62.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.62.0.tgz#258607e60effa309f067608931c3df6fed41fd2f" + integrity sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ== -"@typescript-eslint/typescript-estree@5.49.0": - version "5.49.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.49.0.tgz#ebd6294c0ea97891fce6af536048181e23d729c8" - integrity sha512-PBdx+V7deZT/3GjNYPVQv1Nc0U46dAHbIuOG8AZ3on3vuEKiPDwFE/lG1snN2eUB9IhF7EyF7K1hmTcLztNIsA== +"@typescript-eslint/typescript-estree@5.62.0": + version "5.62.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz#7d17794b77fabcac615d6a48fb143330d962eb9b" + integrity sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA== dependencies: - "@typescript-eslint/types" "5.49.0" - "@typescript-eslint/visitor-keys" "5.49.0" + "@typescript-eslint/types" "5.62.0" + "@typescript-eslint/visitor-keys" "5.62.0" debug "^4.3.4" globby "^11.1.0" is-glob "^4.0.3" semver "^7.3.7" tsutils "^3.21.0" -"@typescript-eslint/utils@5.49.0": - version "5.49.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.49.0.tgz#1c07923bc55ff7834dfcde487fff8d8624a87b32" - integrity sha512-cPJue/4Si25FViIb74sHCLtM4nTSBXtLx1d3/QT6mirQ/c65bV8arBEebBJJizfq8W2YyMoPI/WWPFWitmNqnQ== +"@typescript-eslint/utils@5.62.0": + version "5.62.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.62.0.tgz#141e809c71636e4a75daa39faed2fb5f4b10df86" + integrity sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ== dependencies: + "@eslint-community/eslint-utils" "^4.2.0" "@types/json-schema" "^7.0.9" "@types/semver" "^7.3.12" - "@typescript-eslint/scope-manager" "5.49.0" - "@typescript-eslint/types" "5.49.0" - "@typescript-eslint/typescript-estree" "5.49.0" + "@typescript-eslint/scope-manager" "5.62.0" + "@typescript-eslint/types" "5.62.0" + "@typescript-eslint/typescript-estree" "5.62.0" eslint-scope "^5.1.1" - eslint-utils "^3.0.0" semver "^7.3.7" -"@typescript-eslint/visitor-keys@5.49.0": - version "5.49.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.49.0.tgz#2561c4da3f235f5c852759bf6c5faec7524f90fe" - integrity sha512-v9jBMjpNWyn8B6k/Mjt6VbUS4J1GvUlR4x3Y+ibnP1z7y7V4n0WRz+50DY6+Myj0UaXVSuUlHohO+eZ8IJEnkg== +"@typescript-eslint/visitor-keys@5.62.0": + version "5.62.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz#2174011917ce582875954ffe2f6912d5931e353e" + integrity sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw== dependencies: - "@typescript-eslint/types" "5.49.0" + "@typescript-eslint/types" "5.62.0" eslint-visitor-keys "^3.3.0" "@wharfkit/abicache@^1.1.1": @@ -592,10 +611,10 @@ acorn-walk@^8.1.1: resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1" integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA== -acorn@^8.4.1, acorn@^8.5.0, acorn@^8.8.0: - version "8.8.2" - resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.2.tgz#1b2f25db02af965399b9776b0c2c391276d37c4a" - integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw== +acorn@^8.4.1, acorn@^8.8.2, acorn@^8.9.0: + version "8.10.0" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.10.0.tgz#8be5b3907a67221a81ab23c7889c4c5526b62ec5" + integrity sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw== aggregate-error@^3.0.0: version "3.1.0" @@ -605,7 +624,7 @@ aggregate-error@^3.0.0: clean-stack "^2.0.0" indent-string "^4.0.0" -ajv@^6.10.0, ajv@^6.12.4: +ajv@^6.12.4: version "6.12.6" resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4" integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== @@ -625,6 +644,11 @@ ansi-regex@^5.0.1: resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== +ansi-sequence-parser@^1.1.0: + version "1.1.1" + resolved "https://registry.yarnpkg.com/ansi-sequence-parser/-/ansi-sequence-parser-1.1.1.tgz#e0aa1cdcbc8f8bb0b5bca625aac41f5f056973cf" + integrity sha512-vJXt3yiaUL4UU546s3rPXlsry/RnM730G1+HkpKE012AN0sx1eOrxSu95oKDIonskeLTijMgqWZ3uDEe3NFvyg== + ansi-styles@^3.2.1: version "3.2.1" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d" @@ -752,15 +776,15 @@ browser-stdout@1.3.1: resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60" integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw== -browserslist@^4.21.3: - version "4.21.4" - resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.21.4.tgz#e7496bbc67b9e39dd0f98565feccdcb0d4ff6987" - integrity sha512-CBHJJdDmgjl3daYjN5Cp5kbTf1mUhZoS+beLklHIvkOWscs83YAhLlF3Wsh/lciQYAcbBJgTOD44VtG31ZM4Hw== +browserslist@^4.21.9: + version "4.21.10" + resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.21.10.tgz#dbbac576628c13d3b2231332cb2ec5a46e015bb0" + integrity sha512-bipEBdZfVH5/pwrvqc+Ub0kUPVfGUhlKxbvfD+z1BDnPEO/X98ruXGA1WP5ASpAFKan7Qr6j736IacbZQuAlKQ== dependencies: - caniuse-lite "^1.0.30001400" - electron-to-chromium "^1.4.251" - node-releases "^2.0.6" - update-browserslist-db "^1.0.9" + caniuse-lite "^1.0.30001517" + electron-to-chromium "^1.4.477" + node-releases "^2.0.13" + update-browserslist-db "^1.0.11" buffer-from@^1.0.0: version "1.1.2" @@ -797,15 +821,15 @@ camelcase@^6.0.0: resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a" integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== -caniuse-lite@^1.0.30001400: - version "1.0.30001447" - resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001447.tgz#ef1f39ae38d839d7176713735a8e467a0a2523bd" - integrity sha512-bdKU1BQDPeEXe9A39xJnGtY0uRq/z5osrnXUw0TcK+EYno45Y+U7QU9HhHEyzvMDffpYadFXi3idnSNkcwLkTw== +caniuse-lite@^1.0.30001517: + version "1.0.30001524" + resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001524.tgz#1e14bce4f43c41a7deaeb5ebfe86664fe8dadb80" + integrity sha512-Jj917pJtYg9HSJBF95HVX3Cdr89JUyLT4IZ8SvM5aDRni95swKgYi3TgYLH5hnGfPE/U1dg6IfZ50UsIlLkwSA== chai@^4.3.4: - version "4.3.7" - resolved "https://registry.yarnpkg.com/chai/-/chai-4.3.7.tgz#ec63f6df01829088e8bf55fca839bcd464a8ec51" - integrity sha512-HLnAzZ2iupm25PlN0xFreAlBA5zaBSv3og0DdeGA4Ar6h6rJ3A0rolRUKJhSF2V10GZKDgWF/VmAEsNWjCRB+A== + version "4.3.8" + resolved "https://registry.yarnpkg.com/chai/-/chai-4.3.8.tgz#40c59718ad6928da6629c70496fe990b2bb5b17c" + integrity sha512-vX4YvVVtxlfSZ2VecZgFUTU5qPCYsobVI2O9FmwEXBhDigYGQA6jRXCycIs1yJnnWbZ6/+a2zNIF5DfVCcJBFQ== dependencies: assertion-error "^1.1.0" check-error "^1.0.2" @@ -815,7 +839,7 @@ chai@^4.3.4: pathval "^1.1.1" type-detect "^4.0.5" -chalk@^2.0.0: +chalk@^2.4.2: version "2.4.2" resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424" integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ== @@ -963,9 +987,9 @@ deep-is@^0.1.3: integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== deepmerge@^4.2.2: - version "4.2.2" - resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.2.2.tgz#44d2ea3679b8f4d4ffba33f03d865fc1e7bf4955" - integrity sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg== + version "4.3.1" + resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a" + integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A== default-require-extensions@^3.0.0: version "3.0.1" @@ -998,10 +1022,10 @@ doctrine@^3.0.0: dependencies: esutils "^2.0.2" -electron-to-chromium@^1.4.251: - version "1.4.284" - resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.284.tgz#61046d1e4cab3a25238f6bf7413795270f125592" - integrity sha512-M8WEXFuKXMYMVr45fo8mq0wUrrJHheiKZf6BArTKk9ZBYCKJEOU5H8cdWgDT+qCVZf7Na4lVUaZsA+h6uA9+PA== +electron-to-chromium@^1.4.477: + version "1.4.506" + resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.506.tgz#59f64a211102db4c3ebae2f39cc0e8e1b12b3a07" + integrity sha512-xxGct4GPAKSRlrLBtJxJFYy74W11zX6PO9GyHgl/U+2s3Dp0ZEwAklDfNHXOWcvH7zWMpsmgbR0ggEuaYAVvHA== elliptic@^6.5.4: version "6.5.4" @@ -1027,9 +1051,9 @@ emoji-regex@^8.0.0: integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== eosio-signing-request@^2.5.2: - version "2.5.2" - resolved "https://registry.yarnpkg.com/eosio-signing-request/-/eosio-signing-request-2.5.2.tgz#3cf53d71204d32bb5112e2ac84aba189661a630c" - integrity sha512-mkWhsjZYVfyvUujbeSBZ4u1NlT5Pks/VAT2CesUtMsffg1e4LaA2/uijrDoGNkhRzVv4VDxrssh9jVPdyV97rw== + version "2.5.3" + resolved "https://registry.yarnpkg.com/eosio-signing-request/-/eosio-signing-request-2.5.3.tgz#4b15bcc67d2814393a83084c45e4473d638b16e1" + integrity sha512-jb4cKjQM+NI8+JwtGClYiCDX9sgSeUreRTE7YkIAga0fo21vtLTjTn0ZUH1zyfQU5b4Drdcs/yUMXdPUtqp9bg== dependencies: "@greymass/eosio" "^0.6.0" tslib "^2.0.3" @@ -1055,9 +1079,9 @@ escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5: integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg== eslint-config-prettier@^8.1.0: - version "8.6.0" - resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-8.6.0.tgz#dec1d29ab728f4fa63061774e1672ac4e363d207" - integrity sha512-bAF0eLpLVqP5oEVUFKpMA+NnRFICwn9X8B5jrR9FcqnYBuPbqWEjTEspPWMj5ye6czoSLDweCzSo3Ko7gGrZaA== + version "8.10.0" + resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-8.10.0.tgz#3a06a662130807e2502fc3ff8b4143d8a0658e11" + integrity sha512-SM8AMJdeQqRYT9O9zguiruQZaN7+z+E4eAP9oiLNGKMtomwaB1E9dcgUD6ZAn/eQAb52USbvezbiljfZUhbJcg== eslint-plugin-prettier@^4.0.0: version "4.2.1" @@ -1074,94 +1098,80 @@ eslint-scope@^5.1.1: esrecurse "^4.3.0" estraverse "^4.1.1" -eslint-scope@^7.1.1: - version "7.1.1" - resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.1.1.tgz#fff34894c2f65e5226d3041ac480b4513a163642" - integrity sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw== +eslint-scope@^7.2.2: + version "7.2.2" + resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.2.2.tgz#deb4f92563390f32006894af62a22dba1c46423f" + integrity sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg== dependencies: esrecurse "^4.3.0" estraverse "^5.2.0" -eslint-utils@^3.0.0: - version "3.0.0" - resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-3.0.0.tgz#8aebaface7345bb33559db0a1f13a1d2d48c3672" - integrity sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA== - dependencies: - eslint-visitor-keys "^2.0.0" - -eslint-visitor-keys@^2.0.0: - version "2.1.0" - resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz#f65328259305927392c938ed44eb0a5c9b2bd303" - integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw== - -eslint-visitor-keys@^3.3.0: - version "3.3.0" - resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz#f6480fa6b1f30efe2d1968aa8ac745b862469826" - integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA== +eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1, eslint-visitor-keys@^3.4.3: + version "3.4.3" + resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz#0cd72fe8550e3c2eae156a96a4dddcd1c8ac5800" + integrity sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag== eslint@^8.13.0: - version "8.32.0" - resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.32.0.tgz#d9690056bb6f1a302bd991e7090f5b68fbaea861" - integrity sha512-nETVXpnthqKPFyuY2FNjz/bEd6nbosRgKbkgS/y1C7LJop96gYHWpiguLecMHQ2XCPxn77DS0P+68WzG6vkZSQ== - dependencies: - "@eslint/eslintrc" "^1.4.1" - "@humanwhocodes/config-array" "^0.11.8" + version "8.48.0" + resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.48.0.tgz#bf9998ba520063907ba7bfe4c480dc8be03c2155" + integrity sha512-sb6DLeIuRXxeM1YljSe1KEx9/YYeZFQWcV8Rq9HfigmdDEugjLEVEa1ozDjL6YDjBpQHPJxJzze+alxi4T3OLg== + dependencies: + "@eslint-community/eslint-utils" "^4.2.0" + "@eslint-community/regexpp" "^4.6.1" + "@eslint/eslintrc" "^2.1.2" + "@eslint/js" "8.48.0" + "@humanwhocodes/config-array" "^0.11.10" "@humanwhocodes/module-importer" "^1.0.1" "@nodelib/fs.walk" "^1.2.8" - ajv "^6.10.0" + ajv "^6.12.4" chalk "^4.0.0" cross-spawn "^7.0.2" debug "^4.3.2" doctrine "^3.0.0" escape-string-regexp "^4.0.0" - eslint-scope "^7.1.1" - eslint-utils "^3.0.0" - eslint-visitor-keys "^3.3.0" - espree "^9.4.0" - esquery "^1.4.0" + eslint-scope "^7.2.2" + eslint-visitor-keys "^3.4.3" + espree "^9.6.1" + esquery "^1.4.2" esutils "^2.0.2" fast-deep-equal "^3.1.3" file-entry-cache "^6.0.1" find-up "^5.0.0" glob-parent "^6.0.2" globals "^13.19.0" - grapheme-splitter "^1.0.4" + graphemer "^1.4.0" ignore "^5.2.0" - import-fresh "^3.0.0" imurmurhash "^0.1.4" is-glob "^4.0.0" is-path-inside "^3.0.3" - js-sdsl "^4.1.4" js-yaml "^4.1.0" json-stable-stringify-without-jsonify "^1.0.1" levn "^0.4.1" lodash.merge "^4.6.2" minimatch "^3.1.2" natural-compare "^1.4.0" - optionator "^0.9.1" - regexpp "^3.2.0" + optionator "^0.9.3" strip-ansi "^6.0.1" - strip-json-comments "^3.1.0" text-table "^0.2.0" -espree@^9.4.0: - version "9.4.1" - resolved "https://registry.yarnpkg.com/espree/-/espree-9.4.1.tgz#51d6092615567a2c2cff7833445e37c28c0065bd" - integrity sha512-XwctdmTO6SIvCzd9810yyNzIrOrqNYV9Koizx4C/mRhf9uq0o4yHoCEU/670pOxOL/MSraektvSAji79kX90Vg== +espree@^9.6.0, espree@^9.6.1: + version "9.6.1" + resolved "https://registry.yarnpkg.com/espree/-/espree-9.6.1.tgz#a2a17b8e434690a5432f2f8018ce71d331a48c6f" + integrity sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ== dependencies: - acorn "^8.8.0" + acorn "^8.9.0" acorn-jsx "^5.3.2" - eslint-visitor-keys "^3.3.0" + eslint-visitor-keys "^3.4.1" esprima@^4.0.0: version "4.0.1" resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71" integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== -esquery@^1.4.0: - version "1.4.0" - resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.4.0.tgz#2148ffc38b82e8c7057dfed48425b3e61f0f24a5" - integrity sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w== +esquery@^1.4.2: + version "1.5.0" + resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.5.0.tgz#6ce17738de8577694edd7361c57182ac8cb0db0b" + integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg== dependencies: estraverse "^5.1.0" @@ -1198,14 +1208,14 @@ fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== fast-diff@^1.1.2: - version "1.2.0" - resolved "https://registry.yarnpkg.com/fast-diff/-/fast-diff-1.2.0.tgz#73ee11982d86caaf7959828d519cfe927fac5f03" - integrity sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w== + version "1.3.0" + resolved "https://registry.yarnpkg.com/fast-diff/-/fast-diff-1.3.0.tgz#ece407fa550a64d638536cd727e129c61616e0f0" + integrity sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw== fast-glob@^3.2.9: - version "3.2.12" - resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.12.tgz#7f39ec99c2e6ab030337142da9e0c18f37afae80" - integrity sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w== + version "3.3.1" + resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.3.1.tgz#784b4e897340f3dbbef17413b3f11acf03c874c4" + integrity sha512-kNFPyjhh5cKjrUltxs+wFx+ZkbRaxxmZ+X0ZU31SOsxCEtP9VPgtq2teZw1DebupL5GmDaNQ6yKMMVcM41iqDg== dependencies: "@nodelib/fs.stat" "^2.0.2" "@nodelib/fs.walk" "^1.2.3" @@ -1284,11 +1294,12 @@ find-up@^4.0.0, find-up@^4.1.0: path-exists "^4.0.0" flat-cache@^3.0.4: - version "3.0.4" - resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11" - integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg== + version "3.1.0" + resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.1.0.tgz#0e54ab4a1a60fe87e2946b6b00657f1c99e1af3f" + integrity sha512-OHx4Qwrrt0E4jEIcI5/Xb+f+QmJYNj2rrK8wiIdQOIrB9WrrJL8cjZvXdXuBTkkEwEqLycb5BeZDV1o2i9bTew== dependencies: - flatted "^3.1.0" + flatted "^3.2.7" + keyv "^4.5.3" rimraf "^3.0.2" flat@^5.0.2: @@ -1296,7 +1307,7 @@ flat@^5.0.2: resolved "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz#8ca6fe332069ffa9d324c327198c598259ceb241" integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ== -flatted@^3.1.0: +flatted@^3.2.7: version "3.2.7" resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.7.tgz#609f39207cb614b89d0765b477cb2d437fbf9787" integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ== @@ -1329,9 +1340,9 @@ fs.realpath@^1.0.0: integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== fsevents@~2.3.2: - version "2.3.2" - resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a" - integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA== + version "2.3.3" + resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6" + integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw== function-bind@^1.1.1: version "1.1.1" @@ -1433,9 +1444,9 @@ globals@^11.1.0: integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== globals@^13.19.0: - version "13.19.0" - resolved "https://registry.yarnpkg.com/globals/-/globals-13.19.0.tgz#7a42de8e6ad4f7242fbcca27ea5b23aca367b5c8" - integrity sha512-dkQ957uSRWHw7CFXLUtUHQI3g3aWApYhfNR2O6jn/907riyTYKVBmxYVROkBcY614FSSeSJh7Xm7SrUWCxvJMQ== + version "13.21.0" + resolved "https://registry.yarnpkg.com/globals/-/globals-13.21.0.tgz#163aae12f34ef502f5153cfbdd3600f36c63c571" + integrity sha512-ybyme3s4yy/t/3s35bewwXKOf7cvzfreG2lH0lZl0JB7I4GxRP2ghxOK/Nb9EkRXdbBXZLfq/p/0W2JUONB/Gg== dependencies: type-fest "^0.20.2" @@ -1463,14 +1474,14 @@ globby@^6.1.0: pinkie-promise "^2.0.0" graceful-fs@^4.1.15, graceful-fs@^4.1.6, graceful-fs@^4.2.0: - version "4.2.10" - resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz#147d3a006da4ca3ce14728c7aefc287c367d7a6c" - integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA== + version "4.2.11" + resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3" + integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== -grapheme-splitter@^1.0.4: - version "1.0.4" - resolved "https://registry.yarnpkg.com/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz#9cf3a665c6247479896834af35cf1dbb4400767e" - integrity sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ== +graphemer@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/graphemer/-/graphemer-1.4.0.tgz#fb2f1d55e0e3a1849aeffc90c4fa0dd53a0e66c6" + integrity sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag== has-flag@^3.0.0: version "3.0.0" @@ -1529,7 +1540,7 @@ ignore@^5.2.0: resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324" integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ== -import-fresh@^3.0.0, import-fresh@^3.2.1: +import-fresh@^3.2.1: version "3.3.0" resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b" integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw== @@ -1567,17 +1578,17 @@ is-binary-path@~2.1.0: dependencies: binary-extensions "^2.0.0" -is-builtin-module@^3.2.0: - version "3.2.0" - resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-3.2.0.tgz#bb0310dfe881f144ca83f30100ceb10cf58835e0" - integrity sha512-phDA4oSGt7vl1n5tJvTWooWWAsXLY+2xCnxNqvKhGEzujg+A43wPlPOyDg3C8XQHN+6k/JTQWJ/j0dQh/qr+Hw== +is-builtin-module@^3.2.1: + version "3.2.1" + resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-3.2.1.tgz#f03271717d8654cfcaf07ab0463faa3571581169" + integrity sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A== dependencies: builtin-modules "^3.3.0" -is-core-module@^2.9.0: - version "2.11.0" - resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.11.0.tgz#ad4cb3e3863e814523c96f3f58d26cc570ff0144" - integrity sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw== +is-core-module@^2.13.0: + version "2.13.0" + resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.13.0.tgz#bb52aa6e2cbd49a30c2ba68c42bf3435ba6072db" + integrity sha512-Z7dk6Qo8pOCp3l4tsX2C5ZVas4V+UxwQodwZhLopL91TX8UyyHEXafPcyoeeWuLrwzHcr3igO78wNLwHJHsMCQ== dependencies: has "^1.0.3" @@ -1685,12 +1696,12 @@ istanbul-lib-processinfo@^2.0.2: uuid "^8.3.2" istanbul-lib-report@^3.0.0: - version "3.0.0" - resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#7518fe52ea44de372f460a76b5ecda9ffb73d8a6" - integrity sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw== + version "3.0.1" + resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz#908305bac9a5bd175ac6a74489eafd0fc2445a7d" + integrity sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw== dependencies: istanbul-lib-coverage "^3.0.0" - make-dir "^3.0.0" + make-dir "^4.0.0" supports-color "^7.1.0" istanbul-lib-source-maps@^4.0.0: @@ -1703,9 +1714,9 @@ istanbul-lib-source-maps@^4.0.0: source-map "^0.6.1" istanbul-reports@^3.0.2: - version "3.1.5" - resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.1.5.tgz#cc9a6ab25cb25659810e4785ed9d9fb742578bae" - integrity sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w== + version "3.1.6" + resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.1.6.tgz#2544bcab4768154281a2f0870471902704ccaa1a" + integrity sha512-TLgnMkKg3iTDsQ9PbPTdpfAK2DzjF9mqUG7RMgcQl8oFjad8ob4laGxv5XV5U9MAfx8D6tSJiUyuAwzLicaxlg== dependencies: html-escaper "^2.0.0" istanbul-lib-report "^3.0.0" @@ -1719,11 +1730,6 @@ jest-worker@^26.2.1: merge-stream "^2.0.0" supports-color "^7.0.0" -js-sdsl@^4.1.4: - version "4.3.0" - resolved "https://registry.yarnpkg.com/js-sdsl/-/js-sdsl-4.3.0.tgz#aeefe32a451f7af88425b11fdb5f58c90ae1d711" - integrity sha512-mifzlm2+5nZ+lEcLJMoBK0/IH/bDg8XnJfd/Wq6IP+xoCjLZsTOnV2QpxlVbX9bMnkl5PdEjNtBJ9Cj1NjifhQ== - js-tokens@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" @@ -1749,6 +1755,11 @@ jsesc@^2.5.1: resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4" integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA== +json-buffer@3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.1.tgz#9338802a30d3b6605fbe0613e094008ca8c05a13" + integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ== + json-schema-traverse@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660" @@ -1759,7 +1770,7 @@ json-stable-stringify-without-jsonify@^1.0.1: resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651" integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw== -json5@^2.2.2: +json5@^2.2.2, json5@^2.2.3: version "2.2.3" resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283" integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg== @@ -1776,6 +1787,13 @@ jsonfile@^4.0.0: optionalDependencies: graceful-fs "^4.1.6" +keyv@^4.5.3: + version "4.5.3" + resolved "https://registry.yarnpkg.com/keyv/-/keyv-4.5.3.tgz#00873d2b046df737963157bd04f294ca818c9c25" + integrity sha512-QCiSav9WaX1PgETJ+SpNnx2PRRapJ/oRSXM4VO5OGYGSjrxbKPVFVhB3l2OCbLCk329N8qyAtsJjSjvVBWzEug== + dependencies: + json-buffer "3.0.1" + levn@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade" @@ -1854,6 +1872,13 @@ magic-string@^0.27.0: dependencies: "@jridgewell/sourcemap-codec" "^1.4.13" +magic-string@^0.30.2: + version "0.30.3" + resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.30.3.tgz#403755dfd9d6b398dfa40635d52e96c5ac095b85" + integrity sha512-B7xGbll2fG/VjP+SWg4sX3JynwIU0mjoTc6MPpKNuIvftk6u6vqhDnk1R80b8C2GBR6ywqy+1DcKBrevBg+bmw== + dependencies: + "@jridgewell/sourcemap-codec" "^1.4.15" + make-dir@^3.0.0, make-dir@^3.0.2: version "3.1.0" resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f" @@ -1861,15 +1886,22 @@ make-dir@^3.0.0, make-dir@^3.0.2: dependencies: semver "^6.0.0" +make-dir@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-4.0.0.tgz#c3c2307a771277cd9638305f915c29ae741b614e" + integrity sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw== + dependencies: + semver "^7.5.3" + make-error@^1.1.1: version "1.3.6" resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2" integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== -marked@^4.2.5: - version "4.2.12" - resolved "https://registry.yarnpkg.com/marked/-/marked-4.2.12.tgz#d69a64e21d71b06250da995dcd065c11083bebb5" - integrity sha512-yr8hSKa3Fv4D3jdZmtMMPghgVt6TWbk86WQaWhDloQjRSQhMMYCAro7jP7VDJrjjdV8pxVxMssXS8B8Y5DZ5aw== +marked@^4.2.12: + version "4.3.0" + resolved "https://registry.yarnpkg.com/marked/-/marked-4.3.0.tgz#796362821b019f734054582038b116481b456cf3" + integrity sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A== merge-stream@^2.0.0: version "2.0.0" @@ -1918,17 +1950,24 @@ minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2: dependencies: brace-expansion "^1.1.7" -minimatch@^5.0.1, minimatch@^5.1.2: +minimatch@^5.0.1: version "5.1.6" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-5.1.6.tgz#1cfcb8cf5522ea69952cd2af95ae09477f122a96" integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g== dependencies: brace-expansion "^2.0.1" +minimatch@^7.1.3: + version "7.4.6" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-7.4.6.tgz#845d6f254d8f4a5e4fd6baf44d5f10c8448365fb" + integrity sha512-sBz8G/YjVniEz6lKPNpKxXwazJe4c19fEfV2GDMX6AjFz+MX9uDWIZW8XreVhkFW3fkIdTv/gxWr/Kks5FFAVw== + dependencies: + brace-expansion "^2.0.1" + minimist@^1.2.6: - version "1.2.7" - resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.7.tgz#daa1c4d91f507390437c6a8bc01078e7000c4d18" - integrity sha512-bzfL1YUZsP41gmu/qjrEk0Q6i2ix/cVeAhbCbqH9u3zYutS1cLg00qhrD0M2MVdCcx4Sc0UpP2eBWo9rotpq6g== + version "1.2.8" + resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" + integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== mocha@^10.0.0: version "10.2.0" @@ -1983,9 +2022,9 @@ natural-compare@^1.4.0: integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== node-fetch@^2.6.1: - version "2.6.8" - resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.8.tgz#a68d30b162bc1d8fd71a367e81b997e1f4d4937e" - integrity sha512-RZ6dBYuj8dRSfxpUSu+NsdF1dpPpluJxwOp+6IoDp/sH2QNDSvurYsAa+F1WxY2RjA1iP93xhcsUoYbF2XBqVg== + version "2.7.0" + resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.7.0.tgz#d0f0fa6e3e2dc1d27efcd8ad99d550bda94d187d" + integrity sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A== dependencies: whatwg-url "^5.0.0" @@ -1996,10 +2035,10 @@ node-preload@^0.2.1: dependencies: process-on-spawn "^1.0.0" -node-releases@^2.0.6: - version "2.0.8" - resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.8.tgz#0f349cdc8fcfa39a92ac0be9bc48b7706292b9ae" - integrity sha512-dFSmB8fFHEH/s81Xi+Y/15DQY6VHW81nXRj86EMSL3lmuTmK1e+aT4wrFCkTbm+gSwkw4KpX+rT/pMM2c1mF+A== +node-releases@^2.0.13: + version "2.0.13" + resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.13.tgz#d5ed1627c23e3461e819b02e57b75e4899b1c81d" + integrity sha512-uYr7J37ae/ORWdZeQ1xxMJe3NtdmqMC/JZK+geofDrkLUApKRHPd18/TxtBOJ4A0/+uUIliorNrfYV6s1b02eQ== normalize-path@^3.0.0, normalize-path@~3.0.0: version "3.0.0" @@ -2051,17 +2090,17 @@ once@^1.3.0: dependencies: wrappy "1" -optionator@^0.9.1: - version "0.9.1" - resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499" - integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw== +optionator@^0.9.3: + version "0.9.3" + resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.3.tgz#007397d44ed1872fdc6ed31360190f81814e2c64" + integrity sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg== dependencies: + "@aashutoshrathi/word-wrap" "^1.2.3" deep-is "^0.1.3" fast-levenshtein "^2.0.6" levn "^0.4.1" prelude-ls "^1.2.1" type-check "^0.4.0" - word-wrap "^1.2.3" p-limit@^2.2.0: version "2.3.0" @@ -2202,9 +2241,9 @@ prettier-linter-helpers@^1.0.0: fast-diff "^1.1.2" prettier@^2.2.1: - version "2.8.3" - resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.3.tgz#ab697b1d3dd46fb4626fbe2f543afe0cc98d8632" - integrity sha512-tJ/oJ4amDihPoufT5sM0Z1SKEuKay8LfVAMlbbhnnkvt6BUserZylqo2PN+p9KeljLr0OHa2rXHU1T8reeoTrw== + version "2.8.8" + resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.8.tgz#e8c5d7e98a4305ffe3de2e1fc4aca1a71c28b1da" + integrity sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q== process-on-spawn@^1.0.0: version "1.0.0" @@ -2237,11 +2276,6 @@ readdirp@~3.6.0: dependencies: picomatch "^2.2.1" -regexpp@^3.2.0: - version "3.2.0" - resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2" - integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg== - release-zalgo@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/release-zalgo/-/release-zalgo-1.0.0.tgz#09700b7e5074329739330e535c5a90fb67851730" @@ -2270,11 +2304,11 @@ resolve-from@^5.0.0: integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== resolve@^1.22.1: - version "1.22.1" - resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.1.tgz#27cb2ebb53f91abb49470a928bba7558066ac177" - integrity sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw== + version "1.22.4" + resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.4.tgz#1dc40df46554cdaf8948a486a10f6ba1e2026c34" + integrity sha512-PXNdCiPqDqeUou+w1C2eTQbNfxKSuMxqTCuvlmmMsk1NWHL5fRrhY6Pl0qEYYc6+QqGClco1Qj8XnjPego4wfg== dependencies: - is-core-module "^2.9.0" + is-core-module "^2.13.0" path-parse "^1.0.7" supports-preserve-symlinks-flag "^1.0.0" @@ -2291,13 +2325,13 @@ rimraf@^3.0.0, rimraf@^3.0.2: glob "^7.1.3" rollup-plugin-dts@^5.0.0: - version "5.1.1" - resolved "https://registry.yarnpkg.com/rollup-plugin-dts/-/rollup-plugin-dts-5.1.1.tgz#8cc36ab13135b77ef0cfd6107e4af561c5dffd04" - integrity sha512-zpgo52XmnLg8w4k3MScinFHZK1+ro6r7uVe34fJ0Ee8AM45FvgvTuvfWWaRgIpA4pQ1BHJuu2ospncZhkcJVeA== + version "5.3.1" + resolved "https://registry.yarnpkg.com/rollup-plugin-dts/-/rollup-plugin-dts-5.3.1.tgz#c2841269a3a5cb986b7791b0328e6a178eba108f" + integrity sha512-gusMi+Z4gY/JaEQeXnB0RUdU82h1kF0WYzCWgVmV4p3hWXqelaKuCvcJawfeg+EKn2T1Ie+YWF2OiN1/L8bTVg== dependencies: - magic-string "^0.27.0" + magic-string "^0.30.2" optionalDependencies: - "@babel/code-frame" "^7.18.6" + "@babel/code-frame" "^7.22.5" rollup-plugin-terser@^7.0.2: version "7.0.2" @@ -2310,9 +2344,9 @@ rollup-plugin-terser@^7.0.2: terser "^5.0.0" rollup@^3.2.3: - version "3.10.1" - resolved "https://registry.yarnpkg.com/rollup/-/rollup-3.10.1.tgz#56278901ed11fc2898421e8e3e2c8155bc7b40b4" - integrity sha512-3Er+yel3bZbZX1g2kjVM+FW+RUWDxbG87fcqFM5/9HbPCTpbVp6JOLn7jlxnNlbu7s/N/uDA4EV/91E2gWnxzw== + version "3.28.1" + resolved "https://registry.yarnpkg.com/rollup/-/rollup-3.28.1.tgz#fb44aa6d5e65c7e13fd5bcfff266d0c4ea9ba433" + integrity sha512-R9OMQmIHJm9znrU3m3cpE8uhN0fGdXiawME7aZIpQqvpS/85+Vt1Hq1/yVIcYfOmaQiHjvXkQAoJukvLpau6Yw== optionalDependencies: fsevents "~2.3.2" @@ -2328,15 +2362,15 @@ safe-buffer@^5.1.0: resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== -semver@^6.0.0, semver@^6.3.0: - version "6.3.0" - resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d" - integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw== +semver@^6.0.0, semver@^6.3.0, semver@^6.3.1: + version "6.3.1" + resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4" + integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA== -semver@^7.3.7: - version "7.3.8" - resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.8.tgz#07a78feafb3f7b32347d725e33de7e2a2df67798" - integrity sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A== +semver@^7.3.7, semver@^7.5.3: + version "7.5.4" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e" + integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA== dependencies: lru-cache "^6.0.0" @@ -2371,11 +2405,12 @@ shebang-regex@^3.0.0: resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== -shiki@^0.12.1: - version "0.12.1" - resolved "https://registry.yarnpkg.com/shiki/-/shiki-0.12.1.tgz#26fce51da12d055f479a091a5307470786f300cd" - integrity sha512-aieaV1m349rZINEBkjxh2QbBvFFQOlgqYTNtCal82hHj4dDZ76oMlQIX+C7ryerBTDiga3e5NfH6smjdJ02BbQ== +shiki@^0.14.1: + version "0.14.3" + resolved "https://registry.yarnpkg.com/shiki/-/shiki-0.14.3.tgz#d1a93c463942bdafb9866d74d619a4347d0bbf64" + integrity sha512-U3S/a+b0KS+UkTyMjoNojvTgrBHjgp7L6ovhFVZsXmBGnVdQ4K4U9oK0z63w538S91ATngv1vXigHCSWOwnr+g== dependencies: + ansi-sequence-parser "^1.1.0" jsonc-parser "^3.2.0" vscode-oniguruma "^1.7.0" vscode-textmate "^8.0.0" @@ -2451,7 +2486,7 @@ strip-bom@^4.0.0: resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878" integrity sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w== -strip-json-comments@3.1.1, strip-json-comments@^3.1.0, strip-json-comments@^3.1.1: +strip-json-comments@3.1.1, strip-json-comments@^3.1.1: version "3.1.1" resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006" integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== @@ -2490,12 +2525,12 @@ supports-preserve-symlinks-flag@^1.0.0: integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== terser@^5.0.0: - version "5.16.1" - resolved "https://registry.yarnpkg.com/terser/-/terser-5.16.1.tgz#5af3bc3d0f24241c7fb2024199d5c461a1075880" - integrity sha512-xvQfyfA1ayT0qdK47zskQgRZeWLoOQ8JQ6mIgRGVNwZKdQMU+5FkCBjmv4QjcrTzyZquRw2FVtlJSRUmMKQslw== + version "5.19.3" + resolved "https://registry.yarnpkg.com/terser/-/terser-5.19.3.tgz#359baeba615aef13db4b8c4d77a2aa0d8814aa9e" + integrity sha512-pQzJ9UJzM0IgmT4FAtYI6+VqFf0lj/to58AV0Xfgg0Up37RyPG7Al+1cepC6/BVuAxR9oNb41/DL4DEoHJvTdg== dependencies: - "@jridgewell/source-map" "^0.3.2" - acorn "^8.5.0" + "@jridgewell/source-map" "^0.3.3" + acorn "^8.8.2" commander "^2.20.0" source-map-support "~0.5.20" @@ -2557,9 +2592,9 @@ ts-node@^10.1.0: yn "3.1.1" tsconfig-paths@^4.0.0: - version "4.1.2" - resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-4.1.2.tgz#4819f861eef82e6da52fb4af1e8c930a39ed979a" - integrity sha512-uhxiMgnXQp1IR622dUXI+9Ehnws7i/y6xvpZB9IbUVOPy0muvdvgXeZOn88UcGPiT98Vp3rJPTa8bFoalZ3Qhw== + version "4.2.0" + resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz#ef78e19039133446d244beac0fd6a1632e2d107c" + integrity sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg== dependencies: json5 "^2.2.2" minimist "^1.2.6" @@ -2571,9 +2606,9 @@ tslib@^1.8.1: integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== tslib@^2.0.3, tslib@^2.1.0: - version "2.4.1" - resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.4.1.tgz#0d0bfbaac2880b91e22df0768e55be9753a5b17e" - integrity sha512-tGyy4dAjRIEwI7BzsB0lynWgOpfqjUdq91XXAlIWD2OwKBH7oCl/GZG/HT4BOHrTlPMOASlMQ7veyTqpmRcrNA== + version "2.6.2" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.2.tgz#703ac29425e7b37cd6fd456e92404d46d1f3e4ae" + integrity sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q== tsutils@^3.21.0: version "3.21.0" @@ -2612,29 +2647,29 @@ typedarray-to-buffer@^3.1.5: is-typedarray "^1.0.0" typedoc@^0.23.14: - version "0.23.24" - resolved "https://registry.yarnpkg.com/typedoc/-/typedoc-0.23.24.tgz#01cf32c09f2c19362e72a9ce1552d6e5b48c4fef" - integrity sha512-bfmy8lNQh+WrPYcJbtjQ6JEEsVl/ce1ZIXyXhyW+a1vFrjO39t6J8sL/d6FfAGrJTc7McCXgk9AanYBSNvLdIA== + version "0.23.28" + resolved "https://registry.yarnpkg.com/typedoc/-/typedoc-0.23.28.tgz#3ce9c36ef1c273fa849d2dea18651855100d3ccd" + integrity sha512-9x1+hZWTHEQcGoP7qFmlo4unUoVJLB0H/8vfO/7wqTnZxg4kPuji9y3uRzEu0ZKez63OJAUmiGhUrtukC6Uj3w== dependencies: lunr "^2.3.9" - marked "^4.2.5" - minimatch "^5.1.2" - shiki "^0.12.1" + marked "^4.2.12" + minimatch "^7.1.3" + shiki "^0.14.1" typescript@^4.1.2: - version "4.9.4" - resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.9.4.tgz#a2a3d2756c079abda241d75f149df9d561091e78" - integrity sha512-Uz+dTXYzxXXbsFpM86Wh3dKCxrQqUcVMxwU54orwlJjOpO3ao8L7j5lH+dWfTwgCwIuM9GQ2kvVotzYJMXTBZg== + version "4.9.5" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.9.5.tgz#095979f9bcc0d09da324d58d03ce8f8374cbe65a" + integrity sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g== universalify@^0.1.0: version "0.1.2" resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66" integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg== -update-browserslist-db@^1.0.9: - version "1.0.10" - resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz#0f54b876545726f17d00cd9a2561e6dade943ff3" - integrity sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ== +update-browserslist-db@^1.0.11: + version "1.0.11" + resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.11.tgz#9a2a641ad2907ae7b3616506f4b977851db5b940" + integrity sha512-dCwEFf0/oT85M1fHBg4F0jtLwJrutGoHSQXCh7u4o2t1drG+c0a9Flnqww6XUKSfQMPpJBRjU8d4RXB09qtvaA== dependencies: escalade "^3.1.1" picocolors "^1.0.0" @@ -2680,9 +2715,9 @@ whatwg-url@^5.0.0: webidl-conversions "^3.0.0" which-module@^2.0.0: - version "2.0.0" - resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.0.tgz#d9ef07dce77b9902b8a3a8fa4b31c3e3f7e6e87a" - integrity sha512-B+enWhmw6cjfVC7kS8Pj9pCrKSc5txArRyaYGe088shv/FGWH+0Rjx/xPgtsWfsUtS27FkP697E4DDhgrgoc0Q== + version "2.0.1" + resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.1.tgz#776b1fe35d90aebe99e8ac15eb24093389a4a409" + integrity sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ== which@^2.0.1: version "2.0.2" @@ -2691,11 +2726,6 @@ which@^2.0.1: dependencies: isexe "^2.0.0" -word-wrap@^1.2.3: - version "1.2.3" - resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c" - integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ== - workerpool@6.2.1: version "6.2.1" resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.2.1.tgz#46fc150c17d826b86a008e5a4508656777e9c343" From 0354d2a3b2553a841b2172db8873aa63c913d1ed Mon Sep 17 00:00:00 2001 From: dafuga Date: Wed, 30 Aug 2023 23:23:13 -0700 Subject: [PATCH 03/10] chore: added unit tests for AccountKit --- Makefile | 4 +- ...1e7695d5c028152f877e9d67b3b8a570ed634.json | 32 ++++++++++++ test/{ => tests}/account.ts | 8 ++- test/tests/kit.ts | 49 +++++++++++++++++++ test/{ => tests}/permissions.ts | 4 +- test/tsconfig.json | 2 +- test/{ => utils}/mock-data.ts | 2 +- 7 files changed, 90 insertions(+), 11 deletions(-) create mode 100644 test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json rename test/{ => tests}/account.ts (93%) create mode 100644 test/tests/kit.ts rename test/{ => tests}/permissions.ts (97%) rename test/{ => utils}/mock-data.ts (97%) diff --git a/Makefile b/Makefile index a54836e..37ec601 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ SHELL := /bin/bash SRC_FILES := $(shell find src -name '*.ts') -TEST_FILES := $(wildcard test/*.ts) +TEST_FILES := $(wildcard test/tests/*.ts) BIN := ./node_modules/.bin MOCHA_OPTS := -u tdd -r ts-node/register -r tsconfig-paths/register --extension ts NYC_OPTS := --temp-dir build/nyc_output --report-dir build/coverage @@ -11,7 +11,7 @@ lib: ${SRC_FILES} package.json tsconfig.json node_modules rollup.config.mjs .PHONY: test test: node_modules @TS_NODE_PROJECT='./test/tsconfig.json' \ - ${BIN}/mocha ${MOCHA_OPTS} test/*.ts --grep '$(grep)' + ${BIN}/mocha ${MOCHA_OPTS} test/tests/*.ts --grep '$(grep)' build/coverage: ${SRC_FILES} ${TEST_FILES} node_modules @TS_NODE_PROJECT='./test/tsconfig.json' \ diff --git a/test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json b/test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json new file mode 100644 index 0000000..e34b15f --- /dev/null +++ b/test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json @@ -0,0 +1,32 @@ +{ + "headers": { + "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", + "access-control-allow-methods": "GET, POST, OPTIONS", + "access-control-allow-origin": "*", + "connection": "close", + "content-length": "489", + "content-type": "application/json", + "date": "Thu, 31 Aug 2023 06:13:20 GMT", + "server": "nginx", + "x-cached": "MISS" + }, + "status": 500, + "json": { + "code": 500, + "message": "Internal Service Error", + "error": { + "code": 0, + "name": "exception", + "what": "unspecified", + "details": [ + { + "message": "unknown key (boost::tuples::tuple): (0 nonexistent)", + "file": "http_plugin.cpp", + "line_number": 519, + "method": "handle_exception" + } + ] + } + }, + "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":0,\"name\":\"exception\",\"what\":\"unspecified\",\"details\":[{\"message\":\"unknown key (boost::tuples::tuple): (0 nonexistent)\",\"file\":\"http_plugin.cpp\",\"line_number\":519,\"method\":\"handle_exception\"}]}}" +} \ No newline at end of file diff --git a/test/account.ts b/test/tests/account.ts similarity index 93% rename from test/account.ts rename to test/tests/account.ts index 44aac5f..7659729 100644 --- a/test/account.ts +++ b/test/tests/account.ts @@ -1,11 +1,9 @@ import {assert} from 'chai' import {API, APIClient} from '@wharfkit/antelope' -import {Account} from '../src/account' -import {AccountKit} from '../src/kit' -import {Permission} from '../src/permission' -import {MockProvider} from './utils/mock-provider' -import {deserializedMockAccountObject} from './mock-data' +import {Account, AccountKit, Permission} from '../../src' +import {MockProvider} from '../utils/mock-provider' +import {deserializedMockAccountObject} from '../utils/mock-data' const eosApiClient = new APIClient({ provider: new MockProvider('https://eos.greymass.com'), diff --git a/test/tests/kit.ts b/test/tests/kit.ts new file mode 100644 index 0000000..face5e3 --- /dev/null +++ b/test/tests/kit.ts @@ -0,0 +1,49 @@ +import {assert, expect} from 'chai' + +import { APIClient } from '@wharfkit/antelope'; + +import { Account, AccountKit } from '../../src'; +import { MockProvider } from 'test/utils/mock-provider'; + +const eosApiClient = new APIClient({ + provider: new MockProvider('https://eos.greymass.com'), +}) + +suite('AccountKit', function() { + let accountKit: AccountKit; + + this.beforeAll(function() { + const client = eosApiClient; + accountKit = new AccountKit({ client }); + }); + + suite('constructor', function() { + test('throws error if client is not provided', function() { + try { + new AccountKit({} as any) + } catch (error) { + assert.equal(error.message, 'A `client` must be passed when initializing the AccountKit.'); + } + }); + + test('sets client if provided', function() { + expect(accountKit.client).to.exist; + }); + }); + + suite('load', function() { + test('throws error if account does not exist', async function() { + try { + await accountKit.load('nonexistent'); + assert.fail(); + } catch (error) { + assert.equal(error.message, 'Account nonexistent does not exist'); + } + }); + + test('returns an Account object when account exists', async function() { + const account = await accountKit.load('teamgreymass'); + expect(account).to.be.instanceOf(Account); + }) + }); +}); diff --git a/test/permissions.ts b/test/tests/permissions.ts similarity index 97% rename from test/permissions.ts rename to test/tests/permissions.ts index 3fcd556..d932a3d 100644 --- a/test/permissions.ts +++ b/test/tests/permissions.ts @@ -1,8 +1,8 @@ import {assert} from 'chai' import {Authority, Name, NameType, AuthorityType} from '@wharfkit/antelope' -import {ActionData, Permission} from '../src/permission' -import { deserialize } from './utils/helpers' +import {ActionData, Permission} from '../../src' +import { deserialize } from '../utils/helpers' const authorityExample = { threshold: 1, diff --git a/test/tsconfig.json b/test/tsconfig.json index 8768730..7490743 100644 --- a/test/tsconfig.json +++ b/test/tsconfig.json @@ -11,5 +11,5 @@ "$lib": ["src"], } }, - "include": ["*.ts", "**/*.ts"] + "include": ["*.ts", "**/*.ts"], } diff --git a/test/mock-data.ts b/test/utils/mock-data.ts similarity index 97% rename from test/mock-data.ts rename to test/utils/mock-data.ts index 5846496..eb0c74f 100644 --- a/test/mock-data.ts +++ b/test/utils/mock-data.ts @@ -1,5 +1,5 @@ import {API, Asset, Name, TimePoint, UInt32, UInt64} from '@greymass/eosio' -import { deserialize } from './utils/helpers' +import { deserialize } from './helpers' export const mockAccountObject = API.v1.AccountObject.from({ cpu_weight: UInt64.from(236250), From 1ad3fea6f1c91b8e8db7e12b57db15a7af043b43 Mon Sep 17 00:00:00 2001 From: dafuga Date: Wed, 30 Aug 2023 23:47:16 -0700 Subject: [PATCH 04/10] chore: added unit tests for Account action methods --- test/tests/account.ts | 138 ++++++++++++++++++++++++++++++++++++++ test/tests/permissions.ts | 37 ---------- 2 files changed, 138 insertions(+), 37 deletions(-) diff --git a/test/tests/account.ts b/test/tests/account.ts index 7659729..4603fb4 100644 --- a/test/tests/account.ts +++ b/test/tests/account.ts @@ -4,6 +4,8 @@ import {API, APIClient} from '@wharfkit/antelope' import {Account, AccountKit, Permission} from '../../src' import {MockProvider} from '../utils/mock-provider' import {deserializedMockAccountObject} from '../utils/mock-data' +import { Name } from '@greymass/eosio' +import { deserialize } from 'test/utils/helpers' const eosApiClient = new APIClient({ provider: new MockProvider('https://eos.greymass.com'), @@ -65,6 +67,142 @@ suite('Account', function () { }) }) + suite('updatePermission', () => { + test('returns current Action', () => { + const permission = new Permission("permission", { + account: "............1", + parent: "............1", + permission: "............1", + authorized_by: "............1", + auth: { + accounts: [], + keys: [ + { + key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', + weight: 1, + }, + ], + threshold: 1, + waits: [], + }, + }); + const action = testAccount.updatePermission(permission); + assert.deepEqual(deserialize(action), { + account: "eosio", + authorization: [ + { + actor: "............1", + permission: "............2" + } + ], + data: "01000000000000000100000000000000010000000000000001000000010002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf010000000100000000000000", + name: "updateauth" + }); + }); + }); + + suite('removePermission', () => { + test('returns current Action', () => { + const action = testAccount.removePermission("someName"); + assert.deepEqual(deserialize(action), { + account: "eosio", + authorization: [ + { + actor: "............1", + permission: "............2" + } + ], + data: "01000000000000000000004a1aa024c50100000000000000", + name: "deleteauth" + }); + }); + }); + + suite('buyRam', () => { + test('returns current Action', () => { + const action = testAccount.buyRam("1.0000 EOS"); + assert.deepEqual(deserialize(action), { + account: "eosio", + authorization: [ + { + "actor": "............1", + "permission": "............2" + } + ], + data: "01000000000000000100000000000000102700000000000004454f5300000000", + name: "buyram" + }); + }); + }); + + suite('buyRamBytes', () => { + test('returns current Action', () => { + const action = testAccount.buyRamBytes(1024); + assert.deepEqual(deserialize(action), { + account: "eosio", + authorization: [ + { + actor: "............1", + permission: "............2" + } + ], + data: "0100000000000000010000000000000000040000", + name: "buyrambytes" + }); + }); + }); + + suite('sellRam', () => { + test('returns current Action', () => { + const action = testAccount.sellRam(1024); + assert.deepEqual(deserialize(action), { + account: "eosio", + authorization: [ + { + actor: "............1", + permission: "............2" + } + ], + data: "01000000000000000004000000000000", + name: "sellram" + }); + }); + }); + + suite('delegateResources', () => { + test('returns current Action', () => { + const action = testAccount.delegateResources("1.0000 EOS", "0.5000 EOS"); + assert.deepEqual(deserialize(action), { + account: "eosio", + authorization: [ + { + actor: "............1", + permission: "............2" + } + ], + data: "01000000000000000100000000000000881300000000000004454f5300000000102700000000000004454f530000000000", + name: "delegatebw" + }); + }); + }); + + suite('undelegateResources', () => { + test('returns current Action', () => { + const action = testAccount.undelegateResources("0.5000 EOS", "1.0000 EOS"); + assert.deepEqual(deserialize(action), { + account: "eosio", + authorization: [ + { + actor: "............1", + permission: "............2" + } + ], + data: "01000000000000000100000000000000102700000000000004454f5300000000881300000000000004454f5300000000", + name: "undelegatebw" + }); + }); + }); + suite('getBalance', function () { this.slow(200) this.timeout(5 * 1000) diff --git a/test/tests/permissions.ts b/test/tests/permissions.ts index d932a3d..ecc5a3c 100644 --- a/test/tests/permissions.ts +++ b/test/tests/permissions.ts @@ -16,43 +16,6 @@ const authorityExample = { waits: [], } -const expectedKeyData = { - data: { - array: '2,192,222,210,188,31,19,5,251,15,170,197,230,192,62,227,161,146,66,52,152,84,39,182,22,124,165,105,209,61,244,53,207', - }, - type: 'K1', -} - -const expectedWeightData = { - value: { - length: 1, - negative: 0, - red: [null], - words: [1], - }, -} - -const expectedThresholdData = { - value: { - length: 1, - negative: 0, - red: [null], - words: [1], - }, -} - -const expectedAuthorityData = { - keys: [expectedKeyData], - threshold: expectedThresholdData, -} - interface DeserializedActionData { - account: NameType - parent: NameType - permission: NameType - auth: AuthorityType - authorized_by: NameType -} - suite('Permission', function () { test('construct', function () { const permission = new Permission(Name.from('active'), { From d942c779f268cf1c7ab22fe0bf1e0113dfd300a7 Mon Sep 17 00:00:00 2001 From: dafuga Date: Wed, 30 Aug 2023 23:47:42 -0700 Subject: [PATCH 05/10] style: linted --- src/account.ts | 56 ++++++------- src/contracts/eosio.ts | 1 - src/kit.ts | 3 +- test/tests/account.ts | 163 +++++++++++++++++++------------------- test/tests/kit.ts | 59 +++++++------- test/tests/permissions.ts | 5 +- test/utils/helpers.ts | 4 +- test/utils/mock-data.ts | 2 +- 8 files changed, 145 insertions(+), 148 deletions(-) diff --git a/src/account.ts b/src/account.ts index 8fcf175..dbc8e4c 100644 --- a/src/account.ts +++ b/src/account.ts @@ -31,9 +31,9 @@ export class Account { readonly eosioContract: Eosio.Contract readonly client: APIClient - constructor({ accountData, client }: AccountArgs) { + constructor({accountData, client}: AccountArgs) { this.account_data = accountData - this.eosioContract = new Eosio.Contract({ client }) + this.eosioContract = new Eosio.Contract({client}) this.client = client } @@ -42,8 +42,8 @@ export class Account { } getPermission(permissionName: NameType): Permission { - const permissionObject = this.account_data.permissions.find( - (permission) => permission.perm_name.equals(permissionName) + const permissionObject = this.account_data.permissions.find((permission) => + permission.perm_name.equals(permissionName) ) if (!permissionObject) { @@ -57,7 +57,7 @@ export class Account { parent: permissionObject.parent, permission: permissionObject.perm_name, auth: Authority.from(permissionObject.required_auth), - authorized_by: "............1", + authorized_by: '............1', }) } @@ -67,58 +67,52 @@ export class Account { removePermission(permissionName: NameType): Action { return this.eosioContract.action('deleteauth', { - account: "............1", - authorized_by: "............1", + account: '............1', + authorized_by: '............1', permission: permissionName, }) } buyRam(amount: AssetType): Action { return this.eosioContract.action('buyram', { - payer: "............1", - receiver: "............1", + payer: '............1', + receiver: '............1', quant: amount, }) } buyRamBytes(bytes: number): Action { return this.eosioContract.action('buyrambytes', { - payer: "............1", - receiver: "............1", + payer: '............1', + receiver: '............1', bytes, }) } sellRam(bytes: number): Action { return this.eosioContract.action('sellram', { - account: "............1", + account: '............1', bytes, }) } delegateResources(cpu: AssetType, net: AssetType): Action { - return this.eosioContract.action( - 'delegatebw', - { - from: "............1", - receiver: "............1", - stake_cpu_quantity: cpu, - stake_net_quantity: net, - transfer: false, - } - ) + return this.eosioContract.action('delegatebw', { + from: '............1', + receiver: '............1', + stake_cpu_quantity: cpu, + stake_net_quantity: net, + transfer: false, + }) } undelegateResources(cpu: AssetType, net: AssetType): Action { - return this.eosioContract.action( - 'undelegatebw', - { - from: "............1", - receiver: "............1", - unstake_cpu_quantity: cpu, - unstake_net_quantity: net, - } - ) + return this.eosioContract.action('undelegatebw', { + from: '............1', + receiver: '............1', + unstake_cpu_quantity: cpu, + unstake_net_quantity: net, + }) } getResources(): Resources { diff --git a/src/contracts/eosio.ts b/src/contracts/eosio.ts index c15c6bf..126ffbd 100644 --- a/src/contracts/eosio.ts +++ b/src/contracts/eosio.ts @@ -1536,4 +1536,3 @@ export namespace Eosio { } } export default Eosio - diff --git a/src/kit.ts b/src/kit.ts index 738574b..e618c4c 100644 --- a/src/kit.ts +++ b/src/kit.ts @@ -1,4 +1,3 @@ - import {APIClient, Name, NameType} from '@wharfkit/antelope' import {Account} from './account' @@ -39,4 +38,4 @@ export class AccountKit { client: this.client, }) } -} \ No newline at end of file +} diff --git a/test/tests/account.ts b/test/tests/account.ts index 4603fb4..d41ff7d 100644 --- a/test/tests/account.ts +++ b/test/tests/account.ts @@ -4,8 +4,8 @@ import {API, APIClient} from '@wharfkit/antelope' import {Account, AccountKit, Permission} from '../../src' import {MockProvider} from '../utils/mock-provider' import {deserializedMockAccountObject} from '../utils/mock-data' -import { Name } from '@greymass/eosio' -import { deserialize } from 'test/utils/helpers' +import {Name} from '@greymass/eosio' +import {deserialize} from 'test/utils/helpers' const eosApiClient = new APIClient({ provider: new MockProvider('https://eos.greymass.com'), @@ -15,11 +15,14 @@ suite('Account', function () { let testAccount: Account this.beforeAll(async function () { - testAccount = await (new AccountKit({client: eosApiClient})).load('teamgreymass') + testAccount = await new AccountKit({client: eosApiClient}).load('teamgreymass') }) test('construct', function () { - const account = new Account({ client: eosApiClient, accountData: deserializedMockAccountObject}) + const account = new Account({ + client: eosApiClient, + accountData: deserializedMockAccountObject, + }) assert.instanceOf(account, Account) }) @@ -69,11 +72,11 @@ suite('Account', function () { suite('updatePermission', () => { test('returns current Action', () => { - const permission = new Permission("permission", { - account: "............1", - parent: "............1", - permission: "............1", - authorized_by: "............1", + const permission = new Permission('permission', { + account: '............1', + parent: '............1', + permission: '............1', + authorized_by: '............1', auth: { accounts: [], keys: [ @@ -85,123 +88,123 @@ suite('Account', function () { threshold: 1, waits: [], }, - }); - const action = testAccount.updatePermission(permission); + }) + const action = testAccount.updatePermission(permission) assert.deepEqual(deserialize(action), { - account: "eosio", + account: 'eosio', authorization: [ { - actor: "............1", - permission: "............2" - } + actor: '............1', + permission: '............2', + }, ], - data: "01000000000000000100000000000000010000000000000001000000010002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf010000000100000000000000", - name: "updateauth" - }); - }); - }); + data: '01000000000000000100000000000000010000000000000001000000010002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf010000000100000000000000', + name: 'updateauth', + }) + }) + }) suite('removePermission', () => { test('returns current Action', () => { - const action = testAccount.removePermission("someName"); + const action = testAccount.removePermission('someName') assert.deepEqual(deserialize(action), { - account: "eosio", + account: 'eosio', authorization: [ { - actor: "............1", - permission: "............2" - } + actor: '............1', + permission: '............2', + }, ], - data: "01000000000000000000004a1aa024c50100000000000000", - name: "deleteauth" - }); - }); - }); + data: '01000000000000000000004a1aa024c50100000000000000', + name: 'deleteauth', + }) + }) + }) suite('buyRam', () => { test('returns current Action', () => { - const action = testAccount.buyRam("1.0000 EOS"); + const action = testAccount.buyRam('1.0000 EOS') assert.deepEqual(deserialize(action), { - account: "eosio", + account: 'eosio', authorization: [ { - "actor": "............1", - "permission": "............2" - } + actor: '............1', + permission: '............2', + }, ], - data: "01000000000000000100000000000000102700000000000004454f5300000000", - name: "buyram" - }); - }); - }); + data: '01000000000000000100000000000000102700000000000004454f5300000000', + name: 'buyram', + }) + }) + }) suite('buyRamBytes', () => { test('returns current Action', () => { - const action = testAccount.buyRamBytes(1024); + const action = testAccount.buyRamBytes(1024) assert.deepEqual(deserialize(action), { - account: "eosio", + account: 'eosio', authorization: [ { - actor: "............1", - permission: "............2" - } + actor: '............1', + permission: '............2', + }, ], - data: "0100000000000000010000000000000000040000", - name: "buyrambytes" - }); - }); - }); + data: '0100000000000000010000000000000000040000', + name: 'buyrambytes', + }) + }) + }) suite('sellRam', () => { test('returns current Action', () => { - const action = testAccount.sellRam(1024); + const action = testAccount.sellRam(1024) assert.deepEqual(deserialize(action), { - account: "eosio", + account: 'eosio', authorization: [ { - actor: "............1", - permission: "............2" - } + actor: '............1', + permission: '............2', + }, ], - data: "01000000000000000004000000000000", - name: "sellram" - }); - }); - }); + data: '01000000000000000004000000000000', + name: 'sellram', + }) + }) + }) suite('delegateResources', () => { test('returns current Action', () => { - const action = testAccount.delegateResources("1.0000 EOS", "0.5000 EOS"); + const action = testAccount.delegateResources('1.0000 EOS', '0.5000 EOS') assert.deepEqual(deserialize(action), { - account: "eosio", + account: 'eosio', authorization: [ { - actor: "............1", - permission: "............2" - } + actor: '............1', + permission: '............2', + }, ], - data: "01000000000000000100000000000000881300000000000004454f5300000000102700000000000004454f530000000000", - name: "delegatebw" - }); - }); - }); + data: '01000000000000000100000000000000881300000000000004454f5300000000102700000000000004454f530000000000', + name: 'delegatebw', + }) + }) + }) suite('undelegateResources', () => { test('returns current Action', () => { - const action = testAccount.undelegateResources("0.5000 EOS", "1.0000 EOS"); + const action = testAccount.undelegateResources('0.5000 EOS', '1.0000 EOS') assert.deepEqual(deserialize(action), { - account: "eosio", + account: 'eosio', authorization: [ { - actor: "............1", - permission: "............2" - } + actor: '............1', + permission: '............2', + }, ], - data: "01000000000000000100000000000000102700000000000004454f5300000000881300000000000004454f5300000000", - name: "undelegatebw" - }); - }); - }); + data: '01000000000000000100000000000000102700000000000004454f5300000000881300000000000004454f5300000000', + name: 'undelegatebw', + }) + }) + }) suite('getBalance', function () { this.slow(200) diff --git a/test/tests/kit.ts b/test/tests/kit.ts index face5e3..b872015 100644 --- a/test/tests/kit.ts +++ b/test/tests/kit.ts @@ -1,49 +1,52 @@ import {assert, expect} from 'chai' -import { APIClient } from '@wharfkit/antelope'; +import {APIClient} from '@wharfkit/antelope' -import { Account, AccountKit } from '../../src'; -import { MockProvider } from 'test/utils/mock-provider'; +import {Account, AccountKit} from '../../src' +import {MockProvider} from 'test/utils/mock-provider' const eosApiClient = new APIClient({ provider: new MockProvider('https://eos.greymass.com'), }) -suite('AccountKit', function() { - let accountKit: AccountKit; +suite('AccountKit', function () { + let accountKit: AccountKit - this.beforeAll(function() { - const client = eosApiClient; - accountKit = new AccountKit({ client }); - }); + this.beforeAll(function () { + const client = eosApiClient + accountKit = new AccountKit({client}) + }) - suite('constructor', function() { - test('throws error if client is not provided', function() { + suite('constructor', function () { + test('throws error if client is not provided', function () { try { new AccountKit({} as any) } catch (error) { - assert.equal(error.message, 'A `client` must be passed when initializing the AccountKit.'); + assert.equal( + error.message, + 'A `client` must be passed when initializing the AccountKit.' + ) } - }); + }) - test('sets client if provided', function() { - expect(accountKit.client).to.exist; - }); - }); + test('sets client if provided', function () { + expect(accountKit.client).to.exist + }) + }) - suite('load', function() { - test('throws error if account does not exist', async function() { + suite('load', function () { + test('throws error if account does not exist', async function () { try { - await accountKit.load('nonexistent'); - assert.fail(); + await accountKit.load('nonexistent') + assert.fail() } catch (error) { - assert.equal(error.message, 'Account nonexistent does not exist'); + assert.equal(error.message, 'Account nonexistent does not exist') } - }); + }) - test('returns an Account object when account exists', async function() { - const account = await accountKit.load('teamgreymass'); - expect(account).to.be.instanceOf(Account); + test('returns an Account object when account exists', async function () { + const account = await accountKit.load('teamgreymass') + expect(account).to.be.instanceOf(Account) }) - }); -}); + }) +}) diff --git a/test/tests/permissions.ts b/test/tests/permissions.ts index ecc5a3c..2d52faf 100644 --- a/test/tests/permissions.ts +++ b/test/tests/permissions.ts @@ -1,8 +1,8 @@ import {assert} from 'chai' -import {Authority, Name, NameType, AuthorityType} from '@wharfkit/antelope' +import {Authority, AuthorityType, Name, NameType} from '@wharfkit/antelope' import {ActionData, Permission} from '../../src' -import { deserialize } from '../utils/helpers' +import {deserialize} from '../utils/helpers' const authorityExample = { threshold: 1, @@ -128,4 +128,3 @@ function testPermission() { }), }) } - diff --git a/test/utils/helpers.ts b/test/utils/helpers.ts index cdfc0c0..91a2526 100644 --- a/test/utils/helpers.ts +++ b/test/utils/helpers.ts @@ -1,3 +1,3 @@ export function deserialize(data: DataType) { - return JSON.parse(JSON.stringify(data)) -} \ No newline at end of file + return JSON.parse(JSON.stringify(data)) +} diff --git a/test/utils/mock-data.ts b/test/utils/mock-data.ts index eb0c74f..5b72cc1 100644 --- a/test/utils/mock-data.ts +++ b/test/utils/mock-data.ts @@ -1,5 +1,5 @@ import {API, Asset, Name, TimePoint, UInt32, UInt64} from '@greymass/eosio' -import { deserialize } from './helpers' +import {deserialize} from './helpers' export const mockAccountObject = API.v1.AccountObject.from({ cpu_weight: UInt64.from(236250), From f2de64869d6699b28ae5438bdd20c9fc0dd773a8 Mon Sep 17 00:00:00 2001 From: dafuga Date: Wed, 30 Aug 2023 23:49:50 -0700 Subject: [PATCH 06/10] fix: fixed ci-test Makefile method --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 37ec601..c3c405e 100644 --- a/Makefile +++ b/Makefile @@ -26,7 +26,7 @@ coverage: build/coverage ci-test: node_modules @TS_NODE_PROJECT='./test/tsconfig.json' \ ${BIN}/nyc ${NYC_OPTS} --reporter=text \ - ${BIN}/mocha ${MOCHA_OPTS} -R list test/*.ts + ${BIN}/mocha ${MOCHA_OPTS} -R list test/tests/*.ts .PHONY: check check: node_modules From de298ceab6692eb23a7557e5ea938c955636dcec Mon Sep 17 00:00:00 2001 From: dafuga Date: Thu, 31 Aug 2023 00:06:30 -0700 Subject: [PATCH 07/10] cleanup: code cleanup --- test/tests/{permissions.ts => permission.ts} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename test/tests/{permissions.ts => permission.ts} (100%) diff --git a/test/tests/permissions.ts b/test/tests/permission.ts similarity index 100% rename from test/tests/permissions.ts rename to test/tests/permission.ts From baf673674e8afba899ccbb290e09d98a1276dcb9 Mon Sep 17 00:00:00 2001 From: Aaron Cox Date: Sat, 2 Sep 2023 16:04:09 -0700 Subject: [PATCH 08/10] Updating tests and adding mock-data --- Makefile | 8 ++++---- package.json | 1 + 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/Makefile b/Makefile index c3c405e..a3413d8 100644 --- a/Makefile +++ b/Makefile @@ -10,13 +10,13 @@ lib: ${SRC_FILES} package.json tsconfig.json node_modules rollup.config.mjs .PHONY: test test: node_modules - @TS_NODE_PROJECT='./test/tsconfig.json' \ + @TS_NODE_PROJECT='./test/tsconfig.json' MOCK_DIR='./test/data' \ ${BIN}/mocha ${MOCHA_OPTS} test/tests/*.ts --grep '$(grep)' build/coverage: ${SRC_FILES} ${TEST_FILES} node_modules - @TS_NODE_PROJECT='./test/tsconfig.json' \ + @TS_NODE_PROJECT='./test/tsconfig.json' MOCK_DIR='./test/data' \ ${BIN}/nyc ${NYC_OPTS} --reporter=html \ - ${BIN}/mocha ${MOCHA_OPTS} -R nyan test/*.ts + ${BIN}/mocha ${MOCHA_OPTS} -R nyan test/tests/*.ts .PHONY: coverage coverage: build/coverage @@ -24,7 +24,7 @@ coverage: build/coverage .PHONY: ci-test ci-test: node_modules - @TS_NODE_PROJECT='./test/tsconfig.json' \ + @TS_NODE_PROJECT='./test/tsconfig.json' MOCK_DIR='./test/data' \ ${BIN}/nyc ${NYC_OPTS} --reporter=text \ ${BIN}/mocha ${MOCHA_OPTS} -R list test/tests/*.ts diff --git a/package.json b/package.json index c3f74eb..17a871c 100644 --- a/package.json +++ b/package.json @@ -37,6 +37,7 @@ "@types/node": "^18.11.9", "@typescript-eslint/eslint-plugin": "^5.20.0", "@typescript-eslint/parser": "^5.20.0", + "@wharfkit/mock-data": "^1.0.2", "chai": "^4.3.4", "eslint": "^8.13.0", "eslint-config-prettier": "^8.1.0", From 47a8299a9780608043684948a70da0ca55caae68 Mon Sep 17 00:00:00 2001 From: Aaron Cox Date: Sat, 2 Sep 2023 16:05:16 -0700 Subject: [PATCH 09/10] Removed Session Kit --- package.json | 1 - 1 file changed, 1 deletion(-) diff --git a/package.json b/package.json index 17a871c..32952af 100644 --- a/package.json +++ b/package.json @@ -17,7 +17,6 @@ }, "dependencies": { "@wharfkit/antelope": "^0.7.3", - "@wharfkit/session": "^0.2.0", "@wharfkit/contract": "0.4.2", "git": "^0.1.5", "tslib": "^2.1.0" From 8a9b9829d81aebe7532763b04c0b2b84de2a88a9 Mon Sep 17 00:00:00 2001 From: Aaron Cox Date: Sat, 2 Sep 2023 17:03:46 -0700 Subject: [PATCH 10/10] Big update to mirror styles from other libs --- package.json | 2 + src/account.ts | 234 ++++--- src/contracts/eosio.ts | 6 +- src/index.ts | 1 + src/kit.ts | 26 +- src/permission.ts | 211 +++---- src/resource.ts | 50 ++ ...3515aa85d3148aedc98f52cbc3706fc33e53b.json | 85 +++ ...ce300eff8451d45f33f2c4d40bb35990f1868.json | 17 + ...4bbf54779cc94867d7eb559e69cb0cd62238.json} | 20 +- ...d407d0997a4756acbc477220ba0de7064a8b5.json | 14 + ...e5bfbeee9679a87c18073de5a96be7fe56ebe.json | 100 +++ ...d7d35b2defaefba811b35b2d09c2a5a7b6d67.json | 14 + ...7b1aaa2f758958d774220fd09a76171b37df9.json | 97 +++ ...57e23b35a734db0875477bf749505aa9a3c0a.json | 105 ++++ ...5e40a973fe2860ad803d3c20a76541d3b9392.json | 277 --------- ...72e8c80195f8444c725e12d56dd32bd74fc6e.json | 105 ++++ ...16398369b9af478c9ece8462aad7ee1fe7fb7.json | 101 +++ ...e1f53ef4cf6544fe89a0deb7a7d1043f43149.json | 32 + ...d9d71a7787aac0e342e10f4be8f132415095f.json | 18 - ...c5d3be92c14699da438430c6cdc6d776b1692.json | 97 +++ ...8039abbae9504b0188c5e3e560ef39516d35.json} | 19 +- ...17d312f52e009a605e668a07af7b68f5c8fdd.json | 16 - ...6e7528200581cc18d9d6586cac3b8e09b7663.json | 18 - ...9f667562175555c6f11cb723045a5bf8e0216.json | 12 + test/tests/account.ts | 579 +++++++++++++----- test/tests/kit.ts | 20 +- test/tests/permission.ts | 363 +++++++---- test/utils/helpers.ts | 3 - test/utils/mock-data.ts | 48 -- test/utils/mock-provider.ts | 52 -- yarn.lock | 67 +- 32 files changed, 1839 insertions(+), 970 deletions(-) create mode 100644 src/resource.ts create mode 100644 test/data/1343515aa85d3148aedc98f52cbc3706fc33e53b.json create mode 100644 test/data/2a1ce300eff8451d45f33f2c4d40bb35990f1868.json rename test/data/{c311e7695d5c028152f877e9d67b3b8a570ed634.json => 55af4bbf54779cc94867d7eb559e69cb0cd62238.json} (69%) create mode 100644 test/data/600d407d0997a4756acbc477220ba0de7064a8b5.json create mode 100644 test/data/641e5bfbeee9679a87c18073de5a96be7fe56ebe.json create mode 100644 test/data/789d7d35b2defaefba811b35b2d09c2a5a7b6d67.json create mode 100644 test/data/78f7b1aaa2f758958d774220fd09a76171b37df9.json create mode 100644 test/data/7bb57e23b35a734db0875477bf749505aa9a3c0a.json delete mode 100644 test/data/8745e40a973fe2860ad803d3c20a76541d3b9392.json create mode 100644 test/data/aaa72e8c80195f8444c725e12d56dd32bd74fc6e.json create mode 100644 test/data/b5616398369b9af478c9ece8462aad7ee1fe7fb7.json create mode 100644 test/data/b5ae1f53ef4cf6544fe89a0deb7a7d1043f43149.json delete mode 100644 test/data/c53d9d71a7787aac0e342e10f4be8f132415095f.json create mode 100644 test/data/c6bc5d3be92c14699da438430c6cdc6d776b1692.json rename test/data/{2e1bfb5d12c7491faabd3d5487c2e048e69f35aa.json => d1798039abbae9504b0188c5e3e560ef39516d35.json} (60%) delete mode 100644 test/data/de917d312f52e009a605e668a07af7b68f5c8fdd.json delete mode 100644 test/data/dfd6e7528200581cc18d9d6586cac3b8e09b7663.json create mode 100644 test/data/ea99f667562175555c6f11cb723045a5bf8e0216.json delete mode 100644 test/utils/helpers.ts delete mode 100644 test/utils/mock-data.ts delete mode 100644 test/utils/mock-provider.ts diff --git a/package.json b/package.json index 32952af..ab4a1bc 100644 --- a/package.json +++ b/package.json @@ -18,6 +18,7 @@ "dependencies": { "@wharfkit/antelope": "^0.7.3", "@wharfkit/contract": "0.4.2", + "@wharfkit/resources": "^1.0.0", "git": "^0.1.5", "tslib": "^2.1.0" }, @@ -37,6 +38,7 @@ "@typescript-eslint/eslint-plugin": "^5.20.0", "@typescript-eslint/parser": "^5.20.0", "@wharfkit/mock-data": "^1.0.2", + "@wharfkit/session": "^1.0.0", "chai": "^4.3.4", "eslint": "^8.13.0", "eslint-config-prettier": "^8.1.0", diff --git a/src/account.ts b/src/account.ts index dbc8e4c..90e71bd 100644 --- a/src/account.ts +++ b/src/account.ts @@ -4,154 +4,198 @@ import { APIClient, Asset, AssetType, - Authority, Name, NameType, + UInt32Type, } from '@wharfkit/antelope' +import {Contract} from '@wharfkit/contract' +import {Resources} from '@wharfkit/resources' import {Permission} from './permission' -import {Eosio} from './contracts/eosio' +import {SystemContract} from './contracts/eosio' +import {Resource, ResourceType} from './resource' export interface AccountArgs { - accountData: API.v1.AccountObject client: APIClient + contract?: Contract + data: API.v1.AccountObject } -export interface Resources { - cpu_available: number - cpu_used: number - net_available: number - net_used: number - ram_quota: number - ram_usage: number +export interface BuyramOptions { + receiver?: NameType +} + +export interface DelegateOptions { + from?: NameType + receiver?: NameType + cpu?: AssetType + net?: AssetType + transfer?: boolean +} + +export interface UndelegateOptions { + from?: NameType + receiver?: NameType + cpu?: AssetType + net?: AssetType } export class Account { - readonly account_data: API.v1.AccountObject - readonly eosioContract: Eosio.Contract + readonly data: API.v1.AccountObject + readonly systemContract: Contract readonly client: APIClient - constructor({accountData, client}: AccountArgs) { - this.account_data = accountData - this.eosioContract = new Eosio.Contract({client}) - this.client = client + constructor(args: AccountArgs) { + this.data = args.data + if (args.contract) { + this.systemContract = args.contract + } else { + this.systemContract = new SystemContract.Contract({client: args.client}) + } + this.client = args.client } get accountName() { - return Name.from(this.account_data.account_name) + return Name.from(this.data.account_name) } - getPermission(permissionName: NameType): Permission { - const permissionObject = this.account_data.permissions.find((permission) => + get systemToken() { + return Asset.Symbol.from(this.data.total_resources.cpu_weight.symbol) + } + + balance(contract: NameType = 'eosio.token', symbol?: Asset.SymbolType): Promise { + return new Promise((resolve, reject) => { + this.client.v1.chain + .get_currency_balance(contract, String(this.accountName), symbol && String(symbol)) + .then((balances) => { + const balance = (balances as any)[0] + + if (!balance) { + reject( + new Error( + `No balance found for ${symbol} token of ${contract} contract.` + ) + ) + } + + resolve(balance) + }) + .catch((err) => { + if ( + err.message.includes('No data') || + err.message.includes('Account Query Exception') + ) { + reject(new Error(`Token contract ${contract} does not exist.`)) + } + reject(err) + }) + }) + } + + permission(permissionName: NameType): Permission { + const permission = this.data.permissions.find((permission) => permission.perm_name.equals(permissionName) ) - if (!permissionObject) { + if (!permission) { throw new Error( `Permission ${permissionName} does not exist on account ${this.accountName}.` ) } - return new Permission(permissionName, { - account: this.accountName, - parent: permissionObject.parent, - permission: permissionObject.perm_name, - auth: Authority.from(permissionObject.required_auth), - authorized_by: '............1', - }) + return Permission.from(permission) } - updatePermission(permission: Permission): Action { - return this.eosioContract.action('updateauth', permission.actionData) + resource(resourceType: ResourceType): Resource { + return new Resource(resourceType, this.data) } - removePermission(permissionName: NameType): Action { - return this.eosioContract.action('deleteauth', { - account: '............1', - authorized_by: '............1', - permission: permissionName, + // TODO: Refactor once resources library is updated + resources(sampleAccount?: NameType) { + // Returns an instance of the @wharfkit/resources library + // configured for this blockchain/account + return new Resources({ + api: this.client, + sampleAccount: sampleAccount ? String(sampleAccount) : undefined, + symbol: this.data.core_liquid_balance + ? String(this.data.core_liquid_balance.symbol) + : undefined, }) } - buyRam(amount: AssetType): Action { - return this.eosioContract.action('buyram', { - payer: '............1', - receiver: '............1', - quant: amount, + setPermission(permission: Permission): Action { + return this.systemContract.action('updateauth', { + account: this.accountName, + auth: permission.required_auth, + authorized_by: '', + parent: permission.parent, + permission: permission.perm_name, }) } - buyRamBytes(bytes: number): Action { - return this.eosioContract.action('buyrambytes', { - payer: '............1', - receiver: '............1', - bytes, + removePermission(permissionName: NameType): Action { + return this.systemContract.action('deleteauth', { + account: this.accountName, + authorized_by: '', + permission: permissionName, }) } - sellRam(bytes: number): Action { - return this.eosioContract.action('sellram', { - account: '............1', - bytes, - }) + linkauth() { + // TODO: Implement `linkauth` action calls } - delegateResources(cpu: AssetType, net: AssetType): Action { - return this.eosioContract.action('delegatebw', { - from: '............1', - receiver: '............1', - stake_cpu_quantity: cpu, - stake_net_quantity: net, - transfer: false, - }) + unlinkauth() { + // TODO: Implement `unlinkauth` action calls } - undelegateResources(cpu: AssetType, net: AssetType): Action { - return this.eosioContract.action('undelegatebw', { - from: '............1', - receiver: '............1', - unstake_cpu_quantity: cpu, - unstake_net_quantity: net, + buyRam(amount: AssetType, options?: BuyramOptions): Action { + let receiver = this.accountName + if (options && options.receiver) { + receiver = Name.from(options.receiver) + } + return this.systemContract.action('buyram', { + payer: this.accountName, + quant: amount, + receiver, }) } - getResources(): Resources { - return { - net_available: Number(this.account_data.net_limit.available), - net_used: Number(this.account_data.net_limit.available), - cpu_available: Number(this.account_data.cpu_limit.available), - cpu_used: Number(this.account_data.cpu_limit.used), - ram_quota: Number(this.account_data.ram_quota), - ram_usage: Number(this.account_data.ram_usage), + buyRamBytes(bytes: UInt32Type, options?: BuyramOptions): Action { + let receiver = this.accountName + if (options && options.receiver) { + receiver = Name.from(options.receiver) } + return this.systemContract.action('buyrambytes', { + bytes, + payer: this.accountName, + receiver, + }) } - getBalance(contract: NameType = 'eosio.token', symbol?: Asset.SymbolType): Promise { - return new Promise((resolve, reject) => { - this.client.v1.chain - .get_currency_balance(contract, String(this.accountName), symbol && String(symbol)) - .then((balances) => { - const balance = (balances as any)[0] + sellRam(bytes: UInt32Type): Action { + return this.systemContract.action('sellram', { + account: this.accountName, + bytes, + }) + } - if (!balance) { - reject( - new Error( - `No balance found for ${symbol} token of ${contract} contract.` - ) - ) - } + delegate(value: DelegateOptions): Action { + return this.systemContract.action('delegatebw', { + from: value.from || this.accountName, + receiver: value.receiver || this.accountName, + stake_cpu_quantity: value.cpu || Asset.fromUnits(0, this.systemToken), + stake_net_quantity: value.net || Asset.fromUnits(0, this.systemToken), + transfer: value.transfer !== undefined ? value.transfer : false, + }) + } - resolve(balance) - }) - .catch((err) => { - if ( - err.message.includes('No data') || - err.message.includes('Account Query Exception') - ) { - reject(new Error(`Token contract ${contract} does not exist.`)) - } - reject(err) - }) + undelegate(value: UndelegateOptions): Action { + return this.systemContract.action('undelegatebw', { + from: value.from || this.accountName, + receiver: value.receiver || this.accountName, + unstake_cpu_quantity: value.cpu || Asset.fromUnits(0, this.systemToken), + unstake_net_quantity: value.net || Asset.fromUnits(0, this.systemToken), }) } } diff --git a/src/contracts/eosio.ts b/src/contracts/eosio.ts index 126ffbd..4627cbf 100644 --- a/src/contracts/eosio.ts +++ b/src/contracts/eosio.ts @@ -33,7 +33,7 @@ import { VarUIntType, } from '@wharfkit/antelope' import {ActionOptions, Contract as BaseContract, ContractArgs, PartialBy} from '@wharfkit/contract' -export namespace Eosio { +export namespace SystemContract { export const abiBlob = Blob.from( 'DmVvc2lvOjphYmkvMS4yAhdibG9ja19zaWduaW5nX2F1dGhvcml0eSJ2YXJpYW50X2Jsb2NrX3NpZ25pbmdfYXV0aG9yaXR5X3YwF2Jsb2NrY2hhaW5fcGFyYW1ldGVyc190GGJsb2NrY2hhaW5fcGFyYW1ldGVyc192MWcIYWJpX2hhc2gAAgVvd25lcgRuYW1lBGhhc2gLY2hlY2tzdW0yNTYIYWN0aXZhdGUAAQ5mZWF0dXJlX2RpZ2VzdAtjaGVja3N1bTI1NglhdXRob3JpdHkABAl0aHJlc2hvbGQGdWludDMyBGtleXMMa2V5X3dlaWdodFtdCGFjY291bnRzGXBlcm1pc3Npb25fbGV2ZWxfd2VpZ2h0W10Fd2FpdHMNd2FpdF93ZWlnaHRbXQpiaWRfcmVmdW5kAAIGYmlkZGVyBG5hbWUGYW1vdW50BWFzc2V0B2JpZG5hbWUAAwZiaWRkZXIEbmFtZQduZXduYW1lBG5hbWUDYmlkBWFzc2V0CWJpZHJlZnVuZAACBmJpZGRlcgRuYW1lB25ld25hbWUEbmFtZQxibG9ja19oZWFkZXIACAl0aW1lc3RhbXAGdWludDMyCHByb2R1Y2VyBG5hbWUJY29uZmlybWVkBnVpbnQxNghwcmV2aW91cwtjaGVja3N1bTI1NhF0cmFuc2FjdGlvbl9tcm9vdAtjaGVja3N1bTI1NgxhY3Rpb25fbXJvb3QLY2hlY2tzdW0yNTYQc2NoZWR1bGVfdmVyc2lvbgZ1aW50MzINbmV3X3Byb2R1Y2VycxJwcm9kdWNlcl9zY2hlZHVsZT8RYmxvY2tfaW5mb19yZWNvcmQAAwd2ZXJzaW9uBXVpbnQ4DGJsb2NrX2hlaWdodAZ1aW50MzIPYmxvY2tfdGltZXN0YW1wCnRpbWVfcG9pbnQaYmxvY2tfc2lnbmluZ19hdXRob3JpdHlfdjAAAgl0aHJlc2hvbGQGdWludDMyBGtleXMMa2V5X3dlaWdodFtdFWJsb2NrY2hhaW5fcGFyYW1ldGVycwARE21heF9ibG9ja19uZXRfdXNhZ2UGdWludDY0GnRhcmdldF9ibG9ja19uZXRfdXNhZ2VfcGN0BnVpbnQzMhltYXhfdHJhbnNhY3Rpb25fbmV0X3VzYWdlBnVpbnQzMh5iYXNlX3Blcl90cmFuc2FjdGlvbl9uZXRfdXNhZ2UGdWludDMyEG5ldF91c2FnZV9sZWV3YXkGdWludDMyI2NvbnRleHRfZnJlZV9kaXNjb3VudF9uZXRfdXNhZ2VfbnVtBnVpbnQzMiNjb250ZXh0X2ZyZWVfZGlzY291bnRfbmV0X3VzYWdlX2RlbgZ1aW50MzITbWF4X2Jsb2NrX2NwdV91c2FnZQZ1aW50MzIadGFyZ2V0X2Jsb2NrX2NwdV91c2FnZV9wY3QGdWludDMyGW1heF90cmFuc2FjdGlvbl9jcHVfdXNhZ2UGdWludDMyGW1pbl90cmFuc2FjdGlvbl9jcHVfdXNhZ2UGdWludDMyGG1heF90cmFuc2FjdGlvbl9saWZldGltZQZ1aW50MzIeZGVmZXJyZWRfdHJ4X2V4cGlyYXRpb25fd2luZG93BnVpbnQzMhVtYXhfdHJhbnNhY3Rpb25fZGVsYXkGdWludDMyFm1heF9pbmxpbmVfYWN0aW9uX3NpemUGdWludDMyF21heF9pbmxpbmVfYWN0aW9uX2RlcHRoBnVpbnQxNhNtYXhfYXV0aG9yaXR5X2RlcHRoBnVpbnQxNhhibG9ja2NoYWluX3BhcmFtZXRlcnNfdjEVYmxvY2tjaGFpbl9wYXJhbWV0ZXJzARxtYXhfYWN0aW9uX3JldHVybl92YWx1ZV9zaXplB3VpbnQzMiQGYnV5cmFtAAMFcGF5ZXIEbmFtZQhyZWNlaXZlcgRuYW1lBXF1YW50BWFzc2V0C2J1eXJhbWJ5dGVzAAMFcGF5ZXIEbmFtZQhyZWNlaXZlcgRuYW1lBWJ5dGVzBnVpbnQzMgZidXlyZXgAAgRmcm9tBG5hbWUGYW1vdW50BWFzc2V0C2NhbmNlbGRlbGF5AAIOY2FuY2VsaW5nX2F1dGgQcGVybWlzc2lvbl9sZXZlbAZ0cnhfaWQLY2hlY2tzdW0yNTYKY2ZncG93ZXJ1cAABBGFyZ3MOcG93ZXJ1cF9jb25maWcMY2xhaW1yZXdhcmRzAAEFb3duZXIEbmFtZQhjbG9zZXJleAABBW93bmVyBG5hbWUMY25jbHJleG9yZGVyAAEFb3duZXIEbmFtZQljb25uZWN0b3IAAgdiYWxhbmNlBWFzc2V0BndlaWdodAdmbG9hdDY0C2NvbnNvbGlkYXRlAAEFb3duZXIEbmFtZQpkZWZjcHVsb2FuAAMEZnJvbQRuYW1lCGxvYW5fbnVtBnVpbnQ2NAZhbW91bnQFYXNzZXQKZGVmbmV0bG9hbgADBGZyb20EbmFtZQhsb2FuX251bQZ1aW50NjQGYW1vdW50BWFzc2V0CmRlbGVnYXRlYncABQRmcm9tBG5hbWUIcmVjZWl2ZXIEbmFtZRJzdGFrZV9uZXRfcXVhbnRpdHkFYXNzZXQSc3Rha2VfY3B1X3F1YW50aXR5BWFzc2V0CHRyYW5zZmVyBGJvb2wTZGVsZWdhdGVkX2JhbmR3aWR0aAAEBGZyb20EbmFtZQJ0bwRuYW1lCm5ldF93ZWlnaHQFYXNzZXQKY3B1X3dlaWdodAVhc3NldApkZWxldGVhdXRoAAMHYWNjb3VudARuYW1lCnBlcm1pc3Npb24EbmFtZQ1hdXRob3JpemVkX2J5BW5hbWUkB2RlcG9zaXQAAgVvd25lcgRuYW1lBmFtb3VudAVhc3NldBJlb3Npb19nbG9iYWxfc3RhdGUVYmxvY2tjaGFpbl9wYXJhbWV0ZXJzDQxtYXhfcmFtX3NpemUGdWludDY0GHRvdGFsX3JhbV9ieXRlc19yZXNlcnZlZAZ1aW50NjQPdG90YWxfcmFtX3N0YWtlBWludDY0HWxhc3RfcHJvZHVjZXJfc2NoZWR1bGVfdXBkYXRlFGJsb2NrX3RpbWVzdGFtcF90eXBlGGxhc3RfcGVydm90ZV9idWNrZXRfZmlsbAp0aW1lX3BvaW50DnBlcnZvdGVfYnVja2V0BWludDY0D3BlcmJsb2NrX2J1Y2tldAVpbnQ2NBN0b3RhbF91bnBhaWRfYmxvY2tzBnVpbnQzMhV0b3RhbF9hY3RpdmF0ZWRfc3Rha2UFaW50NjQbdGhyZXNoX2FjdGl2YXRlZF9zdGFrZV90aW1lCnRpbWVfcG9pbnQbbGFzdF9wcm9kdWNlcl9zY2hlZHVsZV9zaXplBnVpbnQxNhp0b3RhbF9wcm9kdWNlcl92b3RlX3dlaWdodAdmbG9hdDY0D2xhc3RfbmFtZV9jbG9zZRRibG9ja190aW1lc3RhbXBfdHlwZRNlb3Npb19nbG9iYWxfc3RhdGUyAAURbmV3X3JhbV9wZXJfYmxvY2sGdWludDE2EWxhc3RfcmFtX2luY3JlYXNlFGJsb2NrX3RpbWVzdGFtcF90eXBlDmxhc3RfYmxvY2tfbnVtFGJsb2NrX3RpbWVzdGFtcF90eXBlHHRvdGFsX3Byb2R1Y2VyX3ZvdGVwYXlfc2hhcmUHZmxvYXQ2NAhyZXZpc2lvbgV1aW50OBNlb3Npb19nbG9iYWxfc3RhdGUzAAIWbGFzdF92cGF5X3N0YXRlX3VwZGF0ZQp0aW1lX3BvaW50HHRvdGFsX3ZwYXlfc2hhcmVfY2hhbmdlX3JhdGUHZmxvYXQ2NBNlb3Npb19nbG9iYWxfc3RhdGU0AAMPY29udGludW91c19yYXRlB2Zsb2F0NjQUaW5mbGF0aW9uX3BheV9mYWN0b3IFaW50NjQOdm90ZXBheV9mYWN0b3IFaW50NjQOZXhjaGFuZ2Vfc3RhdGUAAwZzdXBwbHkFYXNzZXQEYmFzZQljb25uZWN0b3IFcXVvdGUJY29ubmVjdG9yC2Z1bmRjcHVsb2FuAAMEZnJvbQRuYW1lCGxvYW5fbnVtBnVpbnQ2NAdwYXltZW50BWFzc2V0C2Z1bmRuZXRsb2FuAAMEZnJvbQRuYW1lCGxvYW5fbnVtBnVpbnQ2NAdwYXltZW50BWFzc2V0BGluaXQAAgd2ZXJzaW9uCXZhcnVpbnQzMgRjb3JlBnN5bWJvbAprZXlfd2VpZ2h0AAIDa2V5CnB1YmxpY19rZXkGd2VpZ2h0BnVpbnQxNgxsaW1pdGF1dGhjaGcAAwdhY2NvdW50BG5hbWULYWxsb3dfcGVybXMGbmFtZVtdDmRpc2FsbG93X3Blcm1zBm5hbWVbXQhsaW5rYXV0aAAFB2FjY291bnQEbmFtZQRjb2RlBG5hbWUEdHlwZQRuYW1lC3JlcXVpcmVtZW50BG5hbWUNYXV0aG9yaXplZF9ieQVuYW1lJAttdmZyc2F2aW5ncwACBW93bmVyBG5hbWUDcmV4BWFzc2V0C212dG9zYXZpbmdzAAIFb3duZXIEbmFtZQNyZXgFYXNzZXQIbmFtZV9iaWQABAduZXduYW1lBG5hbWULaGlnaF9iaWRkZXIEbmFtZQhoaWdoX2JpZAVpbnQ2NA1sYXN0X2JpZF90aW1lCnRpbWVfcG9pbnQKbmV3YWNjb3VudAAEB2NyZWF0b3IEbmFtZQRuYW1lBG5hbWUFb3duZXIJYXV0aG9yaXR5BmFjdGl2ZQlhdXRob3JpdHkHb25ibG9jawABBmhlYWRlcgxibG9ja19oZWFkZXIHb25lcnJvcgACCXNlbmRlcl9pZAd1aW50MTI4CHNlbnRfdHJ4BWJ5dGVzGXBhaXJfdGltZV9wb2ludF9zZWNfaW50NjQAAgVmaXJzdA50aW1lX3BvaW50X3NlYwZzZWNvbmQFaW50NjQQcGVybWlzc2lvbl9sZXZlbAACBWFjdG9yBG5hbWUKcGVybWlzc2lvbgRuYW1lF3Blcm1pc3Npb25fbGV2ZWxfd2VpZ2h0AAIKcGVybWlzc2lvbhBwZXJtaXNzaW9uX2xldmVsBndlaWdodAZ1aW50MTYHcG93ZXJ1cAAGBXBheWVyBG5hbWUIcmVjZWl2ZXIEbmFtZQRkYXlzBnVpbnQzMghuZXRfZnJhYwVpbnQ2NAhjcHVfZnJhYwVpbnQ2NAttYXhfcGF5bWVudAVhc3NldA5wb3dlcnVwX2NvbmZpZwAEA25ldBdwb3dlcnVwX2NvbmZpZ19yZXNvdXJjZQNjcHUXcG93ZXJ1cF9jb25maWdfcmVzb3VyY2UMcG93ZXJ1cF9kYXlzB3VpbnQzMj8PbWluX3Bvd2VydXBfZmVlBmFzc2V0Pxdwb3dlcnVwX2NvbmZpZ19yZXNvdXJjZQAIFGN1cnJlbnRfd2VpZ2h0X3JhdGlvBmludDY0PxN0YXJnZXRfd2VpZ2h0X3JhdGlvBmludDY0PxRhc3N1bWVkX3N0YWtlX3dlaWdodAZpbnQ2ND8QdGFyZ2V0X3RpbWVzdGFtcA90aW1lX3BvaW50X3NlYz8IZXhwb25lbnQIZmxvYXQ2ND8KZGVjYXlfc2Vjcwd1aW50MzI/CW1pbl9wcmljZQZhc3NldD8JbWF4X3ByaWNlBmFzc2V0Pw1wb3dlcnVwX29yZGVyAAYHdmVyc2lvbgV1aW50OAJpZAZ1aW50NjQFb3duZXIEbmFtZQpuZXRfd2VpZ2h0BWludDY0CmNwdV93ZWlnaHQFaW50NjQHZXhwaXJlcw50aW1lX3BvaW50X3NlYw1wb3dlcnVwX3N0YXRlAAUHdmVyc2lvbgV1aW50OANuZXQWcG93ZXJ1cF9zdGF0ZV9yZXNvdXJjZQNjcHUWcG93ZXJ1cF9zdGF0ZV9yZXNvdXJjZQxwb3dlcnVwX2RheXMGdWludDMyD21pbl9wb3dlcnVwX2ZlZQVhc3NldBZwb3dlcnVwX3N0YXRlX3Jlc291cmNlAA8HdmVyc2lvbgV1aW50OAZ3ZWlnaHQFaW50NjQMd2VpZ2h0X3JhdGlvBWludDY0FGFzc3VtZWRfc3Rha2Vfd2VpZ2h0BWludDY0FGluaXRpYWxfd2VpZ2h0X3JhdGlvBWludDY0E3RhcmdldF93ZWlnaHRfcmF0aW8FaW50NjQRaW5pdGlhbF90aW1lc3RhbXAOdGltZV9wb2ludF9zZWMQdGFyZ2V0X3RpbWVzdGFtcA50aW1lX3BvaW50X3NlYwhleHBvbmVudAdmbG9hdDY0CmRlY2F5X3NlY3MGdWludDMyCW1pbl9wcmljZQVhc3NldAltYXhfcHJpY2UFYXNzZXQLdXRpbGl6YXRpb24FaW50NjQUYWRqdXN0ZWRfdXRpbGl6YXRpb24FaW50NjQVdXRpbGl6YXRpb25fdGltZXN0YW1wDnRpbWVfcG9pbnRfc2VjC3Bvd2VydXBleGVjAAIEdXNlcgRuYW1lA21heAZ1aW50MTYNcHJvZHVjZXJfaW5mbwAJBW93bmVyBG5hbWULdG90YWxfdm90ZXMHZmxvYXQ2NAxwcm9kdWNlcl9rZXkKcHVibGljX2tleQlpc19hY3RpdmUEYm9vbAN1cmwGc3RyaW5nDXVucGFpZF9ibG9ja3MGdWludDMyD2xhc3RfY2xhaW1fdGltZQp0aW1lX3BvaW50CGxvY2F0aW9uBnVpbnQxNhJwcm9kdWNlcl9hdXRob3JpdHkYYmxvY2tfc2lnbmluZ19hdXRob3JpdHkkDnByb2R1Y2VyX2luZm8yAAMFb3duZXIEbmFtZQ12b3RlcGF5X3NoYXJlB2Zsb2F0NjQZbGFzdF92b3RlcGF5X3NoYXJlX3VwZGF0ZQp0aW1lX3BvaW50DHByb2R1Y2VyX2tleQACDXByb2R1Y2VyX25hbWUEbmFtZRFibG9ja19zaWduaW5nX2tleQpwdWJsaWNfa2V5EXByb2R1Y2VyX3NjaGVkdWxlAAIHdmVyc2lvbgZ1aW50MzIJcHJvZHVjZXJzDnByb2R1Y2VyX2tleVtdBnJlZnVuZAABBW93bmVyBG5hbWUOcmVmdW5kX3JlcXVlc3QABAVvd25lcgRuYW1lDHJlcXVlc3RfdGltZQ50aW1lX3BvaW50X3NlYwpuZXRfYW1vdW50BWFzc2V0CmNwdV9hbW91bnQFYXNzZXQLcmVncHJvZHVjZXIABAhwcm9kdWNlcgRuYW1lDHByb2R1Y2VyX2tleQpwdWJsaWNfa2V5A3VybAZzdHJpbmcIbG9jYXRpb24GdWludDE2DHJlZ3Byb2R1Y2VyMgAECHByb2R1Y2VyBG5hbWUScHJvZHVjZXJfYXV0aG9yaXR5F2Jsb2NrX3NpZ25pbmdfYXV0aG9yaXR5A3VybAZzdHJpbmcIbG9jYXRpb24GdWludDE2CHJlZ3Byb3h5AAIFcHJveHkEbmFtZQdpc3Byb3h5BGJvb2wHcmVudGNwdQAEBGZyb20EbmFtZQhyZWNlaXZlcgRuYW1lDGxvYW5fcGF5bWVudAVhc3NldAlsb2FuX2Z1bmQFYXNzZXQHcmVudG5ldAAEBGZyb20EbmFtZQhyZWNlaXZlcgRuYW1lDGxvYW5fcGF5bWVudAVhc3NldAlsb2FuX2Z1bmQFYXNzZXQLcmV4X2JhbGFuY2UABgd2ZXJzaW9uBXVpbnQ4BW93bmVyBG5hbWUKdm90ZV9zdGFrZQVhc3NldAtyZXhfYmFsYW5jZQVhc3NldAttYXR1cmVkX3JleAVpbnQ2NA5yZXhfbWF0dXJpdGllcxtwYWlyX3RpbWVfcG9pbnRfc2VjX2ludDY0W10IcmV4X2Z1bmQAAwd2ZXJzaW9uBXVpbnQ4BW93bmVyBG5hbWUHYmFsYW5jZQVhc3NldAhyZXhfbG9hbgAIB3ZlcnNpb24FdWludDgEZnJvbQRuYW1lCHJlY2VpdmVyBG5hbWUHcGF5bWVudAVhc3NldAdiYWxhbmNlBWFzc2V0DHRvdGFsX3N0YWtlZAVhc3NldAhsb2FuX251bQZ1aW50NjQKZXhwaXJhdGlvbgp0aW1lX3BvaW50CXJleF9vcmRlcgAHB3ZlcnNpb24FdWludDgFb3duZXIEbmFtZQ1yZXhfcmVxdWVzdGVkBWFzc2V0CHByb2NlZWRzBWFzc2V0DHN0YWtlX2NoYW5nZQVhc3NldApvcmRlcl90aW1lCnRpbWVfcG9pbnQHaXNfb3BlbgRib29sCHJleF9wb29sAAgHdmVyc2lvbgV1aW50OAp0b3RhbF9sZW50BWFzc2V0DHRvdGFsX3VubGVudAVhc3NldAp0b3RhbF9yZW50BWFzc2V0DnRvdGFsX2xlbmRhYmxlBWFzc2V0CXRvdGFsX3JleAVhc3NldBBuYW1lYmlkX3Byb2NlZWRzBWFzc2V0CGxvYW5fbnVtBnVpbnQ2NBJyZXhfcmV0dXJuX2J1Y2tldHMAAgd2ZXJzaW9uBXVpbnQ4DnJldHVybl9idWNrZXRzG3BhaXJfdGltZV9wb2ludF9zZWNfaW50NjRbXQ9yZXhfcmV0dXJuX3Bvb2wABwd2ZXJzaW9uBXVpbnQ4Dmxhc3RfZGlzdF90aW1lDnRpbWVfcG9pbnRfc2VjE3BlbmRpbmdfYnVja2V0X3RpbWUOdGltZV9wb2ludF9zZWMSb2xkZXN0X2J1Y2tldF90aW1lDnRpbWVfcG9pbnRfc2VjF3BlbmRpbmdfYnVja2V0X3Byb2NlZWRzBWludDY0GGN1cnJlbnRfcmF0ZV9vZl9pbmNyZWFzZQVpbnQ2NAhwcm9jZWVkcwVpbnQ2NAdyZXhleGVjAAIEdXNlcgRuYW1lA21heAZ1aW50MTYLcm12cHJvZHVjZXIAAQhwcm9kdWNlcgRuYW1lB3NlbGxyYW0AAgdhY2NvdW50BG5hbWUFYnl0ZXMFaW50NjQHc2VsbHJleAACBGZyb20EbmFtZQNyZXgFYXNzZXQGc2V0YWJpAAMHYWNjb3VudARuYW1lA2FiaQVieXRlcwRtZW1vB3N0cmluZyQKc2V0YWNjdGNwdQACB2FjY291bnQEbmFtZQpjcHVfd2VpZ2h0BmludDY0PwpzZXRhY2N0bmV0AAIHYWNjb3VudARuYW1lCm5ldF93ZWlnaHQGaW50NjQ/CnNldGFjY3RyYW0AAgdhY2NvdW50BG5hbWUJcmFtX2J5dGVzBmludDY0PwpzZXRhbGltaXRzAAQHYWNjb3VudARuYW1lCXJhbV9ieXRlcwVpbnQ2NApuZXRfd2VpZ2h0BWludDY0CmNwdV93ZWlnaHQFaW50NjQHc2V0Y29kZQAFB2FjY291bnQEbmFtZQZ2bXR5cGUFdWludDgJdm12ZXJzaW9uBXVpbnQ4BGNvZGUFYnl0ZXMEbWVtbwdzdHJpbmckDHNldGluZmxhdGlvbgADC2FubnVhbF9yYXRlBWludDY0FGluZmxhdGlvbl9wYXlfZmFjdG9yBWludDY0DnZvdGVwYXlfZmFjdG9yBWludDY0CXNldHBhcmFtcwABBnBhcmFtcxdibG9ja2NoYWluX3BhcmFtZXRlcnNfdAdzZXRwcml2AAIHYWNjb3VudARuYW1lB2lzX3ByaXYFdWludDgGc2V0cmFtAAEMbWF4X3JhbV9zaXplBnVpbnQ2NApzZXRyYW1yYXRlAAEPYnl0ZXNfcGVyX2Jsb2NrBnVpbnQxNgZzZXRyZXgAAQdiYWxhbmNlBWFzc2V0DHVuZGVsZWdhdGVidwAEBGZyb20EbmFtZQhyZWNlaXZlcgRuYW1lFHVuc3Rha2VfbmV0X3F1YW50aXR5BWFzc2V0FHVuc3Rha2VfY3B1X3F1YW50aXR5BWFzc2V0CnVubGlua2F1dGgABAdhY2NvdW50BG5hbWUEY29kZQRuYW1lBHR5cGUEbmFtZQ1hdXRob3JpemVkX2J5BW5hbWUkCXVucmVncHJvZAABCHByb2R1Y2VyBG5hbWUMdW5zdGFrZXRvcmV4AAQFb3duZXIEbmFtZQhyZWNlaXZlcgRuYW1lCGZyb21fbmV0BWFzc2V0CGZyb21fY3B1BWFzc2V0CnVwZGF0ZWF1dGgABQdhY2NvdW50BG5hbWUKcGVybWlzc2lvbgRuYW1lBnBhcmVudARuYW1lBGF1dGgJYXV0aG9yaXR5DWF1dGhvcml6ZWRfYnkFbmFtZSQJdXBkYXRlcmV4AAEFb3duZXIEbmFtZQx1cGR0cmV2aXNpb24AAQhyZXZpc2lvbgV1aW50OA51c2VyX3Jlc291cmNlcwAEBW93bmVyBG5hbWUKbmV0X3dlaWdodAVhc3NldApjcHVfd2VpZ2h0BWFzc2V0CXJhbV9ieXRlcwVpbnQ2NAx2b3RlcHJvZHVjZXIAAwV2b3RlcgRuYW1lBXByb3h5BG5hbWUJcHJvZHVjZXJzBm5hbWVbXQp2b3Rlcl9pbmZvAAoFb3duZXIEbmFtZQVwcm94eQRuYW1lCXByb2R1Y2VycwZuYW1lW10Gc3Rha2VkBWludDY0EGxhc3Rfdm90ZV93ZWlnaHQHZmxvYXQ2NBNwcm94aWVkX3ZvdGVfd2VpZ2h0B2Zsb2F0NjQIaXNfcHJveHkEYm9vbAZmbGFnczEGdWludDMyCXJlc2VydmVkMgZ1aW50MzIJcmVzZXJ2ZWQzBWFzc2V0CnZvdGV1cGRhdGUAAQp2b3Rlcl9uYW1lBG5hbWULd2FpdF93ZWlnaHQAAgh3YWl0X3NlYwZ1aW50MzIGd2VpZ2h0BnVpbnQxNgd3YXNtY2ZnAAEIc2V0dGluZ3MEbmFtZQh3aXRoZHJhdwACBW93bmVyBG5hbWUGYW1vdW50BWFzc2V0EWxpbWl0X2F1dGhfY2hhbmdlAAQHdmVyc2lvbgV1aW50OAdhY2NvdW50BG5hbWULYWxsb3dfcGVybXMGbmFtZVtdDmRpc2FsbG93X3Blcm1zBm5hbWVbXT4AAAAqm+0yMghhY3RpdmF0ZYgDLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogQWN0aXZhdGUgUHJvdG9jb2wgRmVhdHVyZQpzdW1tYXJ5OiAnQWN0aXZhdGUgcHJvdG9jb2wgZmVhdHVyZSB7e25vd3JhcCBmZWF0dXJlX2RpZ2VzdH19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvYWRtaW4ucG5nIzliZjFjZWM2NjQ4NjNiZDZhYWFjMGY4MTRiMjM1Zjg3OTlmYjAyYzg1MGU5YWE1ZGEzNGU4YTAwNGJkNjUxOGUKLS0tCgp7eyRhY3Rpb24uYWNjb3VudH19IGFjdGl2YXRlcyB0aGUgcHJvdG9jb2wgZmVhdHVyZSB3aXRoIGEgZGlnZXN0IG9mIHt7ZmVhdHVyZV9kaWdlc3R9fS4AAABASTOTOwdiaWRuYW1lqQ4tLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBCaWQgT24gYSBQcmVtaXVtIEFjY291bnQgTmFtZQpzdW1tYXJ5OiAne3tub3dyYXAgYmlkZGVyfX0gYmlkcyBvbiB0aGUgcHJlbWl1bSBhY2NvdW50IG5hbWUge3tub3dyYXAgbmV3bmFtZX19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvYWNjb3VudC5wbmcjM2Q1NWEyZmMzYTVjMjBiNDU2ZjU2NTdmYWY2NjZiYzI1ZmZkMDZmNDgzNmM1ZTgyNTZmNzQxMTQ5YjBiMjk0ZgotLS0KCnt7YmlkZGVyfX0gYmlkcyB7e2JpZH19IG9uIGFuIGF1Y3Rpb24gdG8gb3duIHRoZSBwcmVtaXVtIGFjY291bnQgbmFtZSB7e25ld25hbWV9fS4KCnt7YmlkZGVyfX0gdHJhbnNmZXJzIHt7YmlkfX0gdG8gdGhlIHN5c3RlbSB0byBjb3ZlciB0aGUgY29zdCBvZiB0aGUgYmlkLCB3aGljaCB3aWxsIGJlIHJldHVybmVkIHRvIHt7YmlkZGVyfX0gb25seSBpZiB7e2JpZGRlcn19IGlzIGxhdGVyIG91dGJpZCBpbiB0aGUgYXVjdGlvbiBmb3Ige3tuZXduYW1lfX0gYnkgYW5vdGhlciBhY2NvdW50LgoKSWYgdGhlIGF1Y3Rpb24gZm9yIHt7bmV3bmFtZX19IGNsb3NlcyB3aXRoIHt7YmlkZGVyfX0gcmVtYWluaW5nIGFzIHRoZSBoaWdoZXN0IGJpZGRlciwge3tiaWRkZXJ9fSB3aWxsIGJlIGF1dGhvcml6ZWQgdG8gY3JlYXRlIHRoZSBhY2NvdW50IHdpdGggbmFtZSB7e25ld25hbWV9fS4KCiMjIEJpZCByZWZ1bmQgYmVoYXZpb3IKCklmIHt7YmlkZGVyfX3igJlzIGJpZCBvbiB7e25ld25hbWV9fSBpcyBsYXRlciBvdXRiaWQgYnkgYW5vdGhlciBhY2NvdW50LCB7e2JpZGRlcn19IHdpbGwgYmUgYWJsZSB0byBjbGFpbSBiYWNrIHRoZSB0cmFuc2ZlcnJlZCBhbW91bnQgb2Yge3tiaWR9fS4gVGhlIHN5c3RlbSB3aWxsIGF0dGVtcHQgdG8gYXV0b21hdGljYWxseSBkbyB0aGlzIG9uIGJlaGFsZiBvZiB7e2JpZGRlcn19LCBidXQgdGhlIGF1dG9tYXRpYyByZWZ1bmQgbWF5IG9jY2FzaW9uYWxseSBmYWlsIHdoaWNoIHdpbGwgdGhlbiByZXF1aXJlIHt7YmlkZGVyfX0gdG8gbWFudWFsbHkgY2xhaW0gdGhlIHJlZnVuZCB3aXRoIHRoZSBiaWRyZWZ1bmQgYWN0aW9uLgoKIyMgQXVjdGlvbiBjbG9zZSBjcml0ZXJpYQoKVGhlIHN5c3RlbSBzaG91bGQgYXV0b21hdGljYWxseSBjbG9zZSB0aGUgYXVjdGlvbiBmb3Ige3tuZXduYW1lfX0gaWYgaXQgc2F0aXNmaWVzIHRoZSBjb25kaXRpb24gdGhhdCBvdmVyIGEgcGVyaW9kIG9mIHR3byBtaW51dGVzIHRoZSBmb2xsb3dpbmcgdHdvIHByb3BlcnRpZXMgY29udGludW91c2x5IGhvbGQ6CgotIG5vIG9uZSBoYXMgYmlkIG9uIHt7bmV3bmFtZX19IHdpdGhpbiB0aGUgbGFzdCAyNCBob3VyczsKLSBhbmQsIHRoZSB2YWx1ZSBvZiB0aGUgbGF0ZXN0IGJpZCBvbiB7e25ld25hbWV9fSBpcyBncmVhdGVyIHRoYW4gdGhlIHZhbHVlIG9mIHRoZSBiaWRzIG9uIGVhY2ggb2YgdGhlIG90aGVyIG9wZW4gYXVjdGlvbnMuCgpCZSBhd2FyZSB0aGF0IHRoZSBjb25kaXRpb24gdG8gY2xvc2UgdGhlIGF1Y3Rpb24gZGVzY3JpYmVkIGFib3ZlIGFyZSBzdWZmaWNpZW50IGJ1dCBub3QgbmVjZXNzYXJ5LiBUaGUgYXVjdGlvbiBmb3Ige3tuZXduYW1lfX0gY2Fubm90IGNsb3NlIHVubGVzcyBib3RoIG9mIHRoZSBwcm9wZXJ0aWVzIGFyZSBzaW11bHRhbmVvdXNseSBzYXRpc2ZpZWQsIGJ1dCBpdCBtYXkgYmUgY2xvc2VkIHdpdGhvdXQgcmVxdWlyaW5nIHRoZSBwcm9wZXJ0aWVzIHRvIGhvbGQgZm9yIGEgcGVyaW9kIG9mIDIgbWludXRlcy4AAEhTL3WTOwliaWRyZWZ1bmT0Ai0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IENsYWltIFJlZnVuZCBvbiBOYW1lIEJpZApzdW1tYXJ5OiAnQ2xhaW0gcmVmdW5kIG9uIHt7bm93cmFwIG5ld25hbWV9fSBiaWQnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hY2NvdW50LnBuZyMzZDU1YTJmYzNhNWMyMGI0NTZmNTY1N2ZhZjY2NmJjMjVmZmQwNmY0ODM2YzVlODI1NmY3NDExNDliMGIyOTRmCi0tLQoKe3tiaWRkZXJ9fSBjbGFpbXMgcmVmdW5kIG9uIHt7bmV3bmFtZX19IGJpZCBhZnRlciBiZWluZyBvdXRiaWQgYnkgc29tZW9uZSBlbHNlLgAAAABIc70+BmJ1eXJhbfoDLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogQnV5IFJBTQpzdW1tYXJ5OiAne3tub3dyYXAgcGF5ZXJ9fSBidXlzIFJBTSBvbiBiZWhhbGYgb2Yge3tub3dyYXAgcmVjZWl2ZXJ9fSBieSBwYXlpbmcge3tub3dyYXAgcXVhbnR9fScKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3Jlc291cmNlLnBuZyMzODMwZjFjZThjYjA3Zjc3NTdkYmNmMzgzYjFlYzFiMTE5MTRhYzM0YTFmOWQ4YjA2NWYwNzYwMGZhOWRhYzE5Ci0tLQoKe3twYXllcn19IGJ1eXMgUkFNIG9uIGJlaGFsZiBvZiB7e3JlY2VpdmVyfX0gYnkgcGF5aW5nIHt7cXVhbnR9fS4gVGhpcyB0cmFuc2FjdGlvbiB3aWxsIGluY3VyIGEgMC41JSBmZWUgb3V0IG9mIHt7cXVhbnR9fSBhbmQgdGhlIGFtb3VudCBvZiBSQU0gZGVsaXZlcmVkIHdpbGwgZGVwZW5kIG9uIG1hcmtldCByYXRlcy4AsMr+SHO9PgtidXlyYW1ieXRlc4EELS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogQnV5IFJBTQpzdW1tYXJ5OiAne3tub3dyYXAgcGF5ZXJ9fSBidXlzIHt7bm93cmFwIGJ5dGVzfX0gYnl0ZXMgb2YgUkFNIG9uIGJlaGFsZiBvZiB7e25vd3JhcCByZWNlaXZlcn19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvcmVzb3VyY2UucG5nIzM4MzBmMWNlOGNiMDdmNzc1N2RiY2YzODNiMWVjMWIxMTkxNGFjMzRhMWY5ZDhiMDY1ZjA3NjAwZmE5ZGFjMTkKLS0tCgp7e3BheWVyfX0gYnV5cyBhcHByb3hpbWF0ZWx5IHt7Ynl0ZXN9fSBieXRlcyBvZiBSQU0gb24gYmVoYWxmIG9mIHt7cmVjZWl2ZXJ9fSBieSBwYXlpbmcgbWFya2V0IHJhdGVzIGZvciBSQU0uIFRoaXMgdHJhbnNhY3Rpb24gd2lsbCBpbmN1ciBhIDAuNSUgZmVlIGFuZCB0aGUgY29zdCB3aWxsIGRlcGVuZCBvbiBtYXJrZXQgcmF0ZXMuAAAAAHR1vT4GYnV5cmV41wYtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBCdXkgUkVYIFRva2VucwpzdW1tYXJ5OiAne3tub3dyYXAgZnJvbX19IGJ1eXMgUkVYIHRva2VucyBpbiBleGNoYW5nZSBmb3Ige3tub3dyYXAgYW1vdW50fX0gYW5kIHRoZWlyIHZvdGUgc3Rha2UgaW5jcmVhc2VzIGJ5IHt7bm93cmFwIGFtb3VudH19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvcmV4LnBuZyNkMjI5ODM3ZmE2MmE0NjRiOWM3MWUwNjA2MGFhODYxNzlhZGYwYjNmNGUzYjhjNGY5NzAyZjRmNGIwYzM0MGE4Ci0tLQoKe3thbW91bnR9fSBpcyB0YWtlbiBvdXQgb2Yge3tmcm9tfX3igJlzIFJFWCBmdW5kIGFuZCB1c2VkIHRvIHB1cmNoYXNlIFJFWCB0b2tlbnMgYXQgdGhlIGN1cnJlbnQgbWFya2V0IGV4Y2hhbmdlIHJhdGUuIEluIG9yZGVyIGZvciB0aGUgYWN0aW9uIHRvIHN1Y2NlZWQsIHt7ZnJvbX19IG11c3QgaGF2ZSB2b3RlZCBmb3IgYSBwcm94eSBvciBhdCBsZWFzdCAyMSBibG9jayBwcm9kdWNlcnMuIHt7YW1vdW50fX0gaXMgYWRkZWQgdG8ge3tmcm9tfX3igJlzIHZvdGUgc3Rha2UuCgpBIHNlbGwgb3JkZXIgb2YgdGhlIHB1cmNoYXNlZCBhbW91bnQgY2FuIG9ubHkgYmUgaW5pdGlhdGVkIGFmdGVyIHdhaXRpbmcgZm9yIHRoZSBtYXR1cml0eSBwZXJpb2Qgb2YgNCB0byA1IGRheXMgdG8gcGFzcy4gRXZlbiB0aGVuLCBkZXBlbmRpbmcgb24gdGhlIG1hcmtldCBjb25kaXRpb25zLCB0aGUgaW5pdGlhdGVkIHNlbGwgb3JkZXIgbWF5IG5vdCBiZSBleGVjdXRlZCBpbW1lZGlhdGVseS4AvIkqRYWmQQtjYW5jZWxkZWxheYoDLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogQ2FuY2VsIERlbGF5ZWQgVHJhbnNhY3Rpb24Kc3VtbWFyeTogJ3t7bm93cmFwIGNhbmNlbGluZ19hdXRoLmFjdG9yfX0gY2FuY2VscyBhIGRlbGF5ZWQgdHJhbnNhY3Rpb24nCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hY2NvdW50LnBuZyMzZDU1YTJmYzNhNWMyMGI0NTZmNTY1N2ZhZjY2NmJjMjVmZmQwNmY0ODM2YzVlODI1NmY3NDExNDliMGIyOTRmCi0tLQoKe3tjYW5jZWxpbmdfYXV0aC5hY3Rvcn19IGNhbmNlbHMgdGhlIGRlbGF5ZWQgdHJhbnNhY3Rpb24gd2l0aCBpZCB7e3RyeF9pZH19LgBA1VdxWtlCCmNmZ3Bvd2VydXAAgNM1XF3pTEQMY2xhaW1yZXdhcmRz5wItLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBDbGFpbSBCbG9jayBQcm9kdWNlciBSZXdhcmRzCnN1bW1hcnk6ICd7e25vd3JhcCBvd25lcn19IGNsYWltcyBibG9jayBhbmQgdm90ZSByZXdhcmRzJwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvYWRtaW4ucG5nIzliZjFjZWM2NjQ4NjNiZDZhYWFjMGY4MTRiMjM1Zjg3OTlmYjAyYzg1MGU5YWE1ZGEzNGU4YTAwNGJkNjUxOGUKLS0tCgp7e293bmVyfX0gY2xhaW1zIGJsb2NrIGFuZCB2b3RlIHJld2FyZHMgZnJvbSB0aGUgc3lzdGVtLgAAAF1dhWlECGNsb3NlcmV4lAQtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBDbGVhbnVwIFVudXNlZCBSRVggRGF0YQpzdW1tYXJ5OiAnRGVsZXRlIFJFWCByZWxhdGVkIERCIGVudHJpZXMgYW5kIGZyZWUgYXNzb2NpYXRlZCBSQU0nCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9yZXgucG5nI2QyMjk4MzdmYTYyYTQ2NGI5YzcxZTA2MDYwYWE4NjE3OWFkZjBiM2Y0ZTNiOGM0Zjk3MDJmNGY0YjBjMzQwYTgKLS0tCgpEZWxldGUgUkVYIHJlbGF0ZWQgREIgZW50cmllcyBhbmQgZnJlZSBhc3NvY2lhdGVkIFJBTSBmb3Ige3tvd25lcn19LgoKVG8gZnVsbHkgZGVsZXRlIGFsbCBSRVggcmVsYXRlZCBEQiBlbnRyaWVzLCB7e293bmVyfX0gbXVzdCBlbnN1cmUgdGhhdCB0aGVpciBSRVggYmFsYW5jZSBhbmQgUkVYIGZ1bmQgYW1vdW50cyBhcmUgYm90aCB6ZXJvIGFuZCB0aGV5IGhhdmUgbm8gb3V0c3RhbmRpbmcgbG9hbnMucFW6tKsb0UQMY25jbHJleG9yZGVy6wItLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBDYW5jZWwgU2NoZWR1bGVkIFJFWCBTZWxsIE9yZGVyCnN1bW1hcnk6ICd7e25vd3JhcCBvd25lcn19IGNhbmNlbHMgYSBzY2hlZHVsZWQgc2VsbCBvcmRlciBpZiBub3QgeWV0IGZpbGxlZCcKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3JleC5wbmcjZDIyOTgzN2ZhNjJhNDY0YjljNzFlMDYwNjBhYTg2MTc5YWRmMGIzZjRlM2I4YzRmOTcwMmY0ZjRiMGMzNDBhOAotLS0KCnt7b3duZXJ9fSBjYW5jZWxzIHRoZWlyIG9wZW4gc2VsbCBvcmRlci4AVDbJRYonRQtjb25zb2xpZGF0ZaYDLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogQ29uc29saWRhdGUgUkVYIE1hdHVyaXR5IEJ1Y2tldHMgSW50byBPbmUKc3VtbWFyeTogJ0NvbnNvbGlkYXRlIFJFWCBtYXR1cml0eSBidWNrZXRzIGludG8gb25lJwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvcmV4LnBuZyNkMjI5ODM3ZmE2MmE0NjRiOWM3MWUwNjA2MGFhODYxNzlhZGYwYjNmNGUzYjhjNGY5NzAyZjRmNGIwYzM0MGE4Ci0tLQoKQ29uc29saWRhdGUgUkVYIG1hdHVyaXR5IGJ1Y2tldHMgaW50byBvbmUgYnVja2V0IHRoYXQge3tvd25lcn19IHdpbGwgbm90IGJlIGFibGUgdG8gc2VsbCB1bnRpbCA0IHRvIDUgZGF5cyBsYXRlci4AwDQ06oqWSgpkZWZjcHVsb2Fu3gMtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBXaXRoZHJhdyBmcm9tIHRoZSBGdW5kIG9mIGEgU3BlY2lmaWMgQ1BVIExvYW4Kc3VtbWFyeTogJ3t7bm93cmFwIGZyb219fSB0cmFuc2ZlcnMge3tub3dyYXAgYW1vdW50fX0gZnJvbSB0aGUgZnVuZCBvZiBDUFUgbG9hbiBudW1iZXIge3tub3dyYXAgbG9hbl9udW19fSBiYWNrIHRvIFJFWCBmdW5kJwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvcmV4LnBuZyNkMjI5ODM3ZmE2MmE0NjRiOWM3MWUwNjA2MGFhODYxNzlhZGYwYjNmNGUzYjhjNGY5NzAyZjRmNGIwYzM0MGE4Ci0tLQoKe3tmcm9tfX0gdHJhbnNmZXJzIHt7YW1vdW50fX0gZnJvbSB0aGUgZnVuZCBvZiBDUFUgbG9hbiBudW1iZXIge3tsb2FuX251bX19IGJhY2sgdG8gUkVYIGZ1bmQuAMA0NGY1l0oKZGVmbmV0bG9hbt4DLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogV2l0aGRyYXcgZnJvbSB0aGUgRnVuZCBvZiBhIFNwZWNpZmljIE5FVCBMb2FuCnN1bW1hcnk6ICd7e25vd3JhcCBmcm9tfX0gdHJhbnNmZXJzIHt7bm93cmFwIGFtb3VudH19IGZyb20gdGhlIGZ1bmQgb2YgTkVUIGxvYW4gbnVtYmVyIHt7bm93cmFwIGxvYW5fbnVtfX0gYmFjayB0byBSRVggZnVuZCcKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3JleC5wbmcjZDIyOTgzN2ZhNjJhNDY0YjljNzFlMDYwNjBhYTg2MTc5YWRmMGIzZjRlM2I4YzRmOTcwMmY0ZjRiMGMzNDBhOAotLS0KCnt7ZnJvbX19IHRyYW5zZmVycyB7e2Ftb3VudH19IGZyb20gdGhlIGZ1bmQgb2YgTkVUIGxvYW4gbnVtYmVyIHt7bG9hbl9udW19fSBiYWNrIHRvIFJFWCBmdW5kLgAAPyobpqJKCmRlbGVnYXRlYnfzBi0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IFN0YWtlIFRva2VucyBmb3IgTkVUIGFuZC9vciBDUFUKc3VtbWFyeTogJ1N0YWtlIHRva2VucyBmb3IgTkVUIGFuZC9vciBDUFUgYW5kIG9wdGlvbmFsbHkgdHJhbnNmZXIgb3duZXJzaGlwJwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvcmVzb3VyY2UucG5nIzM4MzBmMWNlOGNiMDdmNzc1N2RiY2YzODNiMWVjMWIxMTkxNGFjMzRhMWY5ZDhiMDY1ZjA3NjAwZmE5ZGFjMTkKLS0tCgp7eyNpZiB0cmFuc2Zlcn19IHt7ZnJvbX19IHN0YWtlcyBvbiBiZWhhbGYgb2Yge3tyZWNlaXZlcn19IHt7c3Rha2VfbmV0X3F1YW50aXR5fX0gZm9yIE5FVCBiYW5kd2lkdGggYW5kIHt7c3Rha2VfY3B1X3F1YW50aXR5fX0gZm9yIENQVSBiYW5kd2lkdGguCgpTdGFrZWQgdG9rZW5zIHdpbGwgYWxzbyBiZSB0cmFuc2ZlcnJlZCB0byB7e3JlY2VpdmVyfX0uIFRoZSBzdW0gb2YgdGhlc2UgdHdvIHF1YW50aXRpZXMgd2lsbCBiZSBkZWR1Y3RlZCBmcm9tIHt7ZnJvbX194oCZcyBsaXF1aWQgYmFsYW5jZSBhbmQgYWRkIHRvIHRoZSB2b3RlIHdlaWdodCBvZiB7e3JlY2VpdmVyfX0uCnt7ZWxzZX19Cnt7ZnJvbX19IHN0YWtlcyB0byBzZWxmIGFuZCBkZWxlZ2F0ZXMgdG8ge3tyZWNlaXZlcn19IHt7c3Rha2VfbmV0X3F1YW50aXR5fX0gZm9yIE5FVCBiYW5kd2lkdGggYW5kIHt7c3Rha2VfY3B1X3F1YW50aXR5fX0gZm9yIENQVSBiYW5kd2lkdGguCgpUaGUgc3VtIG9mIHRoZXNlIHR3byBxdWFudGl0aWVzIGFkZCB0byB0aGUgdm90ZSB3ZWlnaHQgb2Yge3tmcm9tfX0uCnt7L2lmfX0AQMvaqKyiSgpkZWxldGVhdXRo9QItLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBEZWxldGUgQWNjb3VudCBQZXJtaXNzaW9uCnN1bW1hcnk6ICdEZWxldGUgdGhlIHt7bm93cmFwIHBlcm1pc3Npb259fSBwZXJtaXNzaW9uIG9mIHt7bm93cmFwIGFjY291bnR9fScKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL2FjY291bnQucG5nIzNkNTVhMmZjM2E1YzIwYjQ1NmY1NjU3ZmFmNjY2YmMyNWZmZDA2ZjQ4MzZjNWU4MjU2Zjc0MTE0OWIwYjI5NGYKLS0tCgpEZWxldGUgdGhlIHt7cGVybWlzc2lvbn19IHBlcm1pc3Npb24gb2Yge3thY2NvdW50fX0uAAAAIDtMq0oHZGVwb3NpdIgELS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogRGVwb3NpdCBJbnRvIFJFWCBGdW5kCnN1bW1hcnk6ICdBZGQgdG8ge3tub3dyYXAgb3duZXJ9feKAmXMgUkVYIGZ1bmQgYnkgdHJhbnNmZXJyaW5nIHt7bm93cmFwIGFtb3VudH19IGZyb20ge3tub3dyYXAgb3duZXJ9feKAmXMgbGlxdWlkIGJhbGFuY2UnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9yZXgucG5nI2QyMjk4MzdmYTYyYTQ2NGI5YzcxZTA2MDYwYWE4NjE3OWFkZjBiM2Y0ZTNiOGM0Zjk3MDJmNGY0YjBjMzQwYTgKLS0tCgpUcmFuc2ZlciB7e2Ftb3VudH19IGZyb20ge3tvd25lcn194oCZcyBsaXF1aWQgYmFsYW5jZSB0byB7e293bmVyfX3igJlzIFJFWCBmdW5kLiBBbGwgcHJvY2VlZHMgYW5kIGV4cGVuc2VzIHJlbGF0ZWQgdG8gUkVYIGFyZSBhZGRlZCB0byBvciB0YWtlbiBvdXQgb2YgdGhpcyBmdW5kLgCmoVFXlKZeC2Z1bmRjcHVsb2Fu/AMtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBEZXBvc2l0IGludG8gdGhlIEZ1bmQgb2YgYSBTcGVjaWZpYyBDUFUgTG9hbgpzdW1tYXJ5OiAne3tub3dyYXAgZnJvbX19IGZ1bmRzIGEgQ1BVIGxvYW4nCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9yZXgucG5nI2QyMjk4MzdmYTYyYTQ2NGI5YzcxZTA2MDYwYWE4NjE3OWFkZjBiM2Y0ZTNiOGM0Zjk3MDJmNGY0YjBjMzQwYTgKLS0tCgp7e2Zyb219fSB0cmFuc2ZlcnMge3twYXltZW50fX0gZnJvbSBSRVggZnVuZCB0byB0aGUgZnVuZCBvZiBDUFUgbG9hbiBudW1iZXIge3tsb2FuX251bX19IGluIG9yZGVyIHRvIGJlIHVzZWQgaW4gbG9hbiByZW5ld2FsIGF0IGV4cGlyeS4ge3tmcm9tfX0gY2FuIHdpdGhkcmF3IHRoZSB0b3RhbCBiYWxhbmNlIG9mIHRoZSBsb2FuIGZ1bmQgYXQgYW55IHRpbWUuAKahMauZpl4LZnVuZG5ldGxvYW78Ay0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IERlcG9zaXQgaW50byB0aGUgRnVuZCBvZiBhIFNwZWNpZmljIE5FVCBMb2FuCnN1bW1hcnk6ICd7e25vd3JhcCBmcm9tfX0gZnVuZHMgYSBORVQgbG9hbicKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3JleC5wbmcjZDIyOTgzN2ZhNjJhNDY0YjljNzFlMDYwNjBhYTg2MTc5YWRmMGIzZjRlM2I4YzRmOTcwMmY0ZjRiMGMzNDBhOAotLS0KCnt7ZnJvbX19IHRyYW5zZmVycyB7e3BheW1lbnR9fSBmcm9tIFJFWCBmdW5kIHRvIHRoZSBmdW5kIG9mIE5FVCBsb2FuIG51bWJlciB7e2xvYW5fbnVtfX0gaW4gb3JkZXIgdG8gYmUgdXNlZCBpbiBsb2FuIHJlbmV3YWwgYXQgZXhwaXJ5LiB7e2Zyb219fSBjYW4gd2l0aGRyYXcgdGhlIHRvdGFsIGJhbGFuY2Ugb2YgdGhlIGxvYW4gZnVuZCBhdCBhbnkgdGltZS4AAAAAAJDddARpbml04wItLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBJbml0aWFsaXplIFN5c3RlbSBDb250cmFjdApzdW1tYXJ5OiAnSW5pdGlhbGl6ZSBzeXN0ZW0gY29udHJhY3QnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCkluaXRpYWxpemUgc3lzdGVtIGNvbnRyYWN0LiBUaGUgY29yZSB0b2tlbiBzeW1ib2wgd2lsbCBiZSBzZXQgdG8ge3tjb3JlfX0uwBpqWZvspIsMbGltaXRhdXRoY2hnAAAAAC1rA6eLCGxpbmthdXRonQUtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBMaW5rIEFjdGlvbiB0byBQZXJtaXNzaW9uCnN1bW1hcnk6ICd7e25vd3JhcCBhY2NvdW50fX0gc2V0cyB0aGUgbWluaW11bSByZXF1aXJlZCBwZXJtaXNzaW9uIGZvciB0aGUge3sjaWYgdHlwZX19e3tub3dyYXAgdHlwZX19IGFjdGlvbiBvZiB0aGV7ey9pZn19IHt7bm93cmFwIGNvZGV9fSBjb250cmFjdCB0byB7e25vd3JhcCByZXF1aXJlbWVudH19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvYWNjb3VudC5wbmcjM2Q1NWEyZmMzYTVjMjBiNDU2ZjU2NTdmYWY2NjZiYzI1ZmZkMDZmNDgzNmM1ZTgyNTZmNzQxMTQ5YjBiMjk0ZgotLS0KCnt7YWNjb3VudH19IHNldHMgdGhlIG1pbmltdW0gcmVxdWlyZWQgcGVybWlzc2lvbiBmb3IgdGhlIHt7I2lmIHR5cGV9fXt7dHlwZX19IGFjdGlvbiBvZiB0aGV7ey9pZn19IHt7Y29kZX19IGNvbnRyYWN0IHRvIHt7cmVxdWlyZW1lbnR9fS4KCnt7I2lmIHR5cGV9fXt7ZWxzZX19QW55IGxpbmtzIGV4cGxpY2l0bHkgYXNzb2NpYXRlZCB0byBzcGVjaWZpYyBhY3Rpb25zIG9mIHt7Y29kZX19IHdpbGwgdGFrZSBwcmVjZWRlbmNlLnt7L2lmfX0AMJtuG3zXlgttdmZyc2F2aW5nc5wDLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogVW5sb2NrIFJFWCBUb2tlbnMKc3VtbWFyeTogJ3t7bm93cmFwIG93bmVyfX0gdW5sb2NrcyBSRVggVG9rZW5zJwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvcmV4LnBuZyNkMjI5ODM3ZmE2MmE0NjRiOWM3MWUwNjA2MGFhODYxNzlhZGYwYjNmNGUzYjhjNGY5NzAyZjRmNGIwYzM0MGE4Ci0tLQoKe3tvd25lcn19IHVubG9ja3Mge3tyZXh9fSBieSBtb3ZpbmcgaXQgb3V0IG9mIHRoZSBSRVggc2F2aW5ncyBidWNrZXQuIFRoZSB1bmxvY2tlZCBSRVggdG9rZW5zIGNhbm5vdCBiZSBzb2xkIHVudGlsIDQgdG8gNSBkYXlzIGxhdGVyLgAwm24bTPOWC212dG9zYXZpbmdzugMtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBMb2NrIFJFWCBUb2tlbnMKc3VtbWFyeTogJ3t7bm93cmFwIG93bmVyfX0gbG9ja3MgUkVYIFRva2VucycKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3JleC5wbmcjZDIyOTgzN2ZhNjJhNDY0YjljNzFlMDYwNjBhYTg2MTc5YWRmMGIzZjRlM2I4YzRmOTcwMmY0ZjRiMGMzNDBhOAotLS0KCnt7b3duZXJ9fSBsb2NrcyB7e3JleH19IGJ5IG1vdmluZyBpdCBpbnRvIHRoZSBSRVggc2F2aW5ncyBidWNrZXQuIFRoZSBsb2NrZWQgUkVYIHRva2VucyBjYW5ub3QgYmUgc29sZCBkaXJlY3RseSBhbmQgd2lsbCBoYXZlIHRvIGJlIHVubG9ja2VkIGV4cGxpY2l0bHkgYmVmb3JlIHNlbGxpbmcuAECemiJkuJoKbmV3YWNjb3VudIAELS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogQ3JlYXRlIE5ldyBBY2NvdW50CnN1bW1hcnk6ICd7e25vd3JhcCBjcmVhdG9yfX0gY3JlYXRlcyBhIG5ldyBhY2NvdW50IHdpdGggdGhlIG5hbWUge3tub3dyYXAgbmFtZX19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvYWNjb3VudC5wbmcjM2Q1NWEyZmMzYTVjMjBiNDU2ZjU2NTdmYWY2NjZiYzI1ZmZkMDZmNDgzNmM1ZTgyNTZmNzQxMTQ5YjBiMjk0ZgotLS0KCnt7Y3JlYXRvcn19IGNyZWF0ZXMgYSBuZXcgYWNjb3VudCB3aXRoIHRoZSBuYW1lIHt7bmFtZX19IGFuZCB0aGUgZm9sbG93aW5nIHBlcm1pc3Npb25zOgoKb3duZXIgcGVybWlzc2lvbiB3aXRoIGF1dGhvcml0eToKe3t0b19qc29uIG93bmVyfX0KCmFjdGl2ZSBwZXJtaXNzaW9uIHdpdGggYXV0aG9yaXR5Ogp7e3RvX2pzb24gYWN0aXZlfX0AAAAAIhrPpAdvbmJsb2NrAAAAAODSe9WkB29uZXJyb3IAAAAAoOqrOK0HcG93ZXJ1cNQCLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogUG93ZXJ1cCByZXNvdXJjZXMKc3VtbWFyeTogJ1VzZXIgbWF5IHBvd2VydXAgdG8gcmVzZXJ2ZSByZXNvdXJjZXMnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9yZXNvdXJjZS5wbmcjMzgzMGYxY2U4Y2IwN2Y3NzU3ZGJjZjM4M2IxZWMxYjExOTE0YWMzNGExZjlkOGIwNjVmMDc2MDBmYTlkYWMxOQotLS0KClVzZXJzIG1heSB1c2UgdGhlIHBvd2VydXAgYWN0aW9uIHRvIHJlc2VydmUgcmVzb3VyY2VzLgCQ6qrqqzitC3Bvd2VydXBleGVjAAAAAACkqZe6BnJlZnVuZIcDLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogQ2xhaW0gVW5zdGFrZWQgVG9rZW5zCnN1bW1hcnk6ICdSZXR1cm4gcHJldmlvdXNseSB1bnN0YWtlZCB0b2tlbnMgdG8ge3tub3dyYXAgb3duZXJ9fScKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL2FjY291bnQucG5nIzNkNTVhMmZjM2E1YzIwYjQ1NmY1NjU3ZmFmNjY2YmMyNWZmZDA2ZjQ4MzZjNWU4MjU2Zjc0MTE0OWIwYjI5NGYKLS0tCgpSZXR1cm4gcHJldmlvdXNseSB1bnN0YWtlZCB0b2tlbnMgdG8ge3tvd25lcn19IGFmdGVyIHRoZSB1bnN0YWtpbmcgcGVyaW9kIGhhcyBlbGFwc2VkLgCuQjrRW5m6C3JlZ3Byb2R1Y2VymQQtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBSZWdpc3RlciBhcyBhIEJsb2NrIFByb2R1Y2VyIENhbmRpZGF0ZQpzdW1tYXJ5OiAnUmVnaXN0ZXIge3tub3dyYXAgcHJvZHVjZXJ9fSBhY2NvdW50IGFzIGEgYmxvY2sgcHJvZHVjZXIgY2FuZGlkYXRlJwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvdm90aW5nLnBuZyNkYjI4Y2QzZGI2ZTYyZDQ1MDlhZjM2NDRjZTdkMzc3MzI5NDgyYTE0YmI0YmZhY2EyYWE1ZjE0MDBkOGU4YTg0Ci0tLQoKUmVnaXN0ZXIge3twcm9kdWNlcn19IGFjY291bnQgYXMgYSBibG9jayBwcm9kdWNlciBjYW5kaWRhdGUuCgpVUkw6IHt7dXJsfX0KTG9jYXRpb24gY29kZToge3tsb2NhdGlvbn19CkJsb2NrIHNpZ25pbmcga2V5OiB7e3Byb2R1Y2VyX2tleX19CgojIyBCbG9jayBQcm9kdWNlciBBZ3JlZW1lbnQKe3skY2xhdXNlcy5CbG9ja1Byb2R1Y2VyQWdyZWVtZW50fX0grkI60VuZugxyZWdwcm9kdWNlcjKtBC0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IFJlZ2lzdGVyIGFzIGEgQmxvY2sgUHJvZHVjZXIgQ2FuZGlkYXRlCnN1bW1hcnk6ICdSZWdpc3RlciB7e25vd3JhcCBwcm9kdWNlcn19IGFjY291bnQgYXMgYSBibG9jayBwcm9kdWNlciBjYW5kaWRhdGUnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy92b3RpbmcucG5nI2RiMjhjZDNkYjZlNjJkNDUwOWFmMzY0NGNlN2QzNzczMjk0ODJhMTRiYjRiZmFjYTJhYTVmMTQwMGQ4ZThhODQKLS0tCgpSZWdpc3RlciB7e3Byb2R1Y2VyfX0gYWNjb3VudCBhcyBhIGJsb2NrIHByb2R1Y2VyIGNhbmRpZGF0ZS4KClVSTDoge3t1cmx9fQpMb2NhdGlvbiBjb2RlOiB7e2xvY2F0aW9ufX0KQmxvY2sgc2lnbmluZyBhdXRob3JpdHk6Cnt7dG9fanNvbiBwcm9kdWNlcl9hdXRob3JpdHl9fQoKIyMgQmxvY2sgUHJvZHVjZXIgQWdyZWVtZW50Cnt7JGNsYXVzZXMuQmxvY2tQcm9kdWNlckFncmVlbWVudH19AAAAvtNbmboIcmVncHJveHmjBC0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IFJlZ2lzdGVyL3VucmVnaXN0ZXIgYXMgYSBQcm94eQpzdW1tYXJ5OiAnUmVnaXN0ZXIvdW5yZWdpc3RlciB7e25vd3JhcCBwcm94eX19IGFzIGEgcHJveHkgYWNjb3VudCcKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3ZvdGluZy5wbmcjZGIyOGNkM2RiNmU2MmQ0NTA5YWYzNjQ0Y2U3ZDM3NzMyOTQ4MmExNGJiNGJmYWNhMmFhNWYxNDAwZDhlOGE4NAotLS0KCnt7I2lmIGlzcHJveHl9fQp7e3Byb3h5fX0gcmVnaXN0ZXJzIGFzIGEgcHJveHkgdGhhdCBjYW4gdm90ZSBvbiBiZWhhbGYgb2YgYWNjb3VudHMgdGhhdCBhcHBvaW50IGl0IGFzIHRoZWlyIHByb3h5Lgp7e2Vsc2V9fQp7e3Byb3h5fX0gdW5yZWdpc3RlcnMgYXMgYSBwcm94eSB0aGF0IGNhbiB2b3RlIG9uIGJlaGFsZiBvZiBhY2NvdW50cyB0aGF0IGFwcG9pbnQgaXQgYXMgdGhlaXIgcHJveHkuCnt7L2lmfX0AAABAV5SnugdyZW50Y3B13AktLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBSZW50IENQVSBCYW5kd2lkdGggZm9yIDMwIERheXMKc3VtbWFyeTogJ3t7bm93cmFwIGZyb219fSBwYXlzIHt7bm93cmFwIGxvYW5fcGF5bWVudH19IHRvIHJlbnQgQ1BVIGJhbmR3aWR0aCBmb3Ige3tub3dyYXAgcmVjZWl2ZXJ9fScKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3JleC5wbmcjZDIyOTgzN2ZhNjJhNDY0YjljNzFlMDYwNjBhYTg2MTc5YWRmMGIzZjRlM2I4YzRmOTcwMmY0ZjRiMGMzNDBhOAotLS0KCnt7ZnJvbX19IHBheXMge3tsb2FuX3BheW1lbnR9fSB0byByZW50IENQVSBiYW5kd2lkdGggb24gYmVoYWxmIG9mIHt7cmVjZWl2ZXJ9fSBmb3IgYSBwZXJpb2Qgb2YgMzAgZGF5cy4KCnt7bG9hbl9wYXltZW50fX0gaXMgdGFrZW4gb3V0IG9mIHt7ZnJvbX194oCZcyBSRVggZnVuZC4gVGhlIG1hcmtldCBwcmljZSBkZXRlcm1pbmVzIHRoZSBudW1iZXIgb2YgdG9rZW5zIHRvIGJlIHN0YWtlZCB0byB7e3JlY2VpdmVyfX3igJlzIENQVSByZXNvdXJjZXMuIEluIGFkZGl0aW9uLCB7e2Zyb219fSBwcm92aWRlcyB7e2xvYW5fZnVuZH19LCB3aGljaCBpcyBhbHNvIHRha2VuIG91dCBvZiB7e2Zyb219feKAmXMgUkVYIGZ1bmQsIHRvIGJlIHVzZWQgZm9yIGF1dG9tYXRpYyByZW5ld2FsIG9mIHRoZSBsb2FuLgoKQXQgZXhwaXJhdGlvbiwgaWYgdGhlIGxvYW4gaGFzIGxlc3MgZnVuZHMgdGhhbiB7e2xvYW5fcGF5bWVudH19LCBpdCBpcyBjbG9zZWQgYW5kIGxlbnQgdG9rZW5zIHRoYXQgaGF2ZSBiZWVuIHN0YWtlZCBhcmUgdGFrZW4gb3V0IG9mIHt7cmVjZWl2ZXJ9feKAmXMgQ1BVIGJhbmR3aWR0aC4gT3RoZXJ3aXNlLCBpdCBpcyByZW5ld2VkIGF0IHRoZSBtYXJrZXQgcHJpY2UgYXQgdGhlIHRpbWUgb2YgcmVuZXdhbCwgdGhhdCBpcywgdGhlIG51bWJlciBvZiBzdGFrZWQgdG9rZW5zIGlzIHJlY2FsY3VsYXRlZCBhbmQge3tyZWNlaXZlcn194oCZcyBDUFUgYmFuZHdpZHRoIGlzIHVwZGF0ZWQgYWNjb3JkaW5nbHkuIHt7ZnJvbX19IGNhbiBmdW5kIG9yIGRlZnVuZCBhIGxvYW4gYXQgYW55IHRpbWUgYmVmb3JlIGV4cGlyYXRpb24uIFdoZW4gdGhlIGxvYW4gaXMgY2xvc2VkLCB7e2Zyb219fSBpcyByZWZ1bmRlZCBhbnkgdG9rZW5zIHJlbWFpbmluZyBpbiB0aGUgbG9hbiBmdW5kLgAAACCrmae6B3JlbnRuZXToCS0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IFJlbnQgTkVUIEJhbmR3aWR0aCBmb3IgMzAgRGF5cwpzdW1tYXJ5OiAne3tub3dyYXAgZnJvbX19IHBheXMge3tub3dyYXAgbG9hbl9wYXltZW50fX0gdG8gcmVudCBORVQgYmFuZHdpZHRoIGZvciB7e25vd3JhcCByZWNlaXZlcn19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvcmV4LnBuZyNkMjI5ODM3ZmE2MmE0NjRiOWM3MWUwNjA2MGFhODYxNzlhZGYwYjNmNGUzYjhjNGY5NzAyZjRmNGIwYzM0MGE4Ci0tLQoKe3tmcm9tfX0gcGF5cyB7e2xvYW5fcGF5bWVudH19IHRvIHJlbnQgTkVUIGJhbmR3aWR0aCBvbiBiZWhhbGYgb2Yge3tyZWNlaXZlcn19IGZvciBhIHBlcmlvZCBvZiAzMCBkYXlzLgoKe3tsb2FuX3BheW1lbnR9fSBpcyB0YWtlbiBvdXQgb2Yge3tmcm9tfX3igJlzIFJFWCBmdW5kLiBUaGUgbWFya2V0IHByaWNlIGRldGVybWluZXMgdGhlIG51bWJlciBvZiB0b2tlbnMgdG8gYmUgc3Rha2VkIHRvIHt7cmVjZWl2ZXJ9feKAmXMgTkVUIHJlc291cmNlcyBmb3IgMzAgZGF5cy4gSW4gYWRkaXRpb24sIHt7ZnJvbX19IHByb3ZpZGVzIHt7bG9hbl9mdW5kfX0sIHdoaWNoIGlzIGFsc28gdGFrZW4gb3V0IG9mIHt7ZnJvbX194oCZcyBSRVggZnVuZCwgdG8gYmUgdXNlZCBmb3IgYXV0b21hdGljIHJlbmV3YWwgb2YgdGhlIGxvYW4uCgpBdCBleHBpcmF0aW9uLCBpZiB0aGUgbG9hbiBoYXMgbGVzcyBmdW5kcyB0aGFuIHt7bG9hbl9wYXltZW50fX0sIGl0IGlzIGNsb3NlZCBhbmQgbGVudCB0b2tlbnMgdGhhdCBoYXZlIGJlZW4gc3Rha2VkIGFyZSB0YWtlbiBvdXQgb2Yge3tyZWNlaXZlcn194oCZcyBORVQgYmFuZHdpZHRoLiBPdGhlcndpc2UsIGl0IGlzIHJlbmV3ZWQgYXQgdGhlIG1hcmtldCBwcmljZSBhdCB0aGUgdGltZSBvZiByZW5ld2FsLCB0aGF0IGlzLCB0aGUgbnVtYmVyIG9mIHN0YWtlZCB0b2tlbnMgaXMgcmVjYWxjdWxhdGVkIGFuZCB7e3JlY2VpdmVyfX3igJlzIE5FVCBiYW5kd2lkdGggaXMgdXBkYXRlZCBhY2NvcmRpbmdseS4ge3tmcm9tfX0gY2FuIGZ1bmQgb3IgZGVmdW5kIGEgbG9hbiBhdCBhbnkgdGltZSBiZWZvcmUgZXhwaXJhdGlvbi4gV2hlbiB0aGUgbG9hbiBpcyBjbG9zZWQsIHt7ZnJvbX19IGlzIHJlZnVuZGVkIGFueSB0b2tlbnMgcmVtYWluaW5nIGluIHRoZSBsb2FuIGZ1bmQuAAAAAKmuuroHcmV4ZXhlY6IDLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogUGVyZm9ybSBSRVggTWFpbnRlbmFuY2UKc3VtbWFyeTogJ1Byb2Nlc3Mgc2VsbCBvcmRlcnMgYW5kIGV4cGlyZWQgbG9hbnMnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9yZXgucG5nI2QyMjk4MzdmYTYyYTQ2NGI5YzcxZTA2MDYwYWE4NjE3OWFkZjBiM2Y0ZTNiOGM0Zjk3MDJmNGY0YjBjMzQwYTgKLS0tCgpQZXJmb3JtcyBSRVggbWFpbnRlbmFuY2UgYnkgcHJvY2Vzc2luZyBhIG1heGltdW0gb2Yge3ttYXh9fSBSRVggc2VsbCBvcmRlcnMgYW5kIGV4cGlyZWQgbG9hbnMuIEFueSBhY2NvdW50IGNhbiBleGVjdXRlIHRoaXMgYWN0aW9uLgCuQjrRW7e8C3JtdnByb2R1Y2VyggUtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBGb3JjaWJseSBVbnJlZ2lzdGVyIGEgQmxvY2sgUHJvZHVjZXIgQ2FuZGlkYXRlCnN1bW1hcnk6ICd7e25vd3JhcCBwcm9kdWNlcn19IGlzIHVucmVnaXN0ZXJlZCBhcyBhIGJsb2NrIHByb2R1Y2VyIGNhbmRpZGF0ZScKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL2FkbWluLnBuZyM5YmYxY2VjNjY0ODYzYmQ2YWFhYzBmODE0YjIzNWY4Nzk5ZmIwMmM4NTBlOWFhNWRhMzRlOGEwMDRiZDY1MThlCi0tLQoKe3skYWN0aW9uLmFjY291bnR9fSB1bnJlZ2lzdGVycyB7e3Byb2R1Y2VyfX0gYXMgYSBibG9jayBwcm9kdWNlciBjYW5kaWRhdGUuIHt7cHJvZHVjZXJ9fSBhY2NvdW50IHdpbGwgcmV0YWluIGl0cyB2b3RlcyBhbmQgdGhvc2Ugdm90ZXMgY2FuIGNoYW5nZSBiYXNlZCBvbiB2b3RlciBzdGFrZSBjaGFuZ2VzIG9yIHZvdGVzIHJlbW92ZWQgZnJvbSB7e3Byb2R1Y2VyfX0uIEhvd2V2ZXIgbmV3IHZvdGVycyB3aWxsIG5vdCBiZSBhYmxlIHRvIHZvdGUgZm9yIHt7cHJvZHVjZXJ9fSB3aGlsZSBpdCByZW1haW5zIHVucmVnaXN0ZXJlZC4AAABAmhujwgdzZWxscmFtxQMtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBTZWxsIFJBTSBGcm9tIEFjY291bnQKc3VtbWFyeTogJ1NlbGwgdW51c2VkIFJBTSBmcm9tIHt7bm93cmFwIGFjY291bnR9fScKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3Jlc291cmNlLnBuZyMzODMwZjFjZThjYjA3Zjc3NTdkYmNmMzgzYjFlYzFiMTE5MTRhYzM0YTFmOWQ4YjA2NWYwNzYwMGZhOWRhYzE5Ci0tLQoKU2VsbCB7e2J5dGVzfX0gYnl0ZXMgb2YgdW51c2VkIFJBTSBmcm9tIGFjY291bnQge3thY2NvdW50fX0gYXQgbWFya2V0IHByaWNlLiBUaGlzIHRyYW5zYWN0aW9uIHdpbGwgaW5jdXIgYSAwLjUlIGZlZSBvbiB0aGUgcHJvY2VlZHMgd2hpY2ggZGVwZW5kIG9uIG1hcmtldCByYXRlcy4AAACgqxujwgdzZWxscmV4qQotLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBTZWxsIFJFWCBUb2tlbnMgaW4gRXhjaGFuZ2UgZm9yIEVPUwpzdW1tYXJ5OiAne3tub3dyYXAgZnJvbX19IHNlbGxzIHt7bm93cmFwIHJleH19IHRva2VucycKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3JleC5wbmcjZDIyOTgzN2ZhNjJhNDY0YjljNzFlMDYwNjBhYTg2MTc5YWRmMGIzZjRlM2I4YzRmOTcwMmY0ZjRiMGMzNDBhOAotLS0KCnt7ZnJvbX19IGluaXRpYXRlcyBhIHNlbGwgb3JkZXIgdG8gc2VsbCB7e3JleH19IHRva2VucyBhdCB0aGUgbWFya2V0IGV4Y2hhbmdlIHJhdGUgZHVyaW5nIHRoZSB0aW1lIGF0IHdoaWNoIHRoZSBvcmRlciBpcyB1bHRpbWF0ZWx5IGV4ZWN1dGVkLiBJZiB7e2Zyb219fSBhbHJlYWR5IGhhcyBhbiBvcGVuIHNlbGwgb3JkZXIgaW4gdGhlIHNlbGwgcXVldWUsIHt7cmV4fX0gd2lsbCBiZSBhZGRlZCB0byB0aGUgYW1vdW50IG9mIHRoZSBzZWxsIG9yZGVyIHdpdGhvdXQgY2hhbmdlIHRoZSBwb3NpdGlvbiBvZiB0aGUgc2VsbCBvcmRlciB3aXRoaW4gdGhlIHF1ZXVlLiBPbmNlIHRoZSBzZWxsIG9yZGVyIGlzIGV4ZWN1dGVkLCBwcm9jZWVkcyBhcmUgYWRkZWQgdG8ge3tmcm9tfX3igJlzIFJFWCBmdW5kLCB0aGUgdmFsdWUgb2Ygc29sZCBSRVggdG9rZW5zIGlzIGRlZHVjdGVkIGZyb20ge3tmcm9tfX3igJlzIHZvdGUgc3Rha2UsIGFuZCB2b3RlcyBhcmUgdXBkYXRlZCBhY2NvcmRpbmdseS4KCkRlcGVuZGluZyBvbiB0aGUgbWFya2V0IGNvbmRpdGlvbnMsIGl0IG1heSBub3QgYmUgcG9zc2libGUgdG8gZmlsbCB0aGUgZW50aXJlIHNlbGwgb3JkZXIgaW1tZWRpYXRlbHkuIEluIHN1Y2ggYSBjYXNlLCB0aGUgc2VsbCBvcmRlciBpcyBhZGRlZCB0byB0aGUgYmFjayBvZiBhIHNlbGwgcXVldWUuIEEgc2VsbCBvcmRlciBhdCB0aGUgZnJvbnQgb2YgdGhlIHNlbGwgcXVldWUgd2lsbCBhdXRvbWF0aWNhbGx5IGJlIGV4ZWN1dGVkIHdoZW4gdGhlIG1hcmtldCBjb25kaXRpb25zIGFsbG93IGZvciB0aGUgZW50aXJlIG9yZGVyIHRvIGJlIGZpbGxlZC4gUmVnYXJkbGVzcyBvZiB0aGUgbWFya2V0IGNvbmRpdGlvbnMsIHRoZSBzeXN0ZW0gaXMgZGVzaWduZWQgdG8gZXhlY3V0ZSB0aGlzIHNlbGwgb3JkZXIgd2l0aGluIDMwIGRheXMuIHt7ZnJvbX19IGNhbiBjYW5jZWwgdGhlIG9yZGVyIGF0IGFueSB0aW1lIGJlZm9yZSBpdCBpcyBmaWxsZWQgdXNpbmcgdGhlIGNuY2xyZXhvcmRlciBhY3Rpb24uAAAAALhjssIGc2V0YWJp8wItLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBEZXBsb3kgQ29udHJhY3QgQUJJCnN1bW1hcnk6ICdEZXBsb3kgY29udHJhY3QgQUJJIG9uIGFjY291bnQge3tub3dyYXAgYWNjb3VudH19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvYWNjb3VudC5wbmcjM2Q1NWEyZmMzYTVjMjBiNDU2ZjU2NTdmYWY2NjZiYzI1ZmZkMDZmNDgzNmM1ZTgyNTZmNzQxMTQ5YjBiMjk0ZgotLS0KCkRlcGxveSB0aGUgQUJJIGZpbGUgYXNzb2NpYXRlZCB3aXRoIHRoZSBjb250cmFjdCBvbiBhY2NvdW50IHt7YWNjb3VudH19LgCArigjZLLCCnNldGFjY3RjcHWeBi0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IEV4cGxpY2l0bHkgTWFuYWdlIHRoZSBDUFUgUXVvdGEgb2YgQWNjb3VudApzdW1tYXJ5OiAnRXhwbGljaXRseSBtYW5hZ2UgdGhlIENQVSBiYW5kd2lkdGggcXVvdGEgb2YgYWNjb3VudCB7e25vd3JhcCBhY2NvdW50fX0nCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCnt7I2lmX2hhc192YWx1ZSBjcHVfd2VpZ2h0fX0KRXhwbGljaXRseSBtYW5hZ2UgdGhlIENQVSBiYW5kd2lkdGggcXVvdGEgb2YgYWNjb3VudCB7e2FjY291bnR9fSBieSBwaW5uaW5nIGl0IHRvIGEgd2VpZ2h0IG9mIHt7Y3B1X3dlaWdodH19LgoKe3thY2NvdW50fX0gY2FuIHN0YWtlIGFuZCB1bnN0YWtlLCBob3dldmVyLCBpdCB3aWxsIG5vdCBjaGFuZ2UgdGhlaXIgQ1BVIGJhbmR3aWR0aCBxdW90YSBhcyBsb25nIGFzIGl0IHJlbWFpbnMgcGlubmVkLgp7e2Vsc2V9fQpVbnBpbiB0aGUgQ1BVIGJhbmR3aWR0aCBxdW90YSBvZiBhY2NvdW50IHt7YWNjb3VudH19LiBUaGUgQ1BVIGJhbmR3aWR0aCBxdW90YSBvZiB7e2FjY291bnR9fSB3aWxsIGJlIGRyaXZlbiBieSB0aGUgY3VycmVudCB0b2tlbnMgc3Rha2VkIGZvciBDUFUgYmFuZHdpZHRoIGJ5IHt7YWNjb3VudH19Lgp7ey9pZl9oYXNfdmFsdWV9fQBAVjMjZLLCCnNldGFjY3RuZXSiBi0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IEV4cGxpY2l0bHkgTWFuYWdlIHRoZSBORVQgUXVvdGEgb2YgQWNjb3VudApzdW1tYXJ5OiAnRXhwbGljaXRseSBtYW5hZ2UgdGhlIE5FVCBiYW5kd2lkdGggcXVvdGEgb2YgYWNjb3VudCB7e25vd3JhcCBhY2NvdW50fX0nCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCnt7I2lmX2hhc192YWx1ZSBuZXRfd2VpZ2h0fX0KRXhwbGljaXRseSBtYW5hZ2UgdGhlIG5ldHdvcmsgYmFuZHdpZHRoIHF1b3RhIG9mIGFjY291bnQge3thY2NvdW50fX0gYnkgcGlubmluZyBpdCB0byBhIHdlaWdodCBvZiB7e25ldF93ZWlnaHR9fS4KCnt7YWNjb3VudH19IGNhbiBzdGFrZSBhbmQgdW5zdGFrZSwgaG93ZXZlciwgaXQgd2lsbCBub3QgY2hhbmdlIHRoZWlyIE5FVCBiYW5kd2lkdGggcXVvdGEgYXMgbG9uZyBhcyBpdCByZW1haW5zIHBpbm5lZC4Ke3tlbHNlfX0KVW5waW4gdGhlIE5FVCBiYW5kd2lkdGggcXVvdGEgb2YgYWNjb3VudCB7e2FjY291bnR9fS4gVGhlIE5FVCBiYW5kd2lkdGggcXVvdGEgb2Yge3thY2NvdW50fX0gd2lsbCBiZSBkcml2ZW4gYnkgdGhlIGN1cnJlbnQgdG9rZW5zIHN0YWtlZCBmb3IgTkVUIGJhbmR3aWR0aCBieSB7e2FjY291bnR9fS4Ke3svaWZfaGFzX3ZhbHVlfX0AgDQ3I2SywgpzZXRhY2N0cmFt0AUtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBFeHBsaWNpdGx5IE1hbmFnZSB0aGUgUkFNIFF1b3RhIG9mIEFjY291bnQKc3VtbWFyeTogJ0V4cGxpY2l0bHkgbWFuYWdlIHRoZSBSQU0gcXVvdGEgb2YgYWNjb3VudCB7e25vd3JhcCBhY2NvdW50fX0nCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCnt7I2lmX2hhc192YWx1ZSByYW1fYnl0ZXN9fQpFeHBsaWNpdGx5IG1hbmFnZSB0aGUgUkFNIHF1b3RhIG9mIGFjY291bnQge3thY2NvdW50fX0gYnkgcGlubmluZyBpdCB0byB7e3JhbV9ieXRlc319IGJ5dGVzLgoKe3thY2NvdW50fX0gY2FuIGJ1eSBhbmQgc2VsbCBSQU0sIGhvd2V2ZXIsIGl0IHdpbGwgbm90IGNoYW5nZSB0aGVpciBSQU0gcXVvdGEgYXMgbG9uZyBhcyBpdCByZW1haW5zIHBpbm5lZC4Ke3tlbHNlfX0KVW5waW4gdGhlIFJBTSBxdW90YSBvZiBhY2NvdW50IHt7YWNjb3VudH19LiBUaGUgUkFNIHF1b3RhIG9mIHt7YWNjb3VudH19IHdpbGwgYmUgZHJpdmVuIGJ5IHRoZSBjdXJyZW50IFJBTSBob2xkaW5ncyBvZiB7e2FjY291bnR9fS4Ke3svaWZfaGFzX3ZhbHVlfX0AAM5OumiywgpzZXRhbGltaXRz9gMtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBBZGp1c3QgUmVzb3VyY2UgTGltaXRzIG9mIEFjY291bnQKc3VtbWFyeTogJ0FkanVzdCByZXNvdXJjZSBsaW1pdHMgb2YgYWNjb3VudCB7e25vd3JhcCBhY2NvdW50fX0nCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCnt7JGFjdGlvbi5hY2NvdW50fX0gdXBkYXRlcyB7e2FjY291bnR9feKAmXMgcmVzb3VyY2UgbGltaXRzIHRvIGhhdmUgYSBSQU0gcXVvdGEgb2Yge3tyYW1fYnl0ZXN9fSBieXRlcywgYSBORVQgYmFuZHdpZHRoIHF1b3RhIG9mIHt7bmV0X3dlaWdodH19IGFuZCBhIENQVSBiYW5kd2lkdGggcXVvdGEgb2Yge3tjcHVfd2VpZ2h0fX0uAAAAQCWKssIHc2V0Y29kZeYCLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogRGVwbG95IENvbnRyYWN0IENvZGUKc3VtbWFyeTogJ0RlcGxveSBjb250cmFjdCBjb2RlIG9uIGFjY291bnQge3tub3dyYXAgYWNjb3VudH19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvYWNjb3VudC5wbmcjM2Q1NWEyZmMzYTVjMjBiNDU2ZjU2NTdmYWY2NjZiYzI1ZmZkMDZmNDgzNmM1ZTgyNTZmNzQxMTQ5YjBiMjk0ZgotLS0KCkRlcGxveSBjb21waWxlZCBjb250cmFjdCBjb2RlIHRvIHRoZSBhY2NvdW50IHt7YWNjb3VudH19LjCpyyau6bLCDHNldGluZmxhdGlvbusELS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogU2V0IEluZmxhdGlvbiBQYXJhbWV0ZXJzCnN1bW1hcnk6ICdTZXQgaW5mbGF0aW9uIHBhcmFtZXRlcnMnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCnt7JGFjdGlvbi5hY2NvdW50fX0gc2V0cyB0aGUgaW5mbGF0aW9uIHBhcmFtZXRlcnMgYXMgZm9sbG93czoKCiogQW5udWFsIGluZmxhdGlvbiByYXRlIChpbiB1bml0cyBvZiBhIGh1bmRyZWR0aCBvZiBhIHBlcmNlbnQpOiB7e2FubnVhbF9yYXRlfX0KKiBGcmFjdGlvbiBvZiBpbmZsYXRpb24gdXNlZCB0byByZXdhcmQgYmxvY2sgcHJvZHVjZXJzOiAxMDAwMC97e2luZmxhdGlvbl9wYXlfZmFjdG9yfX0KKiBGcmFjdGlvbiBvZiBibG9jayBwcm9kdWNlciByZXdhcmRzIHRvIGJlIGRpc3RyaWJ1dGVkIHByb3BvcnRpb25hbCB0byBibG9ja3MgcHJvZHVjZWQ6IDEwMDAwL3t7dm90ZXBheV9mYWN0b3J9fQAAwNJcU7PCCXNldHBhcmFtc9ACLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogU2V0IFN5c3RlbSBQYXJhbWV0ZXJzCnN1bW1hcnk6ICdTZXQgU3lzdGVtIFBhcmFtZXRlcnMnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCnt7JGFjdGlvbi5hY2NvdW50fX0gc2V0cyBzeXN0ZW0gcGFyYW1ldGVycyB0bzoKe3t0b19qc29uIHBhcmFtc319AAAAYLtbs8IHc2V0cHJpdo0ELS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogTWFrZSBhbiBBY2NvdW50IFByaXZpbGVnZWQgb3IgVW5wcml2aWxlZ2VkCnN1bW1hcnk6ICd7eyNpZiBpc19wcml2fX1NYWtlIHt7bm93cmFwIGFjY291bnR9fSBwcml2aWxlZ2Vke3tlbHNlfX1SZW1vdmUgcHJpdmlsZWdlZCBzdGF0dXMgb2Yge3tub3dyYXAgYWNjb3VudH19e3svaWZ9fScKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL2FkbWluLnBuZyM5YmYxY2VjNjY0ODYzYmQ2YWFhYzBmODE0YjIzNWY4Nzk5ZmIwMmM4NTBlOWFhNWRhMzRlOGEwMDRiZDY1MThlCi0tLQoKe3sjaWYgaXNfcHJpdn19Cnt7JGFjdGlvbi5hY2NvdW50fX0gbWFrZXMge3thY2NvdW50fX0gcHJpdmlsZWdlZC4Ke3tlbHNlfX0Ke3skYWN0aW9uLmFjY291bnR9fSByZW1vdmVzIHByaXZpbGVnZWQgc3RhdHVzIG9mIHt7YWNjb3VudH19Lgp7ey9pZn19AAAAAEhzs8IGc2V0cmFt5gItLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBDb25maWd1cmUgdGhlIEF2YWlsYWJsZSBSQU0Kc3VtbWFyeTogJ0NvbmZpZ3VyZSB0aGUgYXZhaWxhYmxlIFJBTScKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL2FkbWluLnBuZyM5YmYxY2VjNjY0ODYzYmQ2YWFhYzBmODE0YjIzNWY4Nzk5ZmIwMmM4NTBlOWFhNWRhMzRlOGEwMDRiZDY1MThlCi0tLQoKe3skYWN0aW9uLmFjY291bnR9fSBjb25maWd1cmVzIHRoZSBhdmFpbGFibGUgUkFNIHRvIHt7bWF4X3JhbV9zaXplfX0gYnl0ZXMuAIDK5kpzs8IKc2V0cmFtcmF0ZYUDLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogU2V0IHRoZSBSYXRlIG9mIEluY3JlYXNlIG9mIFJBTQpzdW1tYXJ5OiAnU2V0IHRoZSByYXRlIG9mIGluY3JlYXNlIG9mIFJBTSBwZXIgYmxvY2snCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCnt7JGFjdGlvbi5hY2NvdW50fX0gc2V0cyB0aGUgcmF0ZSBvZiBpbmNyZWFzZSBvZiBSQU0gdG8ge3tieXRlc19wZXJfYmxvY2t9fSBieXRlcy9ibG9jay4AAAAAdHWzwgZzZXRyZXi3Ay0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IEFkanVzdCBSRVggUG9vbCBWaXJ0dWFsIEJhbGFuY2UKc3VtbWFyeTogJ0FkanVzdCBSRVggUG9vbCBWaXJ0dWFsIEJhbGFuY2UnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCnt7JGFjdGlvbi5hY2NvdW50fX0gYWRqdXN0cyBSRVggbG9hbiByYXRlIGJ5IHNldHRpbmcgUkVYIHBvb2wgdmlydHVhbCBiYWxhbmNlIHRvIHt7YmFsYW5jZX19LiBObyB0b2tlbiB0cmFuc2ZlciBvciBpc3N1ZSBpcyBleGVjdXRlZCBpbiB0aGlzIGFjdGlvbi7Aj8qGqajS1Ax1bmRlbGVnYXRlYnehBy0tLQpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IFVuc3Rha2UgVG9rZW5zIGZvciBORVQgYW5kL29yIENQVQpzdW1tYXJ5OiAnVW5zdGFrZSB0b2tlbnMgZm9yIE5FVCBhbmQvb3IgQ1BVIGZyb20ge3tub3dyYXAgcmVjZWl2ZXJ9fScKaWNvbjogaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2Vvc25ldHdvcmtmb3VuZGF0aW9uL2Vvcy1zeXN0ZW0tY29udHJhY3RzL21haW4vY29udHJhY3RzL2ljb25zL3Jlc291cmNlLnBuZyMzODMwZjFjZThjYjA3Zjc3NTdkYmNmMzgzYjFlYzFiMTE5MTRhYzM0YTFmOWQ4YjA2NWYwNzYwMGZhOWRhYzE5Ci0tLQoKe3tmcm9tfX0gdW5zdGFrZXMgZnJvbSB7e3JlY2VpdmVyfX0ge3t1bnN0YWtlX25ldF9xdWFudGl0eX19IGZvciBORVQgYmFuZHdpZHRoIGFuZCB7e3Vuc3Rha2VfY3B1X3F1YW50aXR5fX0gZm9yIENQVSBiYW5kd2lkdGguCgpUaGUgc3VtIG9mIHRoZXNlIHR3byBxdWFudGl0aWVzIHdpbGwgYmUgcmVtb3ZlZCBmcm9tIHRoZSB2b3RlIHdlaWdodCBvZiB7e3JlY2VpdmVyfX0gYW5kIHdpbGwgYmUgbWFkZSBhdmFpbGFibGUgdG8ge3tmcm9tfX0gYWZ0ZXIgYW4gdW5pbnRlcnJ1cHRlZCAzIGRheSBwZXJpb2Qgd2l0aG91dCBmdXJ0aGVyIHVuc3Rha2luZyBieSB7e2Zyb219fS4gQWZ0ZXIgdGhlIHVuaW50ZXJydXB0ZWQgMyBkYXkgcGVyaW9kIHBhc3NlcywgdGhlIHN5c3RlbSB3aWxsIGF0dGVtcHQgdG8gYXV0b21hdGljYWxseSByZXR1cm4gdGhlIGZ1bmRzIHRvIHt7ZnJvbX194oCZcyByZWd1bGFyIHRva2VuIGJhbGFuY2UuIEhvd2V2ZXIsIHRoaXMgYXV0b21hdGljIHJlZnVuZCBtYXkgb2NjYXNpb25hbGx5IGZhaWwgd2hpY2ggd2lsbCB0aGVuIHJlcXVpcmUge3tmcm9tfX0gdG8gbWFudWFsbHkgY2xhaW0gdGhlIGZ1bmRzIHdpdGggdGhlIHJlZnVuZCBhY3Rpb24uAEDL2sDp4tQKdW5saW5rYXV0aJEFLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogVW5saW5rIEFjdGlvbiBmcm9tIFBlcm1pc3Npb24Kc3VtbWFyeTogJ3t7bm93cmFwIGFjY291bnR9fSB1bnNldHMgdGhlIG1pbmltdW0gcmVxdWlyZWQgcGVybWlzc2lvbiBmb3IgdGhlIHt7I2lmIHR5cGV9fXt7bm93cmFwIHR5cGV9fSBhY3Rpb24gb2YgdGhle3svaWZ9fSB7e25vd3JhcCBjb2RlfX0gY29udHJhY3QnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hY2NvdW50LnBuZyMzZDU1YTJmYzNhNWMyMGI0NTZmNTY1N2ZhZjY2NmJjMjVmZmQwNmY0ODM2YzVlODI1NmY3NDExNDliMGIyOTRmCi0tLQoKe3thY2NvdW50fX0gcmVtb3ZlcyB0aGUgYXNzb2NpYXRpb24gYmV0d2VlbiB0aGUge3sjaWYgdHlwZX19e3t0eXBlfX0gYWN0aW9uIG9mIHRoZXt7L2lmfX0ge3tjb2RlfX0gY29udHJhY3QgYW5kIGl0cyBtaW5pbXVtIHJlcXVpcmVkIHBlcm1pc3Npb24uCgp7eyNpZiB0eXBlfX17e2Vsc2V9fVRoaXMgd2lsbCBub3QgcmVtb3ZlIGFueSBsaW5rcyBleHBsaWNpdGx5IGFzc29jaWF0ZWQgdG8gc3BlY2lmaWMgYWN0aW9ucyBvZiB7e2NvZGV9fS57ey9pZn19AABI9Fam7tQJdW5yZWdwcm9k5QQtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBVbnJlZ2lzdGVyIGFzIGEgQmxvY2sgUHJvZHVjZXIgQ2FuZGlkYXRlCnN1bW1hcnk6ICd7e25vd3JhcCBwcm9kdWNlcn19IHVucmVnaXN0ZXJzIGFzIGEgYmxvY2sgcHJvZHVjZXIgY2FuZGlkYXRlJwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvdm90aW5nLnBuZyNkYjI4Y2QzZGI2ZTYyZDQ1MDlhZjM2NDRjZTdkMzc3MzI5NDgyYTE0YmI0YmZhY2EyYWE1ZjE0MDBkOGU4YTg0Ci0tLQoKe3twcm9kdWNlcn19IHVucmVnaXN0ZXJzIGFzIGEgYmxvY2sgcHJvZHVjZXIgY2FuZGlkYXRlLiB7e3Byb2R1Y2VyfX0gYWNjb3VudCB3aWxsIHJldGFpbiBpdHMgdm90ZXMgYW5kIHRob3NlIHZvdGVzIGNhbiBjaGFuZ2UgYmFzZWQgb24gdm90ZXIgc3Rha2UgY2hhbmdlcyBvciB2b3RlcyByZW1vdmVkIGZyb20ge3twcm9kdWNlcn19LiBIb3dldmVyIG5ldyB2b3RlcnMgd2lsbCBub3QgYmUgYWJsZSB0byB2b3RlIGZvciB7e3Byb2R1Y2VyfX0gd2hpbGUgaXQgcmVtYWlucyB1bnJlZ2lzdGVyZWQu0NWlWUGT8dQMdW5zdGFrZXRvcmV44wYtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBCdXkgUkVYIFRva2VucyBVc2luZyBTdGFrZWQgVG9rZW5zCnN1bW1hcnk6ICd7e25vd3JhcCBvd25lcn19IGJ1eXMgUkVYIHRva2VucyBpbiBleGNoYW5nZSBmb3IgdG9rZW5zIGN1cnJlbnRseSBzdGFrZWQgdG8gTkVUIGFuZC9vciBDUFUnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9yZXgucG5nI2QyMjk4MzdmYTYyYTQ2NGI5YzcxZTA2MDYwYWE4NjE3OWFkZjBiM2Y0ZTNiOGM0Zjk3MDJmNGY0YjBjMzQwYTgKLS0tCgp7e2Zyb21fbmV0fX0gYW5kIHt7ZnJvbV9jcHV9fSBhcmUgd2l0aGRyYXduIGZyb20ge3tyZWNlaXZlcn194oCZcyBORVQgYW5kIENQVSBiYW5kd2lkdGhzIHJlc3BlY3RpdmVseS4gVGhlc2UgZnVuZHMgYXJlIHVzZWQgdG8gcHVyY2hhc2UgUkVYIHRva2VucyBhdCB0aGUgY3VycmVudCBtYXJrZXQgZXhjaGFuZ2UgcmF0ZS4gSW4gb3JkZXIgZm9yIHRoZSBhY3Rpb24gdG8gc3VjY2VlZCwge3tvd25lcn19IG11c3QgaGF2ZSB2b3RlZCBmb3IgYSBwcm94eSBvciBhdCBsZWFzdCAyMSBibG9jayBwcm9kdWNlcnMuCgpBIHNlbGwgb3JkZXIgb2YgdGhlIHB1cmNoYXNlZCBhbW91bnQgY2FuIG9ubHkgYmUgaW5pdGlhdGVkIGFmdGVyIHdhaXRpbmcgZm9yIHRoZSBtYXR1cml0eSBwZXJpb2Qgb2YgNCB0byA1IGRheXMgdG8gcGFzcy4gRXZlbiB0aGVuLCBkZXBlbmRpbmcgb24gdGhlIG1hcmtldCBjb25kaXRpb25zLCB0aGUgaW5pdGlhdGVkIHNlbGwgb3JkZXIgbWF5IG5vdCBiZSBleGVjdXRlZCBpbW1lZGlhdGVseS4AQMvaqGxS1Qp1cGRhdGVhdXRo7QMtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBNb2RpZnkgQWNjb3VudCBQZXJtaXNzaW9uCnN1bW1hcnk6ICdBZGQgb3IgdXBkYXRlIHRoZSB7e25vd3JhcCBwZXJtaXNzaW9ufX0gcGVybWlzc2lvbiBvZiB7e25vd3JhcCBhY2NvdW50fX0nCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hY2NvdW50LnBuZyMzZDU1YTJmYzNhNWMyMGI0NTZmNTY1N2ZhZjY2NmJjMjVmZmQwNmY0ODM2YzVlODI1NmY3NDExNDliMGIyOTRmCi0tLQoKTW9kaWZ5LCBhbmQgY3JlYXRlIGlmIG5lY2Vzc2FyeSwgdGhlIHt7cGVybWlzc2lvbn19IHBlcm1pc3Npb24gb2Yge3thY2NvdW50fX0gdG8gaGF2ZSBhIHBhcmVudCBwZXJtaXNzaW9uIG9mIHt7cGFyZW50fX0gYW5kIHRoZSBmb2xsb3dpbmcgYXV0aG9yaXR5Ogp7e3RvX2pzb24gYXV0aH19AADo6qpsUtUJdXBkYXRlcmV4gQMtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBVcGRhdGUgUkVYIE93bmVyIFZvdGUgV2VpZ2h0CnN1bW1hcnk6ICdVcGRhdGUgdm90ZSB3ZWlnaHQgdG8gY3VycmVudCB2YWx1ZSBvZiBoZWxkIFJFWCB0b2tlbnMnCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9yZXgucG5nI2QyMjk4MzdmYTYyYTQ2NGI5YzcxZTA2MDYwYWE4NjE3OWFkZjBiM2Y0ZTNiOGM0Zjk3MDJmNGY0YjBjMzQwYTgKLS0tCgpVcGRhdGUgdm90ZSB3ZWlnaHQgb2Yge3tvd25lcn19IGFjY291bnQgdG8gY3VycmVudCB2YWx1ZSBvZiBoZWxkIFJFWCB0b2tlbnMuMKnDbqubU9UMdXBkdHJldmlzaW9uggMtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBVcGRhdGUgU3lzdGVtIENvbnRyYWN0IFJldmlzaW9uIE51bWJlcgpzdW1tYXJ5OiAnVXBkYXRlIHN5c3RlbSBjb250cmFjdCByZXZpc2lvbiBudW1iZXInCmljb246IGh0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9lb3NuZXR3b3JrZm91bmRhdGlvbi9lb3Mtc3lzdGVtLWNvbnRyYWN0cy9tYWluL2NvbnRyYWN0cy9pY29ucy9hZG1pbi5wbmcjOWJmMWNlYzY2NDg2M2JkNmFhYWMwZjgxNGIyMzVmODc5OWZiMDJjODUwZTlhYTVkYTM0ZThhMDA0YmQ2NTE4ZQotLS0KCnt7JGFjdGlvbi5hY2NvdW50fX0gYWR2YW5jZXMgdGhlIHN5c3RlbSBjb250cmFjdCByZXZpc2lvbiBudW1iZXIgdG8ge3tyZXZpc2lvbn19LnAV0oneqjLdDHZvdGVwcm9kdWNlcq0GLS0tCnNwZWNfdmVyc2lvbjogIjAuMi4wIgp0aXRsZTogVm90ZSBmb3IgQmxvY2sgUHJvZHVjZXJzCnN1bW1hcnk6ICd7e25vd3JhcCB2b3Rlcn19IHZvdGVzIGZvciB7eyNpZiBwcm94eX19dGhlIHByb3h5IHt7bm93cmFwIHByb3h5fX17e2Vsc2V9fXVwIHRvIDMwIGJsb2NrIHByb2R1Y2VyIGNhbmRpZGF0ZXN7ey9pZn19JwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvdm90aW5nLnBuZyNkYjI4Y2QzZGI2ZTYyZDQ1MDlhZjM2NDRjZTdkMzc3MzI5NDgyYTE0YmI0YmZhY2EyYWE1ZjE0MDBkOGU4YTg0Ci0tLQoKe3sjaWYgcHJveHl9fQp7e3ZvdGVyfX0gdm90ZXMgZm9yIHRoZSBwcm94eSB7e3Byb3h5fX0uCkF0IHRoZSB0aW1lIG9mIHZvdGluZyB0aGUgZnVsbCB3ZWlnaHQgb2Ygdm90ZXLigJlzIHN0YWtlZCAoQ1BVICsgTkVUKSB0b2tlbnMgd2lsbCBiZSBjYXN0IHRvd2FyZHMgZWFjaCBvZiB0aGUgcHJvZHVjZXJzIHZvdGVkIGJ5IHt7cHJveHl9fS4Ke3tlbHNlfX0Ke3t2b3Rlcn19IHZvdGVzIGZvciB0aGUgZm9sbG93aW5nIGJsb2NrIHByb2R1Y2VyIGNhbmRpZGF0ZXM6Cgp7eyNlYWNoIHByb2R1Y2Vyc319CiAgKyB7e3RoaXN9fQp7ey9lYWNofX0KCkF0IHRoZSB0aW1lIG9mIHZvdGluZyB0aGUgZnVsbCB3ZWlnaHQgb2Ygdm90ZXLigJlzIHN0YWtlZCAoQ1BVICsgTkVUKSB0b2tlbnMgd2lsbCBiZSBjYXN0IHRvd2FyZHMgZWFjaCBvZiB0aGUgYWJvdmUgcHJvZHVjZXJzLgp7ey9pZn19AIDKJlWtMt0Kdm90ZXVwZGF0ZQAAAACALSSx4Qd3YXNtY2ZnAAAAANzc1LLjCHdpdGhkcmF3yQMtLS0Kc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBXaXRoZHJhdyBmcm9tIFJFWCBGdW5kCnN1bW1hcnk6ICdXaXRoZHJhdyB7e25vd3JhcCBhbW91bnR9fSBmcm9tIHt7bm93cmFwIG93bmVyfX3igJlzIFJFWCBmdW5kIGJ5IHRyYW5zZmVycmluZyB0byB7e293bmVyfX3igJlzIGxpcXVpZCBiYWxhbmNlJwppY29uOiBodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vZW9zbmV0d29ya2ZvdW5kYXRpb24vZW9zLXN5c3RlbS1jb250cmFjdHMvbWFpbi9jb250cmFjdHMvaWNvbnMvcmV4LnBuZyNkMjI5ODM3ZmE2MmE0NjRiOWM3MWUwNjA2MGFhODYxNzlhZGYwYjNmNGUzYjhjNGY5NzAyZjRmNGIwYzM0MGE4Ci0tLQoKV2l0aGRyYXdzIHt7YW1vdW50fX0gZnJvbSB7e293bmVyfX3igJlzIFJFWCBmdW5kIGFuZCB0cmFuc2ZlciB0aGVtIHRvIHt7b3duZXJ9feKAmXMgbGlxdWlkIGJhbGFuY2UuGgAAAKBh09wxA2k2NAAACGFiaV9oYXNoAABOUy91kzsDaTY0AAAKYmlkX3JlZnVuZAAAoGs6iGg8A2k2NAAAEWJsb2NrX2luZm9fcmVjb3JkAAAAYBoadUUDaTY0AAAIcmV4X2xvYW4AAAAgTXOiSgNpNjQAABNkZWxlZ2F0ZWRfYmFuZHdpZHRoAAAAAERzaGQDaTY0AAASZW9zaW9fZ2xvYmFsX3N0YXRlAAAAQERzaGQDaTY0AAATZW9zaW9fZ2xvYmFsX3N0YXRlMgAAAGBEc2hkA2k2NAAAE2Vvc2lvX2dsb2JhbF9zdGF0ZTMAAACARHNoZANpNjQAABNlb3Npb19nbG9iYWxfc3RhdGU0AAAAOLmjpJkDaTY0AAAIbmFtZV9iaWQAAABgGhqzmgNpNjQAAAhyZXhfbG9hbgCuSpeCqjmtA2k2NAAADXBvd2VydXBfb3JkZXIAVDYZg6o5rQNpNjQAAA1wb3dlcnVwX3N0YXRlAADAVyGd6K0DaTY0AAANcHJvZHVjZXJfaW5mbwCAwFchneitA2k2NAAADnByb2R1Y2VyX2luZm8yAADICl4jpbkDaTY0AAAOZXhjaGFuZ2Vfc3RhdGUAAAAAp6mXugNpNjQAAA5yZWZ1bmRfcmVxdWVzdAAAzgoifbK6A2k2NAAAEnJleF9yZXR1cm5fYnVja2V0cwAAAABEc7q6A2k2NAAAC3JleF9iYWxhbmNlAAAAIE29uroDaTY0AAAIcmV4X2Z1bmQAAAAgUlq7ugNpNjQAAAhyZXhfcG9vbAAAAEorbbu6A2k2NAAACXJleF9vcmRlcgBApLRmdbu6A2k2NAAAD3JleF9yZXR1cm5fcG9vbAAAAACrexXWA2k2NAAADnVzZXJfcmVzb3VyY2VzAAAAAOCrMt0DaTY0AAAKdm90ZXJfaW5mb8Aaalmb7KSLA2k2NAAAEWxpbWl0X2F1dGhfY2hhbmdlAg1Vc2VyQWdyZWVtZW507H8jIEVPUyBVc2VyIEFncmVlbWVudAoKIyMgRGVmaW5pdGlvbnMKCiBBbGwgY2FwaXRhbGl6ZWQsIGl0YWxpY2l6ZWQsIG9yIGlubGluZSBjb2RlIHRlcm1zIGluICpUaGUgRU9TIFVzZXIgQWdyZWVtZW50KiB3aWxsIGJlIGdpdmVuIHRoZSBzYW1lIGVmZmVjdCBhbmQgbWVhbmluZyBhcyBpbiAqRGVmaW5pdGlvbnMqLgoKKiBFT1MgVXNlciBBZ3JlZW1lbnQ6IFRoaXMgZG9jdW1lbnQgKCpFVUEqKQoKKiBDaGFpbiBJRDogYGNoYWluX2lkYOKAii3igIphY2EzNzZmMjA2YjhmYzI1YTZlZDQ0ZGJkYzY2NTQ3YzM2YzZjMzNlM2ExMTlmZmJlYWVmOTQzNjQyZjBlOTA2CgoqIFVzZXI6IEFueSBwZXJzb24gb3Igb3JnYW5pemF0aW9uIG9mIHBlcnNvbnMgd2hvIG1haW50YWluKHMpIGRpcmVjdCBvciBpbmRpcmVjdCBvd25lcnNoaXAgb2YgYW4gRU9TIGFjY291bnQsIG9yIEVPUy1iYXNlZCBwcm9wZXJ0eSBjb25uZWN0ZWQgdG8gYW4gRU9TIGFjY291bnQuCgoqIE93bmVyc2hpcDogRGlyZWN0IG9yIGluZGlyZWN0IGFjY2VzcyB0byBhbiBFT1MgYWNjb3VudCB0aHJvdWdoIG9uZSBvciBtb3JlIHZhbGlkIHBlcm1pc3Npb25zIGNoZWNrcy4gT3duZXJzaGlwIG1heSBiZSBwYXJ0aWFsbHkgc2hhcmVkIGJldHdlZW4gVXNlcnMgdGhyb3VnaCB0aGUgdXNlIG9mIG11bHRpLXNpZ25hdHVyZSBwZXJtaXNzaW9ucy4KCiogQmxvY2sgUHJvZHVjZXI6IFVzZXJzIHdobyBoYXZlIGNhbGxlZCBgcmVncHJvZHVjZXJgIGFuZCByZWNlaXZlIHJld2FyZHMgZnJvbSBlb3Npby52cGF5LgoKKiBgZW9zaW8ucHJvZHNgOiBBbiBFT1MgYWNjb3VudCB3aXRoIGEgZHluYW1pYyBwZXJtaXNzaW9ucyBzdHJ1Y3R1cmUgdGhhdCBjYW4gYXNzdW1lIHRoZSBwcml2aWxlZ2VzIG9mIHRoZSBgZW9zaW9gIGFjY291bnQgd2hlbiAxNS8yMSBCbG9jayBQcm9kdWNlcnMgYWdyZWUgdG8gZG8gc28uCgoqIE5ldHdvcmsgRnVuZHM6IFRva2VucyBjb250YWluZWQgd2l0aGluIHRoZSBmb2xsb3dpbmcgYWNjb3VudHM6IGBlb3Npby5uYW1lc2AsIGBlb3Npby5yYW1mZWVgLCBgZW9zaW8uc2F2aW5nYC4KCiogR292ZXJuaW5nIERvY3VtZW50czogKnJlZ3Byb2R1Y2VyKiBpcyBjb25zaWRlcmVkIGEgZ292ZXJuaW5nIGRvY3VtZW50LgoKKiBPbi1DaGFpbjogQW55IHRyYW5zYWN0aW9uLCBzbWFydCBjb250cmFjdCwgb3IgUmljYXJkaWFuIGNvbnRyYWN0IHdoaWNoIGlzIGxvY2F0ZWQgd2l0aGluIGEgYmxvY2sgdGhhdCBpcyBpcnJldmVyc2libGUgYW5kIGFwcGVuZGVkIHRvIHRoZSBFT1MgYmxvY2tjaGFpbiBgY2hhaW5faWRgLgoKKiBFT1MtYmFzZWQgUHJvcGVydHk6IEFueXRoaW5nIHRoYXQgcmVxdWlyZXMgYSB2YWxpZCBwZXJtaXNzaW9uIGluIG9yZGVyIHRvIGRpcmVjdGx5IG1hbmlwdWxhdGUsIGFsdGVyLCB0cmFuc2ZlciwgaW5mbHVlbmNlLCBvciBvdGhlcndpc2UgZWZmZWN0IG9uIHRoZSBFT1MgQmxvY2tjaGFpbgoKKiBDYWxsOiBUbyBzdWJtaXQgYW4gYWN0aW9uIHRvIHRoZSBFT1MgQmxvY2tjaGFpbiBgY2hhaW5faWRgLgoKKiBBdXRob3JpemF0aW9ucyAmIFBlcm1pc3Npb25zOiBQZXJtaXNzaW9ucyBhcmUgYXJiaXRyYXJ5IG5hbWVzIHVzZWQgdG8gZGVmaW5lIHRoZSByZXF1aXJlbWVudHMgZm9yIGEgdHJhbnNhY3Rpb24gc2VudCBvbiBiZWhhbGYgb2YgdGhhdCBwZXJtaXNzaW9uLiBQZXJtaXNzaW9ucyBjYW4gYmUgYXNzaWduZWQgZm9yIGF1dGhvcml0eSBvdmVyIHNwZWNpZmljIGNvbnRyYWN0IGFjdGlvbnMuCgoqIFJpY2FyZGlhbiBDb250cmFjdDogQSBjb250cmFjdCB0aGF0IHBsYWNlcyB0aGUgZGVmaW5pbmcgZWxlbWVudHMgb2YgYSBsZWdhbCBhZ3JlZW1lbnQgaW4gYSBmb3JtYXQgdGhhdCBjYW4gYmUgZXhwcmVzc2VkIGFuZCBleGVjdXRlZCBpbiBzb2Z0d2FyZS4KCiMjIEFydGljbGUgSSAt4oCKIFVzZXIgQWNrbm93bGVkZ2VtZW50IG9mIFJpc2tzCklmIFVzZXIgbG9zZXMgYWNjZXNzIHRvIHRoZWlyIEVPUyBhY2NvdW50IG9uIGBjaGFpbl9pZGAgYW5kIGhhcyBub3QgdGFrZW4gYXBwcm9wcmlhdGUgbWVhc3VyZXMgdG8gc2VjdXJlIGFjY2VzcyB0byB0aGVpciBFT1MgYWNjb3VudCBieSBvdGhlciBtZWFucywgdGhlIFVzZXIgYWNrbm93bGVkZ2VzIGFuZCBhZ3JlZXMgdGhhdCB0aGF0IEVPUyBhY2NvdW50IHdpbGwgYmVjb21lIGluYWNjZXNzaWJsZS4gVXNlcnMgYWNrbm93bGVkZ2UgdGhhdCB0aGUgVXNlciBoYXMgYW4gYWRlcXVhdGUgdW5kZXJzdGFuZGluZyBvZiB0aGUgcmlza3MsIHVzYWdlIGFuZCBpbnRyaWNhY2llcyBvZiBjcnlwdG9ncmFwaGljIHRva2VucyBhbmQgYmxvY2tjaGFpbi1iYXNlZCBzb2Z0d2FyZS4gVGhlIFVzZXIgYWNrbm93bGVkZ2VzIGFuZCBhZ3JlZXMgdGhhdCB0aGUgVXNlciBpcyB1c2luZyB0aGUgRU9TIGJsb2NrY2hhaW4gYXQgdGhlaXIgc29sZSByaXNrLgoKIyMgQXJ0aWNsZSBJSeKAii3igIpTcGVjaWFsIFVzZXIgVHlwZXMKVXNlcnMgd2hvIGNhbGwgYHJlZ3Byb2R1Y2VyYCBhZ3JlZSB0bywgYW5kIGFyZSBib3VuZCBieSwgdGhlICpyZWdwcm9kdWNlciogUmljYXJkaWFuIENvbnRyYWN0LgoKIyMgQXJ0aWNsZSBJSUnigIot4oCKQ29uc2VudCBvZiB0aGUgRVVBClRoZSBuYXR1cmUgb2YgdGhlICpFT1MgVXNlciBBZ3JlZW1lbnQqIGlzIHN1Y2ggdGhhdCBpdCBzZXJ2ZXMgYXMgYSBkZXNjcmlwdGlvbiBvZiB0aGUgY3VycmVudCBFT1MgTWFpbm5ldCBnb3Zlcm5hbmNlIGZ1bmN0aW9ucyB0aGF0IGFyZSBpbiBwbGFjZS4gVGhlc2UgZnVuY3Rpb25zLCBlbmZvcmNlZCBieSBjb2RlLCBkbyBub3QgcmVxdWlyZSB0aGUgY29uc2VudCBvZiBVc2VycyBhcyB0aGVzZSBmdW5jdGlvbnMgYXJlIGluaGVyZW50IGFuZCBzeXN0ZW1pYyB0byB0aGUgRU9TIE1haW5uZXQgaXRzZWxmLgoKIyMgQXJ0aWNsZSBJVuKAii3igIpHb3Zlcm5pbmcgRG9jdW1lbnRzCkFueSBtb2RpZmljYXRpb25zIHRvIHRoZSAqRVVBKiBhbmQgKmdvdmVybmluZyBkb2N1bWVudHMqIG1heSBiZSBtYWRlIGJ5IGBlb3Npby5wcm9kc2AuIEl0IGlzIGFkbW9uaXNoZWQgdGhhdCBhIHN0YXRlbWVudCBiZSBjcmFmdGVkIGFuZCBpc3N1ZWQgdGhyb3VnaCBgZW9zaW8ucHJvZHNgIHZpYSBlb3Npby5mb3J1bSByZWZlcmVuZHVtIGNvbnRyYWN0IGRlc2NyaWJpbmcgc3VjaCBhIG1vZGlmaWNhdGlvbiBpbiBhZHZhbmNlLgoKIyMgQXJ0aWNsZSBW4oCKLeKAik5hdGl2ZSBVbml0IG9mIFZhbHVlClRoZSBuYXRpdmUgdW5pdCBvZiB2YWx1ZSBvbiBFT1MgY2hhaW5faWQgc2hhbGwgYmUgdGhlIEVPUyB0b2tlbiBhcyBkZWZpbmVkIGFuZCBjcmVhdGVkIGJ5IHRoZSBgZW9zaW8udG9rZW5gIHNtYXJ0IGNvbnRyYWN0LgoKIyMgQXJ0aWNsZSBWSeKAii3igIpNYWludGFpbmluZyB0aGUgRU9TIGJsb2NrY2hhaW4KYGVvc2lvLnByb2RzYCB3aWxsIG1haW50YWluIHRoZSBhY3RpdmUgYmxvY2tjaGFpbiBjb2RlYmFzZSB3aGljaCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCB0aGUgaW1wbGVtZW50YXRpb24gb2YgYWxsIG1vZGlmaWNhdGlvbnMgb2YgYWxsIGZlYXR1cmVzLCBvcHRpbWl6YXRpb25zLCBhbmQgdXBncmFkZXM6IHByZXNlbnQgYW5kIGZ1dHVyZS4KCiMjIEFydGljbGUgVklJ4oCKLeKAik5ldHdvcmsgRnVuZHMKSXQgaXMgYWRtb25pc2hlZCB0aGF0IGFueSBhbHRlcmluZyBvZiB0aGUgc3RhdGUgb2YgYW55IHRva2VucyBjb250YWluZWQgd2l0aGluIG5ldHdvcmsgZnVuZCBhY2NvdW50cywgb3IgYWx0ZXJpbmcgYW55IHByZS1leGlzdGluZyBjb2RlIHRoYXQgZGlyZWN0bHkgb3IgaW5kaXJlY3RseSBnb3Zlcm5zIHRoZSBhbGxvY2F0aW9uLCBmdWxmaWxsbWVudCwgb3IgZGlzdHJpYnV0aW9uIG9mIGFueSAqbmV0d29yayBmdW5kcyogYmUgcHJlY2VkZWQgYnkgYSBzdGF0ZW1lbnQgY3JhZnRlZCBhbmQgaXNzdWVkIGJ5IGBlb3Npby5wcm9kc2AgdG8gdGhlICplb3Npby5mb3J1bSogcmVmZXJlbmR1bSBzeXN0ZW0gY29udHJhY3QgZGVzY3JpYmluZyB0aGUgZWZmZWN0IGluIGFkdmFuY2UuCgojIyBBcnRpY2xlIFZJSUnigIot4oCKRnJlZWRvbSBvZiBBY2NvdW50IENyZWF0aW9uCkFueSBjdXJyZW50IG9yIGZ1dHVyZSBVc2VyIGlzIGFibGUgdG8gY3JlYXRlIGFuIEVPUyBBY2NvdW50IHdpdGhvdXQgdGhlIHBlcm1pc3Npb24gYnkgYW55IG90aGVyIFVzZXIuIGBlb3Npby5wcm9kc2AgbWF5IG5ldmVyIGFmZmVjdCBhbiBFT1MgVXNlciBBY2NvdW50KHMpIHdpdGhvdXQgdmFsaWQgcGVybWlzc2lvbihzKSB3aGljaCBoYXZlIGJlZW4gc2hhcmVkIHdpdGggYGVvc2lvLnByb2RzYCBieSBhbiBFT1MgYWNjb3VudC4gYGVvc2lvLnByb2RzYCBtYXkgY2hhcmdlIGEgZmVlIGZvciBhbnkgYWN0aW9ucyB0aGF0IGFyZSByZXF1ZXN0ZWQgYnkgb3RoZXIgVXNlcnMgcGVydGFpbmluZyB0byBhbiBFT1MgYWNjb3VudCB3aGVyZSBwZXJtaXNzaW9ucyBhcmUgc2hhcmVkLgoKIyMgQXJ0aWNsZSBJWOKAii3igIpObyBGaWR1Y2lhcnkKTm8gVXNlciBzaGFsbCBoYXZlIGEgZmlkdWNpYXJ5IHB1cnBvc2UgdG8gc3VwcG9ydCB0aGUgdmFsdWUgb2YgdGhlIEVPUyB0b2tlbi4gTm8gVXNlciBjYW4gYXV0aG9yaXplIGFueW9uZSB0byBob2xkIGFzc2V0cywgYm9ycm93LCBzcGVhaywgY29udHJhY3Qgb24gYmVoYWxmIG9mIG90aGVyIEVPUyBVc2VycyBvciB0aGUgRU9TIGJsb2NrY2hhaW4gYGNoYWluX2lkYCBjb2xsZWN0aXZlbHkuIFRoaXMgRU9TIGJsb2NrY2hhaW4gc2hhbGwgaGF2ZSBubyBvd25lcnMsIG1hbmFnZXJzLCBvciBmaWR1Y2lhcmllcy4KCiMjIEFydGljbGUgWOKAii3igIpVc2VyIFNlY3VyaXR5CkFsbCBpdGVtcyBwZXJ0YWluaW5nIHRvIHBlcnNvbmFsIGFjY291bnQgc2VjdXJpdHksIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIHNhZmVrZWVwaW5nIG9mIHByaXZhdGUga2V5cywgaXMgc29sZWx5IHRoZSByZXNwb25zaWJpbGl0eSBvZiB0aGUgVXNlciB0byBzZWN1cmUuCgojIyBBcnRpY2xlIFhJIC0gYGVvc2lvLnByb2RzYCBMaW1pdGVkIExpYWJpbGl0eQpUaGUgVXNlciBhY2tub3dsZWRnZXMgYW5kIGFncmVlcyB0aGF0LCB0byB0aGUgZnVsbGVzdCBleHRlbnQgcGVybWl0dGVkIGJ5IGFueSBhcHBsaWNhYmxlIGxhdywgdGhpcyBkaXNjbGFpbWVyIG9mIGxpYWJpbGl0eSBhcHBsaWVzIHRvIGFueSBhbmQgYWxsIGRhbWFnZXMgb3IgaW5qdXJ5IHdoYXRzb2V2ZXIgY2F1c2VkIGJ5IG9yIHJlbGF0ZWQgdG8gcmlza3Mgb2YsIHVzZSBvZiwgb3IgaW5hYmlsaXR5IHRvIHVzZSwgdGhlIEVPUyB0b2tlbiBvciB0aGUgRU9TIGJsb2NrY2hhaW4gYGNoYWluX2lkYCB1bmRlciBhbnkgY2F1c2Ugb2YgYWN0aW9uIHdoYXRzb2V2ZXIgb2YgYW55IGtpbmQgaW4gYW55IGp1cmlzZGljdGlvbiwgaW5jbHVkaW5nLCB3aXRob3V0IGxpbWl0YXRpb24sIGFjdGlvbnMgZm9yIGJyZWFjaCBvZiB3YXJyYW50eSwgYnJlYWNoIG9mIGNvbnRyYWN0IG9yIHRvcnQgKGluY2x1ZGluZyBuZWdsaWdlbmNlKSBhbmQgdGhhdCBgZW9zaW8ucHJvZHNgLCBub3IgdGhlIGluZGl2aWR1YWwgcGVybWlzc2lvbnMgdGhhdCBvcGVyYXRlIGl0LCBzaGFsbCBub3QgYmUgbGlhYmxlIGZvciBhbnkgaW5kaXJlY3QsIGluY2lkZW50YWwsIHNwZWNpYWwsIGV4ZW1wbGFyeSBvciBjb25zZXF1ZW50aWFsIGRhbWFnZXMsIGluY2x1ZGluZyBmb3IgbG9zcyBvZiBwcm9maXRzLCBnb29kd2lsbCBvciBkYXRhLgoKIyBFT1Mg7IKs7Jqp7J6QIOuPmeydmOyEnAoKIyMg7KCV7J2YCgpFT1Mg7IKs7Jqp7J6QIOuPmeydmOyEnOydmCDrqqjrk6Ag64yA66y47J6QLCDquLDsmrjsnoQg6ry0LCDrmJDripQg7J2465287J24IOy9lOuTnCDsmqnslrTripQg7KCV7J2Y7JeQ7ISc7JmAIOuPmeydvO2VnCDtmqjqs7zsmYAg7J2Y66+46rCAIOu2gOyXrOuQqeuLiOuLpC4KCi0gICBFT1Mg7IKs7Jqp7J6QIOuPmeydmOyEnDog67O4IOusuOyEnCAoRVVBKQotICAg7LK07J24IElEOiBjaGFpbl9pZOKAii0tLeKAimFjYTM3NmYyMDZiOGZjMjVhNmVkNDRkYmRjNjY1NDdjMzZjNmMzM2UzYTExOWZmYmVhZWY5NDM2NDJmMGU5MDYKLSAgIOyCrOyaqeyekDogRU9TIOqzhOygleydhCDsp4HsoJEg65iQ64qUIOqwhOygkeyggeycvOuhnCDshozsnKDtlZjqsbDrgpggRU9TIOqzhOygleyXkCDsl7DqsrDrkJwgRU9TIOq4sOuwmCDsho3shLHsnYQg7Jyg7KeA7ZWY6rGw64KYIOq0gOumrO2VmOuKlCDsgqzrnowsIOyhsOyngSwg65iQ64qUIOyhsOyngeydmCDrqqjrk6Ag7IKs656MLgotICAg7IaM7Jyg6raMOiDtlZjrgpgg7J207IOB7J2YIOycoO2aqO2VnCDsgqzsmqnqtoztlZwg7ZmV7J247J2EIO2Gte2VtCBFT1Mg6rOE7KCV7JeQIOyngeygkSDrmJDripQg6rCE7KCR7KCB7Jy866GcIOygkeq3vO2VqeuLiOuLpC4g7IaM7Jyg6raM7J2AIOuLpOykkSDshJzrqoXqtoztlZzsnYQg7IKs7Jqp7ZWY7JesIOyCrOyaqeyekOqwhOyXkCDrtoDrtoTsoIHsnLzroZwg6rO17JygIOuQoCDsiJgg7J6I7Iq164uI64ukLgotICAg67iU66GdIO2UhOuhnOuTgOyEnDogcmVncHJvZHVjZXLrpbwg7Iuk7ZaJ7ZWY6rOgIGVvc2lvLnZwYXnroZzrtoDthLAg67O07IOB7J2EIOuwm+uKlCDsgqzsmqnsnpAuCi0gICBlb3Npby5wcm9kczogMTUvMjEg67iU66GdIO2UhOuhnOuTgOyEnOuTpOydtCDrj5nsnZgg7ZWgIOuVjCBlb3NpbyDqs4TsoJXsnZgg6raM7ZWc7J2EIOqwgOyniCDsiJgg7J6I64qUIOuPmeyggSDqtoztlZwg6rWs7KGw66W8IOqwgOynhCBFT1Mg6rOE7KCVLgotICAg64Sk7Yq47JuM7YGsIOyekOq4iDog64uk7J2MIOqzhOygleyXkCDtj6ztlagg65CcIO2GoO2BsDogZW9zaW8ubmFtZXMsIGVvc2lvLnJhbWZlZSwgZW9zaW8uc2F2aW5nLgotICAg6rSA66asIOusuOyEnDogcmVncHJvZHVjZXLripQg6rSA66asIOusuOyEnOuhnCDqsITso7zrkKnri4jri6QuCi0gICDsmKjssrTsnbg6IEVPUyDruJTroZ3ssrTsnbggY2hhaW5faWTsl5Ag67mE6rCA7Jet7KCB7J2066mwIOy2lOqwgCDtlaAg7IiYIOyeiOuKlCDruJTroZ0g64K07JeQIOychOy5mO2VnCDrqqjrk6Ag6rGw656YLCDsiqTrp4jtirgg6rOE7JW9IOuYkOuKlCDrpqzsubTrpbTrlJTslYgg6rOE7JW9LgotICAgRU9TIOq4sOuwmCDsho3shLE6IEVPUyDruJTroZ3ssrTsnbjsnYQg7KeB7KCRIOyhsOyekSwg67OA6rK9LCDsoITshqEsIOyYge2WpSDrmJDripQg64us66asIOyggeyaqe2VmOq4sCDsnITtlbQg7Jyg7Zqo7ZWcIOyCrOyaqSDqtoztlZzsnbQg7ZWE7JqU7ZWcIOuqqOuToCDqsoMKLSAgIOy9nDogRU9TIOu4lOuhneyytOyduCBjaGFpbl9pZOyXkCDsnpHsl4XsnYQg7Iug7LKt7ZWY64qUIOqygy4KLSAgIO2XiOqwgCDrsI8g6raM7ZWcOiAn7ZeI6rCAJ+uKlCDtlbTri7kg6raM7ZWc7J2EIOuMgOyLoO2VmOyXrCDsoITshqHrkJjripQg7Yq4656c7J6t7IWY7J2YIOyalOq1rOyCrO2VreydhCDsoJXsnZjtlZjripQg642wIOyCrOyaqeuQqeuLiOuLpC4gJ+q2jO2VnCfsnYAg7Yq57KCVIOqzhOyVvSDsobDsuZjsl5Ag64yA7ZWcIOq2jO2VnOydhCDrtoDsl6ztlanri4jri6QuCi0gICDrpqzsubTrpbTrlJTslYgg6rOE7JW9OiDtlanrspXsoIEg6rOE7JW97J2YIOygleydmCDsmpTshozrpbwg7IaM7ZSE7Yq47Juo7Ja066GcIO2RnO2YhO2VmOqzoCDsi6TtlontlaAg7IiYIOyeiOuKlCDtmJXsi53snLzroZwg67Cw7LmY7ZWY64qUIOqzhOyVvS4KCiMjIOygnCAx7KGw4oCKLS0t4oCK7JyE7ZeY7JeQIOuMgO2VnCDsgqzsmqnsnpDrk6TsnZgg7J247KeACgrsgqzsmqnsnpDqsIAgY2hhaW5faWTsl5DshJwgRU9TIOqzhOygleyXkCDrjIDtlZwg7KCR6re8IOq2jO2VnOydhCDsnoPqs6AsIOuLpOuluCDrsKnrspXsnLzroZwgRU9TIOqzhOygleyXkCDrjIDtlZwg7KCR6re87J2EIOuztO2YuO2VmOq4sCDsnITtlbQg7KCB7KCI7ZWcIOyhsOy5mOulvCDst6jtlZjsp4Ag7JWK64qUIOqyveyasOyXkOuKlCBFT1Mg6rOE7KCV7JeQIOygkeq3vO2VoCDsiJgg7JeG6rKMIOuQnOuLpOuKlCDqsoPsnYQg7J247KCV7ZWY6rOgIOuPmeydmO2VqeuLiOuLpC4g7IKs7Jqp7J6Q64qUIOyVlO2YuO2ZlCDthqDtgbDqs7wg67iU66Gd7LK07J24IOq4sOuwmCDshoztlITtirjsm6jslrTsnZgg7JyE7ZeYLCDsgqzsmqnrspUsIOq3uOumrOqzoCDrs7XsnqHshLHsl5Ag64yA7ZW0IOy2qeu2hO2eiCDsnbTtlbTtlZjqs6Ag7J6I7J2M7J2EIOyduOygle2VqeuLiOuLpC4g7IKs7Jqp7J6Q64qUIEVPUyDruJTroZ3ssrTsnbjsnZgg7IKs7Jqp7JeQIOuMgO2VnCDsoITsoIHsnbgg7LGF7J6E7J2EIOynhOuLpOuKlCDqsoPsl5Ag7J247KCV7ZWY6rOgIOuPmeydmO2VqeuLiOuLpC4KCiMjIOygnCAy7KGw4oCKLS0t4oCK7Yq567OE7ZWcIOyCrOyaqeyekCDsnKDtmJUKCnJlZ3Byb2R1Y2Vy66W8IOyLpO2Wie2VmOuKlCDsgqzsmqnsnpDripQgcmVncHJvZHVjZXIg66as7Lm066W065SU7JWIIOqzhOyVveyXkCDrj5nsnZjtlZjqs6AsIOydtOyXkCDqtazsho3rkKnri4jri6QuCgojIyDsoJwgM+yhsOKAii0tLeKAikVVQeydmCDrj5nsnZgKCkVPUyDsgqzsmqnsnpAg64+Z7J2Y7ISc64qUIO2YhOyerCDsi5ztlonspJHsnbggRU9TIOuplOyduOuEtyDqsbDrsoTrhIzsiqTsl5Ag64yA7ZWcIOyEpOuqheycvOuhnCDsgqzsmqnrkKnri4jri6QuIOy9lOuTnOyXkCDsnZjtlbQg7Iuc7ZaJ65CY64qUIOydtOufrO2VnCDquLDriqXsnYAgRU9TIOuplOyduOuEtyDsnpDssrTsnZgg7LK06rOE7KCB7J206rOgIOqzoOycoO2VnCDquLDriqXsnbTrr4DroZwg7IKs7Jqp7J6Q7J2YIOuPmeydmOulvCDtlYTsmpTroZwg7ZWY7KeAIOyViuyKteuLiOuLpC4KCiMjIOygnCA07KGw4oCKLS0t4oCK6rSA66asIOusuOyEnAoKRVVB7JmAIOq0gOumrCDrrLjshJzripQgZW9zaW8ucHJvZHPrpbwg7Ya17ZW0IOyImOygleydtCDqsIDriqXtlanri4jri6QuIO2KueyglSDrs4Dqsr3sgqztla3snYQg7IKs7KCE7JeQIOyEpOuqhe2VmOuKlCBlb3Npby5mb3J1bSDtiKztkZwg6rOE7JW97J2EIO2Gte2VtCBlb3Npby5wcm9kc+qwgCDshLHrqoXshJzrpbwg7J6R7ISx7ZWY6rOgIOuwnOq4ie2VoCDqsoPsnYQg6raM6rOg7ZWp64uI64ukLgoKIyMg7KCcIDXsobDigIotLS3igIrqsIDsuZjsnZgg6riw67O4IOuLqOychAoKRU9TIGNoYWluX2lk7J2YIOq4sOuzuCDri6jsnITripQgZW9zaW8udG9rZW4g7Iqk66eI7Yq4IOqzhOyVveyXkCDsnZjtlbQg7KCV7J2Y65CY6rOgIOyekeyEseuQnCBFT1Mg7Yag7YGw7J6F64uI64ukLgoKIyMg7KCcIDbsobDigIotLS3igIpFT1Mg67iU66Gd7LK07J24IOycoOyngAoKZW9zaW8ucHJvZHPripQg66qo65OgIOq4sOuKpSwg7LWc7KCB7ZmULCDqt7jrpqzqs6Ag7JeF6re466CI7J2065Oc7J2YIO2YhOyerOyZgCDrr7jrnpjsnZgg66qo65OgIOyImOygleyCrO2VreydhCDqtaztmITtlZjripQg6rKD7J2EIO2PrO2VqO2VmOuQmCwg7J207JeQIOq1re2VnOuQmOyngCDslYrripQg7Zmc7ISx7ZmU65CcIOu4lOuhneyytOyduCDsvZTrk5zrsqDsnbTsiqTrpbwg7Jyg7KeA7ZWp64uI64ukCgojIyDsoJwgN+yhsOKAii0tLeKAiuuEpO2KuOybjO2BrCDsnpDquIgKCuuEpO2KuOybjO2BrCDsnpDquIgg6rOE7KCV7JeQIO2PrO2VqOuQnCDthqDtgbDsnZgg7IOB7YOc66W8IOuzgOqyve2VmOqxsOuCmCwg64Sk7Yq47JuM7YGsIOyekOq4iOydmCDrsLDrtoQsIOydtO2WiSwg65iQ64qUIOuwsO2PrOulvCDsp4Ev6rCE7KCR7KCB7Jy866GcIOq0gOumrO2VmOuKlCDquLDsobQg7L2U65Oc66W8IOuzgOqyve2VmOuKlCDqsr3smrDsl5DripQgZW9zaW8ucHJvZHPrpbwgZW9zaW8uZm9ydW0g7LSdIO2IrO2RnCDsi5zsiqTthZwg6rOE7JW97JeQIOy2lOqwgO2VmOyXrCDsgqzsoITsl5Ag7Lap67aE7ZWcIOyEpOuqheydtCDsnbTro6jslrTsoLjslbwg7ZWp64uI64ukLgoKIyMg7KCcIDjsobDigIotLS3igIrqs4TsoJUg7IOd7ISx7J2YIOyekOycoAoK7ZiE7J6sLCDrmJDripQg66+4656Y7J2YIOyCrOyaqeyekOuKlCDri6Trpbgg7IKs7Jqp7J6Q7J2YIO2XiOqwgCDsl4bsnbQgRU9TIOqzhOygleydhCDrp4zrk6Qg7IiYIOyeiOyKteuLiOuLpC4gZW9zaW8ucHJvZHPripQgRU9TIOqzhOygleyXkCDsnZjtlbQg6rO17Jyg65CcIOycoO2aqO2VnCDtl4jqsIAg7JeG7J2064qUIEVPUyDsgqzsmqnsnpAg6rOE7KCV7JeQIOyYge2WpeydhCDspIQg7IiYIOyXhuyKteuLiOuLpC4gZW9zaW8ucHJvZHPripQg6raM7ZWc7J20IOqzteycoOuQmOuKlCBFT1Mg6rOE7KCV6rO8IOq0gOugqO2VmOyXrCDri6Trpbgg7IKs7Jqp7J6Q6rCAIOyalOyyre2VnCDrqqjrk6Ag7J6R7JeF7JeQIOuMgO2VtCDsmpTquIjsnYQg67aA6rO87ZWgIOyImCDsnojsirXri4jri6QuCgojIyDsoJwgOeyhsOKAii0tLeKAiuyLoO2DgSDrtojqsIAKCuyCrOyaqeyekOuKlCBFT1Mg7Yag7YGw7J2YIOqwgOy5mOulvCDrkrfrsJvsuajtlaAg7IiYIOyeiOuKlCDsi6Dtg4Eg66qp7KCB7J2EIOqwgOyguOyEnOuKlCDslYjrkKnri4jri6QuIOyCrOyaqeyekOuKlCBFT1Mg7IKs7Jqp7J6QIOuYkOuKlCBFT1Mg67iU66Gd7LK07J24IGNoYWluX2lk66W8IOuMgO2RnO2VmOyXrCDriITqtazsl5Dqsozrj4Qg7J6Q7IKw7J2EIOuztOycoO2VmOqxsOuCmCwg64yA7Jes7ZWY6rGw64KYLCDsnpDsgrDsl5Ag64yA7ZW0IOyWmOq4sO2VmOqxsOuCmCwg6rOE7JW97J2EIOunuuydhCDqtoztlZzsnYQg67aA7Jes7ZWgIOyImCDsl4bsirXri4jri6QuIEVPUyDruJTroZ3ssrTsnbjsl5DripQg7IaM7Jyg7J6QLCDqtIDrpqzsnpAsIOq3uOumrOqzoCDsiJjtg4HsnpDqsIAg7JeG7Ja07JW8IO2VqeuLiOuLpC4KCiMjIOygnCAxMOyhsOKAii0tLeKAiuyCrOyaqeyekCDrs7TslYgKCuu5hOqzteqwnCDtgqTsnZgg67O06rSA7J2EIO2PrO2VqO2VmOuQmCwg7J207JeQIOq1re2VnOuQmOyngCDslYrripQg6rCc7J24IOqzhOyijCDrs7TslYjqs7wg6rSA66Co65CcIOuqqOuToCDtla3rqqnrk6Qg65iQ7ZWcIOyghOyggeycvOuhnCDsgqzsmqnsnpDqsIAg7JWI7KCE7ZWY6rKMIOuztOq0gO2VtOyVvCDtlanri4jri6QuCgojIyDsoJwgMTHsobDigIotLS3igIplb3Npby5wcm9kcyDsnKDtlZzssYXsnoQKCuyCrOyaqeyekOuKlCDrspXrpaDsnbQg7ZeI7Jqp7ZWY64qUIO2VnOuPhCDrgrTsl5DshJwgRU9TIO2GoO2BsOydmCDsnITtl5gsIOyCrOyaqSwg65iQ64qUIOyCrOyaqSDrtojqsIDroZwg7J247ZW0IOuwnOyDne2VmOuKlCDrqqjrk6Ag7IaQ7ZW07JeQIOuMgO2VtCDssYXsnoTsnZgg66m07LGFIOyhsO2VreydtCDsoIHsmqnrkJzri6TripQg6rKD7J2EIOyduOygle2VmOqzoCwg64+Z7J2Y7ZWp64uI64ukLiDqs4Tslb0g7JyE67CYLCDrtojrspUg7ZaJ7JyELCDqt7jrpqzqs6Ag7JyE67CYIO2WieychCAo6rSA66asIO2DnOunjCDtj6ztlagp7JmAIGVvc2lvLnByb2RzIOuYkOuKlCDsnbTrpbwg7Jq07JiB7ZWY64qUIOqwnOuzhCDsgqzsmqkg6raM7ZWc7J2EIO2PrO2VqO2VmOuQmCwg7J207JeQIOq1re2VnO2VmOyngCDslYrqs6Ag66qo65OgIOq0gO2VoCDsp4Dsl63sl5DshJzsnZgg66qo65OgIOyiheulmOydmCDsgqzsnKDroZwg7J247ZWcIEVPUyDruJTroZ3ssrTsnbggY2hhaW5faWQg7J207J21LCDsmIHsl4XqtowsIOuYkOuKlCDrjbDsnbTthLDsnZgg7IaQ7Iuk7J2EIO2PrO2VqO2VmOyXrCDqsITsoJHsoIEsIOyasOuwnOyggSwg7Yq57IiY7ZWcLCDrjIDtkZzsoIEsIOq3uOumrOqzoCDtjIzsg53soIHsnbgg7IaQ7ZW07JeQIOuMgO2VnCDssYXsnoTsnYQg7KeA7KeAIOyViuyKteuLiOuLpC4KCiMgRU9T55So5oi35Y2P6K6uCgojIyAqKuWumuS5iSoqCgpFT1PnlKjmiLfljY/orq7kuK3nmoTmiYDmnInlpKflhpnvvIzmlpzkvZPmiJblhoXogZTku6PnoIHmnK/or63lsIblhbfmnInkuI7ku6XkuIvlrprkuYnnm7jlkIznmoTmlYjmnpzlkozlkKvkuYnjgIIKCi0gRU9T55So5oi35Y2P6K6u77ya5Y2z5pys5paH5qGj77yIRVVB77yJCgotIOmTvuS4iklEOiBjaGFpbl9pZCAtIGFjYTM3NmYyMDZiOGZjMjVhNmVkNDRkYmRjNjY1NDdjMzZjNmMzM2UzYTExOWZmYmVhZWY5NDM2NDJmMGU5MDYKCi0g55So5oi377ya5Lu75oSP5ruh6Laz5LiL5YiX6KaB5rGC55qE5Liq5Lq65oiW57uE57uH77ya55u05o6l5oiW6ICF6Ze05o6l5oul5pyJRU9T6LSm5oi35oiW5LiORU9T6LSm5oi35YWz6IGU55qE5Z+65LqORU9T5Y+R6KGM55qE6LSi5Lqn44CCCgotIOaJgOacieadg++8muebtOaOpeaIluiAhemXtOaOpemAmui/h+S4gOS4quaIluWkmuS4quacieaViOeahOadg+mZkOajgOafpeiuv+mXruS4gOS4qkVPU+i0puaIt+OAguaJgOacieadg+WPr+S7pemAmui/h+Wkmuetvuadg+mZkOiuuOWPr+WcqOeUqOaIt+mXtOWFseS6q+OAggoKLSDmiafooYzkuoZyZWdwcm9kdWNl77yM5bm25LiU5LuOZW9zaW8udnBheemihuWPluaUtuWFpeeahOeUqOaIt+OAggoKLSBlb3Npby5wcm9kczrlhbfmnInliqjmgIHmnYPpmZDnu5PmnoTnmoRFT1PluJDmiLfvvIzlvZMxNS8yMSBCbG9jayBQcm9kdWNlcnPlkIzmhI/ml7bvvIzor6XluJDmiLflj6/ku6Xmib/mi4Vlb3Npb+W4kOaIt+eahOadg+mZkOOAggoKLSDnvZHnu5zotYTkuqfvvJrljIXlkKvlnKjku6XkuIvotKbmiLfkuK3nmoTku6PluIHvvJplb3Npby5uYW1lc+OAgWVvc2lvLnJhbWZlZeOAgSAgZW9zaW8uc2F2aW5n44CCCgotIOayu+eQhuaWh+aho++8mnJlZ3Byb2R1Y2Vy5piv5rK755CG5paH5qGj44CCCgotIOS7u+S9leS6pOaYk+OAgeaZuuiDveWQiOe6puaIluiAheadjuWYieWbvuWQiOe6pu+8jOWug+S7rOW3sue7j+S9jeS6juS4gOS4quWMuuWdl+S4re+8jOW5tuS4lOi/meS4quWMuuWdl+aYr+S4jeWPr+mAhui9rOeahOOAgeW3sumZhOWKoOWIsOWQjeS4umNoYWluX2lk55qERU9T5Yy65Z2X6ZO+5Lit44CCCgotIOWfuuS6jkVPU+i1hOS6p++8muS7u+S9lemcgOimgeacieaViOiuuOWPr+adpeaTjeS9nOOAgeaUueWPmOOAgei9rOenu+OAgeW9seWTjeaIluiAhei/m+ihjOWFtuS7luaTjeS9nOeahOS4nOilv+OAggoKLSDmiafooYzvvJrlnKjlkI3kuLpjaGFpbl9pZOeahEVPU+WMuuWdl+mTvuS4reaPkOS6pOS4gOS4quihjOWKqOOAggoKLSDmjojmnYPlkozmnYPpmZDvvJrmnYPpmZDvvIhQZXJtaXNzaW9uc++8ieaYr+eUqOadpeWumuS5ieS7o+ihqOivpeadg+mZkOWPkemAgeeahOS6pOaYk+eahOimgeaxgueahOS7u+aEj+WQjeWtl+OAguWPr+S7pee7meeJueWumueahOWQiOe6puaTjeS9nOeahOaOiOadg++8iEF1dGhvcml6YXRpb25z77yJ5YiG6YWN5p2D6ZmQ77yIUGVybWlzc2lvbnPvvInjgIIKCi0g5p2O5ZiJ5Zu+5ZCI57qm77ya5bCG5rOV5b6L5Y2P6K6u5Lit55qE5a6a5LmJ6KaB57Sg5Lul6IO95Zyo6L2v5Lu25Lit6KGo6L6+5ZKM5omn6KGM55qE5qC85byP6KGo6L6+55qE5ZCI57qm44CCCgojIyAqKuadoeasvuS4gCoqKirnlKgqKioq5oi36aOO6Zmp56Gu6K6kKioKCuWmguaenOeUqOaIt+S4ouWksei0puaIt+iuv+mXruadg+mZkOaIluiAheayoeaciemHh+WPluWQiOmAgueahOaWueW8j+S/neaKpOi0puaIt+iuv+mXruadg+mZkO+8jOeUqOaIt+W6lOefpeaCieW5tuWQjOaEj++8jEVPU+i0puaIt+WwhuaXoOazleiuv+mXruOAgueUqOaIt+W6lOehruiupOeUqOaIt+WvueWKoOWvhuS7o+W4geWSjOWMuuWdl+mTvui9r+S7tueahOmjjumZqeOAgeeUqOazleWSjOWkjeadguaAp+acieWFheWIhuS6huino+OAgueUqOaIt+aJv+iupOW5tuWQjOaEj+eUqOaIt+iHquihjOaJv+aLheS9v+eUqEVPU+WMuuWdl+mTvueahOmjjumZqeOAggoKIyMgKirmnaHmrL7kuowqKioq54m55q6K55SoKioqKuaIt+exu+WeiyoqCgrmiafooYxyZWdwcm9kdWNl77yM5ZCM5oSP5bm25LiU5Y+XcmVncHJvZHVjZXLmnY7lmInlm77lkIjnuqbnuqbmnZ/nmoTnlKjmiLfjgIIKCiMjICoq5p2h5qy+5LiJKioqKuWQjOaEjyoqKipFT1MqKioq55SoKioqKuaIt+WNj+iurioqCgpFT1PnlKjmiLfljY/orq7nmoTlrp7otKjmmK/lr7nlvZPliY1FT1PkuLvnvZHmsrvnkIblip/og73nmoTmj4/ov7DjgILnlLHku6PnoIHlvLrliLbmiafooYznmoTlip/og73kuI3pnIDopoHnlKjmiLfnmoTlkIzmhI/vvIzlm6DkuLrov5nkupvlip/og73mmK9FT1PkuLvnvZHns7vnu5/oh6rluKbnmoTjgIIKCiMjICoq5p2h5qy+5ZubKiogLSAqKuayu+eQhuaWh+ahoyoqCgplb3Npby5wcm9kc+WPr+S7peWvuUVPU+eUqOaIt+WNj+iuruWSjOayu+eQhuaWh+aho+i/m+ihjOS7u+S9leS/ruaUueOAguS4peato+aPkOmGku+8jOaPkOWJjeeUqGVvc2lvLmZvcnVt5YWs5oqV5ZCI57qm77yM6YCa6L+HZW9zaW8ucHJvZHPnvJblhpnjgIHlj5HluIPkuIDkuKrlo7DmmI7mnaXmj4/ov7DpgqPkuKrkv67mlLnjgIIKCiMjICoq5p2h5qy+5LqUKioqKuWOn+eUn+S7tyoqKirlgLzljZXkvY0qKgoKRU9T5YWs6ZO+5LiK55qE5Y6f55Sf5Lu35YC85Y2V5L2N5bqU5Li6ZW9zaW8udG9rZW7mmbrog73lkIjnuqblrprkuYnlkozliJvlu7rnmoRFT1PpgJror4HjgIIKCiMjICoq5p2h5qy+5YWtKioqKue7tOaKpCoqKipFT1MqKioq5Yy6KioqKuWdl+mTvioqCgrml6DorrrnjrDlnKjmiJblsIbmnaXlsIbmnaXvvIxlb3Npby5wcm9kc+Wwhue7tOaKpOa0u+i3g+eahOWMuuWdl+mTvuS7o+eggeW6k++8jOWMheaLrOS9huS4jemZkOS6juaJgOacieWKn+iDveOAgeS8mOWMluOAgeWNh+e6p+eahOaJgOacieS/ruaUueOAgeWunueOsOOAggoKIyMg5p2h5qy+5LiDIC0gKioqKuWumioqKirkuYkqKioqRU9TKioqKue9kee7nOi1hOS6pwoK5pu05pS5572R57uc6LWE5Lqn6LSm5oi35Lit55qE5Lu75L2V5Luj5biB55qE54q25oCB77yM5pu05pS55Lu75L2V546w5a2Y55qE55u05o6l5oiW6Ze05o6l566h55CG5Lu75L2V572R57uc6LWE5Lqn55qE5YiG6YWN44CB5a6e546w5oiW5YiG5Y+R55qE5Luj56CB77yM6ZyA6KaB5LqL5YWI55SoZW9zaW8ucHJvZHPlnKhlb3Npby5mb3J1beWFrOaKleWQiOe6puS4iue8luWGmeWSjOWPkeW4g+aViOaenOaPj+i/sOeahOWjsOaYjuOAggoKIyMgKirmnaHmrL7lhast5Yib5bu66LSm5oi36Ieq55SxKioKCuS7u+S9leeOsOWcqOaIluWwhuadpeeahOeUqOaIt+mDveWPr+S7peWcqOacque7j+S7u+S9leWFtuS7lueUqOaIt+iuuOWPr+eahOaDheWGteS4i+WIm+W7ukVPU+W4kOaIt+OAgiAg5aaC5L2V5rKh5pyJ5pS25YiwRU9T5biQ5oi355qE5pyJ5pWI6K645Y+v77yIcGVybWlzc2lvbu+8ie+8jGVvc2lvLnByb2Rz5rC46L+c5LiN5Lya5b2x5ZONRU9T55So5oi35biQ5oi344CCICDlr7nkuo7lhbHkuqvmnYPpmZDnmoRFT1PluJDmiLfnmoTlhbbku5bnlKjmiLfor7fmsYLnmoTku7vkvZXmk43kvZzvvIxlb3Npby5wcm9kc+WPr+iDveS8muaUtuWPlui0ueeUqOOAggoKIyMgKirmnaHmrL7kuZ3msqHmnInlj5fmiZjkuroqKgoK5rKh5pyJ55So5oi35om/5ouF5L+h5omY6LSj5Lu75p2l57u05oyBRU9T5Luj5biB55qE5Lu35YC844CC5rKh5pyJ55So5oi35Y+v5Lul5Luj6KGoRU9T55So5oi35oiW6ICF5Luj6KGo5ZCN5Li6Y2hhaW5fSUTnmoRFT1PljLrlnZfpk77mjojmnYPku7vkvZXkurrlhbHlkIzmjIHmnInotYTkuqfjgIHlgJ/mrL7jgIHlj5HoqIDmiJblrprlkIjlkIzjgILmraTljLrlnZfpk77kuI3lrZjlnKjmi6XmnInogIXjgIHnrqHnkIbogIXmiJbogIXlj5fmiZjkurrjgIIKCiMjICoq5p2h5qy+5Y2B5Liq5Lq65a6J5YWoKioKCuaJgOacieacieWFs+S4quS6uui0puaIt+WuieWFqOeahOS6i+mhue+8jOWMheaLrOS9huS4jemZkOS6juengemSpeeahOWuieWFqOS/neWtmO+8jOmDveeUseeUqOaIt+iHquW3sei0n+i0o+OAggoKIyMgKirmnaHmrL7ljYHkuIAgZW9zaW8ucHJvZHPnmoTmnInpmZDotKPku7sqKgoK55So5oi35bqU55+l5oKJ5ZKM5ZCM5oSP77yM5Zyo5Lu75L2V6YCC55So5rOV5b6L5YWB6K6455qE5pyA5aSn6IyD5Zu05YaF77yM5pys5YWN6LSj5aOw5piO6YCC55So5LqO5LiORU9T5Luj5biB6aOO6Zmp77yM5L2/55So5oiW5peg5rOV5L2/55SoRU9T5Luj5biB5pyJ5YWz5oiW5a+86Ie055qE5Lu75L2V5oiW5omA5pyJ5o2f5a6z5oiW5Lyk5a6z77yM5Lmf6YCC55So5LqO5Lu75L2V5Y+45rOV566h6L6W5Yy65YaF55qE5Lu75L2V5Lu75L2V6KGM5Li65LiL55qERU9T5Yy65Z2X6ZO+Y2hhaW5faWTvvIzljIXmi6zkvYbkuI3pmZDkuo7ov53lj43mi4Xkv53jgIHov53lj43lkIjlkIzmiJbkvrXmnYPooYzkuLrvvIjljIXmi6znlo/lv73vvInjgIJlb3Npby5wcm9kc+S7peWPiuaTjeS9nOWug+eahOS4quS6uuadg+mZkOWvueS6juS7u+S9lemXtOaOpeeahO+8jOWBtueEtueahO+8jOeJueauiueahO+8jOekuuS+i+aAp+eahOaIluWQjuaenOaAp+eahOaNn+Wus++8jOWMheaLrOWIqea2puaNn+Wkse+8jOWVhuiqieaIluaVsOaNru+8jOS4jeaJv+aLheS7u+S9lei0o+S7u+OAghZCbG9ja1Byb2R1Y2VyQWdyZWVtZW50xmwjIyMgMS4gVGhlIGludGVudCBvZiByZWdwcm9kdWNlcgoKVGhlIGludGVudCBvZiB0aGUgYHJlZ3Byb2R1Y2VyYCBhY3Rpb24gaXMgdG8gcmVnaXN0ZXIgYSBibG9jayBwcm9kdWNlciBjYW5kaWRhY3kuIFRoaXMgY29udHJhY3QgaXMgY29uc2lkZXJlZCBhIGdvdmVybmluZyBkb2N1bWVudCBhcyBkZWZpbmVkIGJ5IHRoZSBFT1MgVXNlciBBZ3JlZW1lbnQgKEVVQSkuCgpyZWdwcm9kdWNlcuydmCDrqqnsoIEKCmByZWdwcm9kdWNlcmAg7J6R7JeF7J2YIOuqqeyggeydgCDruJTroZ3sg53sgrDsnpAg7J6F7ZuE67O0IOuTseuhneydhCDtlZjripQg6rKD7J6F64uI64ukLiDsnbQg6rOE7JW97J2AIEVPUyDsgqzsmqnsnpAg6rOE7JW97IScIChFVUEp7JeQIOygleydmOuQnCDrsJTsmYAg6rCZ7J20IOq0gOumrCDrrLjshJzroZwg6rCE7KO865Cp64uI64ukLgoKcmVncHJvZHVjZXIg55qE55uu55qECgpgcmVncHJvZHVjZXJg5pON5L2c55qE55uu55qE5piv5rOo5YaM5oiQ5Li65Ye65Z2X6IqC54K55YCZ6YCJ6ICF44CC5qC55o2uIEVPUyDnlKjmiLfljY/orq4oRVVBKeeahOWumuS5ie+8jOacrOWQiOe6puWxnuS6juayu+eQhuaWh+acrChnb3Zlcm5pbmcgZG9jdW1lbnQpCgojIyMgMi4gTm9taW5hdGlvbgoKSSwge3sgcHJvZHVjZXIgfX0sIGhlcmVieSBub21pbmF0ZSBteXNlbGYgZm9yIGNvbnNpZGVyYXRpb24gYXMgYSBibG9jayBwcm9kdWNlciBjYW5kaWRhdGUuIFRoaXMgbm9taW5hdGlvbiBpbmNsdWRlcyBhZ3JlZW1lbnQgdG8gdGhlIHRlcm1zIG9mIHRoaXMgY29udHJhY3QgYnkgbXkgYmxvY2sgcHJvZHVjZXIgY2FuZGlkYXRlIGVudGl0eSwgaW5jbHVkaW5nIGFsbCBvZiBpdHMgc2hhcmVob2xkZXJzLCBvd25lcnMsIGVtcGxveWVlcywgc3RhZmYsIG1lbWJlcnMsIGFuZCBhbnkgaW5kaXZpZHVhbCB3b3JraW5nIGluIG9mZmljaWFsLCBkaXJlY3QsIG9yIGFmZmlsaWF0ZWQgY2FwYWNpdHkgZm9yIG15IEJsb2NrIFByb2R1Y2VyIGVudGl0eS4KCuyngOuqhQoK64KYLCB7eyBwcm9kdWNlciB9feuKlCDruJTroZ3tlITroZzrk4DshJwg7ZuE67O066GcIOqzoOugpOuQmOuPhOuhnSDsnpDsi6DsnYQg7KeA66qF7ZWp64uI64ukLiDsnbQg7KeA66qF7JeQ64qUIOu4lOuhne2UhOuhnOuTgOyEnO2ajOyCrOydmCDrqqjrk6Ag7KO87KO8LCDshozsnKDsnpAsIOyngeybkCwg66mk67KELCDtmozsm5Ag67CPIOqzteyLneyduOybkCwg7KeB7KCRIOuYkOuKlCDqs4Tsl7Tsgqzsl5DshJwg7J287ZWY64qUIOuqqOuToCDqsJzsnbjsnYQg7Y+s7ZWo7ZWcIOu4lOuhne2UhOuhnOuTgOyEnCDtmozsgqzqsIAg6rOE7JW9IOyhsOqxtOyXkCDrjIDtlbQg64+Z7J2Y7ZWo7J2EIOyduOygle2VqeuLiOuLpC4KCuaPkOWQjQoK5pys5Lq677yMe3sgcHJvZHVjZXIgfX3vvIznibnmraTmj5DlkI3mnKzkurrkuLrlh7rlnZfoioLngrnlgJnpgInkurrjgILmnKzmj5DlkI3ljIXmi6zkuobmnKzlh7rlnZfoioLngrnlgJnpgInkurrlrp7kvZPlr7nmnKzlkIjnuqbkuK3miYDmnInmnaHmrL7nmoTmmI7noa7lkIzmhI/vvIzljIXlkKvlhbbmiYDmnInogIXjgIHpm4flkZjjgIHlkZjlt6XjgIHmiJDlkZjvvIzku6Xlj4rku7vkvZXku6XmraPlvI/mlrnlvI/jgIHnm7TmjqXmiJbpmYTlsZ7mlrnlvI/kuLrmnKzlh7rlnZfoioLngrnlrp7kvZPlt6XkvZznmoTkuKrkurrjgIIKCiMjIyAzLiBSZXNpZ25hdGlvbiBhbmQgUmVtb3ZhbCBmb3IgSW5hYmlsaXR5IHRvIFBlcmZvcm0gT2JsaWdhdGlvbnMuCgpJZiBJLCB7eyBwcm9kdWNlciB9fSwgYW0gdW5hYmxlIHRvIHBlcmZvcm0gYW55IG9mIHRoZSBvYmxpZ2F0aW9ucyBzdGlwdWxhdGVkIGluIHRoaXMgY29udHJhY3QsIEkgd2lsbCByZXNpZ24gbXkgcG9zaXRpb24gYnkgY2FsbGluZyB0aGUgYHVucmVncHJvZGAgYWN0aW9uLgoKSWYgSSwge3sgcHJvZHVjZXIgfX0sIGZhaWwgdG8gcmVzaWduIHdoZW4gdW5hYmxlIHRvIHBlcmZvcm0gc2FpZCBvYmxpZ2F0aW9ucywgSSB1bmRlcnN0YW5kIHRoYXQgcHJvY2VkdXJlcyBlbnVtZXJhdGVkIGluIHRoaXMgY29udHJhY3Qgc2hhbGwgYmUgZW5hY3RlZC4KCuydmOustOydmCDrtojsnbTtlonsl5Ag64yA7ZWcIOyCrOyehCDrsI8g7LKg7ZqMCgp7eyBwcm9kdWNlciB9feqwgCDrs7gg6rOE7JW97ISc7JeQIOuqheyLnOuQnCDsnZjrrLTrpbwg7IiY7ZaJIO2VoCDsiJgg7JeG64qUIOqyveyasCwg7IOd7IKw7J6QIO2CpOulvCBudWxsIOuhnCDtlajsnLzroZzsjagg67O47J247J2YIOyngOychOulvCDsgqzsnoTtlanri4jri6QuCgrrp4zslb0g64K06rCAIHt7cHJvZHVjZXJ9feydmCDsnZjrrLTrpbwg7J207ZaJIO2VoCDsiJgg7JeG7J2EIOuVjCDsgqzsnoTtlZjsp4Ag7JWK64qU64uk66m0LCDrgpjripQg67O4IOqzhOyVveyXkCDsl7TqsbDrkJwg7KCI7LCo6rCAIOynke2WieuQqOydhCDrj5nsnZjtlanri4jri6QuCgrlm6DkuI3og73lsaXooYzkuYnliqHogIzpgIDlh7rmiJbooqvlj5bmtojlh7rlnZfotYTmoLwKCuWmguaenOaIke+8jHt7IHByb2R1Y2VyIH1977yM5LiN6IO95bGl6KGM5pys5ZCI57qm5Lit5omA6KeE5a6a55qE5omA5pyJ5LmJ5Yqh77yM5oiR5bCG5L2/55SoIGB1bnJlZ3Byb2RgIOaTjeS9nOadpeiHquaIkemAgOWHuu+8iHJlc2lnbu+8ieOAggoK5aaC5p6c5oiRIHt7IHByb2R1Y2VyIH19LCDlnKjml6Dms5XlsaXooYzkuIrov7DkuYnliqHml7bmnKrog73pgIDlh7oocmVzaWduKe+8jOaIkeefpeaZk+acrOWQiOe6puWwhuS8muaMieeFp+aJgOacieWIl+S4vueahOeoi+W6j+WvueaIkeWunuihjOWItuijgeaIluWkhOe9mueoi+W6j+OAggoKIyMjIDQuIEVPUyBBY2NvdW50cwoKQmxvY2sgUHJvZHVjZXJzIG1heSBuZXZlciBhZmZlY3QgYW4gYWNjb3VudCBvbiB0aGUgRU9TIGJsb2NrY2hhaW4sIGV4Y2VwdCBmb3IgdGhlIHJlYXNvbnMgc3BlY2lmaWNhbGx5IGNpdGVkIGluIHRoaXMgY29udHJhY3QgdGhhdCBwZXJ0YWluIHRvIEJsb2NrIFByb2R1Y2VyIGFjY291bnRzLiBVc2VyIGFjY291bnRzIGNhbiBvbmx5IGJlIGFmZmVjdGVkIG9uIHRoZSBiYXNpcyBvZiBBcnRpY2xlIFZJSUkgaW4gdGhlIEVPUyBVc2VyIEFncmVlbWVudC4KCkVPUyDqs4TsoJUKCuu4lOuhne2UhOuhnOuTgOyEnOuKlCDrs7gg6rOE7JW97JeQ7IScIO2VtOuLue2VmOuKlCDruJTroZ3tlITroZzrk4DshJzsnZgg6rOE7KCVIOywqOuLqOyXkCDqtIDroKjtlZjsl6wg7Yq567OE7Z6IIOyWuOq4ie2VnCDsnbTsnKDrpbwg7KCc7Jm47ZWY6rOg64qUIEVPUyDruJTroZ3ssrTsnbjsnZgg6rOE7KCV7JeQIOqysOy9lCDsmIHtlqXsnYQg66+47LmY7KeAIOyViuyKteuLiOuLpC4g7IKs7Jqp7J6QIOqzhOygleydgCBFT1Mg7IKs7Jqp7J6QIOqzhOyVveyEnOydmCA47KGw7JeQIOq3vOqxsO2VoCDrlYzrp4wg7JiB7Zal7J2EIOuwm+ydhCDsiJgg7J6I7Iq164uI64ukLgoKRU9TIOi0puWPtwoK5Ye65Z2X6IqC54K55rC46L+c5LiN5Lya5a+5IEVPUyDljLrlnZfpk77kuIrnmoTluJDmiLfpgKDmiJDlvbHlk43vvIzpmaTpnZ7mmK/mnKzlkIjnuqbkuK3nibnliKvmj5DliLDkuI7lh7rlnZfoioLngrnluJDmiLfmnInlhbPnmoTljp/lm6DjgILlj6rmnInln7rkuo4gRU9T55So5oi35Y2P6K6u5Lit55qE56ys5YWr5p2h55qE5oOF5b2i5LiL77yM55So5oi355qE6LSm5Y+35omN5Lya5Y+X5Yiw5b2x5ZONLgoKIyMjIDUuIFByb2R1Y2VyIEtleQoKSSwge3sgcHJvZHVjZXIgfX0sIHdpbGwgc2lnbiBibG9ja3Mgd2l0aCB7eyBwcm9kdWNlcl9rZXkgfX0KCklmIEksIHt7IHByb2R1Y2VyIH19IHN1c3BlY3QgbXkga2V5IGhhcyBiZWVuIGNvbXByb21pc2VkIEkgd2lsbCBhbGVydCB0aGUgb3RoZXIgQmxvY2sgUHJvZHVjZXJzIGltbWVkaWF0ZWx5LgoKSSwge3sgcHJvZHVjZXIgfX0sIGFja25vd2xlZGdlIHRoYXQgYW55IGFuZCBhbGwgYWN0aW9ucyBleGVjdXRlZCB3aXRoIG15IHt7IHByb2R1Y2VyX2tleSB9fSBpcyBteSByZXNwb25zaWJpbGl0eSwgcmVnYXJkbGVzcyBvZiB0aGUgYWNjb3VudCBiZWluZyBjb21wcm9taXNlZC4KCu2UhOuhnOuTgOyEnCDtgqQKCuuCmCwge3sgcHJvZHVjZXIgfX3ripQge3sgcHJvZHVjZXIgXyBrZXkgfX0g66GcIOu4lOuhneyXkCDshJzrqoUg7ZWgIOqyg+yeheuLiOuLpC4K66eM7JW9IOuCtCwge3twcm9kdWNlcn19IOqwgCDrs7jsnbjsnZgg7YKk6rCAIOyGkOyDgeuQmOyXiOuLpOqzoCDsnZjsi6zrkJjrqbQg7KaJ7IucIOuLpOuluCDruJTroZ3tlITroZzrk4DshJzsl5Dqsowg7JWM66Ck7KSEIOqyg+yeheuLiOuLpC4K64KYLCB7e3Byb2R1Y2VyfX3ripQgRU9TIOu4lOuhneyytOyduOyXkOyEnCDrs7jsnbjsnZgg67iU66Gd7ZSE66Gc65OA7IScIOqzhOygleydtCDsi6TtlontlZjripQg66qo65OgIOyekeyXheyXkCDrjIDtlbQsIOqzhOyglSDsnbTsg4Eg7Jyg66y07JmAIOq0gOugqCDsl4bsnbQsIOyxheyehOydtCDsnojsnYzsnYQg7J247KCV7ZWp64uI64ukLgoK5Ye65Z2X6IqC54K55YWs6ZKlCgog5oiRLCB7eyBwcm9kdWNlciB9fSwg5bCG5L2/55SoIHt7IHByb2R1Y2VyX2tleSB9fSDlr7nljLrlnZfnrb7lkI3jgIIK5aaC5p6c5oiRLCB7eyBwcm9kdWNlciB9fSwg5oCA55aR5oiR55qE5a+G6ZKl5bey6KKr5rOE6Zyy77yM5oiR5bCG56uL5Y2z6YCa55+l5YW25LuW6IqC54K544CCCuaIke+8jHt7IHByb2R1Y2VyIH1977yM5om/6K6k5oiR55qE5Ye65Z2X6IqC54K55biQ5oi35ZyoRU9T5Yy65Z2X6ZO+5LiK5omA5omn6KGM55qE5Lu75L2V5pON5L2c6YO95piv5oiR55qE6LSj5Lu777yM5peg6K666K+l5biQ5oi35piv5ZCm6KKr55uX44CCCgojIyMgNi4gQVBJIEVuZHBvaW50cwoKSWYgSSwge3sgcHJvZHVjZXIgfX0sIHF1YWxpZnkgZm9yLCBhbmQgY2hvb3NlIHRvIGNsYWltIHJld2FyZHMgZHVlIHRvIHZvdGVzIHJlY2VpdmVkLCBhbmQvb3IgYmxvY2tzIHByb2R1Y2VkLCBJLCB7eyBwcm9kdWNlciB9fSwgd2lsbCBwcm92aWRlIGZ1bmN0aW9uaW5nIGFuZCBxdWVyeWFibGUgcHVibGljIFAyUCBhbmQgQVBJIGVuZHBvaW50cyB0byBtYWludGFpbiBzeW5jaHJvbml6YXRpb24gd2l0aCB0aGUgYmxvY2tjaGFpbiBhbmQgc3VibWl0IHRyYW5zYWN0aW9ucyB0byBiZSBpbmNsdWRlZC4gQVBJIGVuZHBvaW50cyBtdXN0IGJlIHVwZGF0ZWQgdG8gYSByZWNlbnQgZnVuY3Rpb25hbCB2ZXJzaW9uIHRoYXQgZG9lcyBub3QgaGF2ZSBrbm93biBzZWN1cml0eSB2dWxuZXJhYmlsaXRpZXMuCgpJLCB7eyBwcm9kdWNlciB9fSwgaGVyZWJ5IGFja25vd2xlZGdlIHRoYXQgaWYgSSBhbSB1bmFibGUgdG8gZG8gc28gd2l0aGluIDMwIG1pbnV0ZXMgb2YgYmVpbmcgYWxlcnRlZCBieSBhbm90aGVyIGJsb2NrIHByb2R1Y2VyIGNhbmRpZGF0ZSwgSSBjYW4gYmUgcmVtb3ZlZCBieSB1c2Ugb2YgdGhlIGBybXZwcm9kdWNlcmAgYWN0aW9uLgoKQVBJIOyXlOuTnO2PrOyduO2KuAoK66eM7JW9IOuCtCwge3sgcHJvZHVjZXIgfX0g6rCAIO2IrO2RnOulvCDrsJvslYQg67iU66GdIOuztOyDgeydhCDssq3qtaztlaAg7IiYIOyeiOuKlCDsnpDqsqnsnYQg7Ja77Jy866m0LCDrgpgge3sgcHJvZHVjZXIgfX3ripQg7J6R64+ZIOuwjyDsv7zrpqwg6rCA64ql7ZWcIOqzteqwnCBQMlAg67CPIEFQSSDsl5Trk5ztj6zsnbjtirjrpbwg67iU66Gd7LK07J246rO87J2YIOuPmeq4sO2ZlCDrsI8g7Yq4656c7J6t7IWY7J2EIOygnOy2nO2VoCDsiJgg7J6I6rKMIOycoOyngOq0gOumrO2VqeuLiOuLpC4gQVBJIOyXlOuTnO2PrOyduO2KuOuKlCDslYzroKTsp4Qg67O07JWIIOy3qOyVveyEseydtCDsl4bripQg7LWc7Iug67KE7KCE7Jy866GcIOyXheuNsOydtO2KuO2VtOyVvCDtlanri4jri6QuCgrrgpgsIHt7IHByb2R1Y2VyIH19IOuKlCDri6TrpbggYmxvY2sgcHJvZHVjZXIgY2FuZGlkYXRlIOqwgCDqsr3qs6Ag4oCL4oCL7ZWcIO2bhCwgMzDrtoQg7J2064K07JeQIOuwlOuhnOyeoeydhCDsiJgg7JeG64uk66m0IGBybXZwcm9kdWNlcmAg7KGw7LmY66W8IO2Gte2VtCDsnpDqsqnsnbQg7KCc6rGwIOuQoCDsiJgg7J6I7J2M7J2EIOyduOygle2VqeuLiOuLpC4KCkFQSSDnq6/ngrkKCuWmguaenOaIke+8jHt7IHByb2R1Y2VyIH19IOeUseS6juW+l+WIsOaKleelqOWSjC/miJblh7rlnZfnmoTljp/lm6DvvIznrKblkIjpooblj5blpZblirHnmoTmnaHku7blubbpgInmi6nmjqXlj5flpZblirHvvIzpgqPkuYjmiJHvvIwge3sgcHJvZHVjZXIgfX3vvIzlsIbmj5Dkvpvlip/og73mraPluLjnmoTlhazlhbEgUDJQIOWSjCBBUEkg56uv54K55p2l57u05oqk5LiO5Yy65Z2X6ZO+55qE5ZCM5q2l77yM5bm25o+Q5Lqk6KaB5omT5YyF5YWl5Z2X55qE5LqL5Yqh44CCQVBJIOerr+eCueW/hemhu+abtOaWsOWIsOacgOaWsOeahOWPr+eUqOeJiOacrO+8jOW5tuS4lOivpeeJiOacrOayoeacieW3suefpeeahOWuieWFqOa8j+a0ngoK5oiR77yMe3twcm9kdWNlcn1977yM5Zyo5q2k56Gu6K6k77yM5aaC5p6c5oiR5Zyo5pS25Yiw5Y+m5LiA5LiqIGJsb2NrIHByb2R1Y2VyIGNhbmRpZGF0ZeeahOitpuWRiuWQjjMw5YiG6ZKf5YaF5LuN5LiN6IO956ym5ZCI5LiK6L+w6KaB5rGC77yM5Y+v5Lul5L2/55SoYHJtdnByb2R1Y2VyYOaTjeS9nOenu+mZpOaIkeeahOi0puaIt+OAggoKIyMjIDcuIEV4ZWN1dGlvbiB0aW1lCgpJLCB7eyBwcm9kdWNlciB9fSwgd2lsbCBkZXBsb3kgYW5kIHJ1biBuZXR3b3JrIGluZnJhc3RydWN0dXJlIGNhcGFibGUgb2YgbWFpbnRhaW5pbmcgMm1zIG9yIGxlc3MgQ1BVIGV4ZWN1dGlvbiB0aW1lcy4KCkksIHt7IHByb2R1Y2VyIH19LCBoZXJlYnkgYWNrbm93bGVkZ2UgdGhhdCBpZiBJIGFtIHVuYWJsZSB0byBkbyBzbyB3aXRoaW4gMzAgbWludXRlcyBvZiBiZWluZyBhbGVydGVkIGJ5IGFub3RoZXIgYmxvY2sgcHJvZHVjZXIgY2FuZGlkYXRlLCBJIGNhbiBiZSByZW1vdmVkIGJ5IHVzZSBvZiB0aGUgYHJtdnByb2R1Y2VyYCBhY3Rpb24uCgrsi6Ttlokg7Iuc6rCECgrrgpgsIHt7IHByb2R1Y2VyIH1964qUIDJtcyDrmJDripQg6re4IOydtO2VmOydmCBDUFUg7Iuk7ZaJIOyLnOqwhOydhCDsnKDsp4DtlaAg7IiYIOyeiOuKlCDrhKTtirjsm4ztgawg7J247ZSE652866W8IOuwsO2PrO2VmOqzoCDsi6Ttlontlanri4jri6QuCgog64KYLCB7eyBwcm9kdWNlciB9fSDripQg64uk66W4IGJsb2NrIHByb2R1Y2VyIGNhbmRpZGF0ZeqwgCDqsr3qs6Ag4oCL4oCL7ZWcIO2bhCwgMzDrtoQg7J2064K07JeQIOuwlOuhnOyeoeydhCDsiJgg7JeG64uk66m0IGBybXZwcm9kdWNlcmAg7KGw7LmY66W8IO2Gte2VtCDsnpDqsqnsnbQg7KCc6rGwIOuQoCDsiJgg7J6I7J2M7J2EIOyduOygle2VqeuLiOuLpC4KCuaJp+ihjOaXtumXtAoK5oiR77yMIHt7IHByb2R1Y2VyIH1977yM5bCG6YOo572y5ZKM6L+Q6KGM572R57uc5Z+656GA6K6+5pa977yM6IO95aSf5bCGIENQVSDmiafooYzml7bpl7Tnu7TmjIHlnKggMm1zIOaIluabtOWwkeeahOawtOW5s+OAggoK5oiR77yMe3sgcHJvZHVjZXIgfX3vvIzlnKjmraTnoa7orqTvvIzlpoLmnpzmiJHlnKjmlLbliLDlj6bkuIDkuKpibG9jayBwcm9kdWNlciBjYW5kaWRhdGXnmoTorablkYrlkI4zMOWIhumSn+WGheS4jeiDveespuWQiOS4iui/sOadoeS7tu+8jOWPr+S7peS9v+eUqCBgcm12cHJvZHVjZXJgIOaTjeS9nOWwhuaIkeenu+mZpOOAggoKIyMjIDguIE9yZGVyaW5nCgpJIHt7IHByb2R1Y2VyIH19IGFncmVlIHRvIHByb2Nlc3MgdHJhbnNhY3Rpb25zIG9uIGEgZmlyc3QtaW4tZmlyc3Qtb3V0IChGSUZPKSBiYXNpcywgYW5kIG5vdCB0byBtYW5pcHVsYXRlIHRoZSBjb250ZW50cyBvZiBibG9ja3MgaW4gb3JkZXIgdG8gZGVyaXZlIHByb2ZpdCBmcm9tIHRoZSBvcmRlciBpbiB3aGljaCB0cmFuc2FjdGlvbnMgYXJlIGluY2x1ZGVkOiB0aGUgaGFzaCBvZiB0aGUgYmxvY2sgdGhhdCBpcyBwcm9kdWNlZC4KCuyDneyCsArrgpgsIHt7IHByb2R1Y2VyIH1964qUIOyEoOyehSDshKDstpzrspUgKEZJRk8pIOuwqeyLneycvOuhnCDqsbDrnpjrpbwg7LKY66as7ZWY6rOgIOqxsOuemOqwgCDruJTroZ3snZgg7ZW07Iuc7JeQIO2PrO2VqOuQmOuKlCDsiJzshJzsl5DshJwg7J207J217J2EIOyWu+ycvOugpOuKlCDrqqnsoIHsnLzroZwg7IOd7IKw7ZWY64qUIOu4lOuhneydmCDrgrTsmqnsnYQg7KGw7J6R7ZWY7KeAIOyViuq4sOuhnCDrj5nsnZjtlanri4jri6QuCgrpobrluo8KCuaIke+8jCB7eyBwcm9kdWNlciB9fSDvvIzlkIzmhI/moLnmja7lhYjov5vlhYjlh7ooRklGTynnmoTmlrnlvI/lpITnkIbkuovliqHvvIzlubbkuJTnu53kuI3kvJrkuLrkuobniZ/liKnogIzliKnnlKjljLrlnZflhoXlrrnjgIHmk43nurXljLrlnZfkuK3kuqTmmJPlpITnkIbnmoTpobrluo/jgIIKCiMjIyA5LiBSYW5kb20gUm90YXRpb24gb2YgU3RhbmRieXMKCkksIHt7IHByb2R1Y2VyIH19LCBhZ3JlZSB0aGF0IGlmIEkgYW0gaW4gYSBwYWlkIHN0YW5kYnkgcG9zaXRpb24sIEkgY2FuIGJlIHJhbmRvbWx5IGNhbGxlZCBpbnRvIGEgcHJvZHVjaW5nIHBvc2l0aW9uLiBVcG9uIGZhaWx1cmUgdG8gcHJvZHVjZSBibG9ja3MsIGNvZGUgbWF5IHNlbGYtZXhlY3V0ZSBwZW5hbHRpZXMgcmVnYXJkaW5nIGZ1dHVyZSB2cGF5IHJld2FyZHMuCgrsnKDquIkg64yA6riwIOu4lOuhne2UhOuhnOuTgOyEnOydmCDrrLTsnpHsnIQg66Gc7YWM7J207IWYCgrrgpgsIHt7IHByb2R1Y2VyIH1964qUIOuzuOyduOydtCDsnKDquIkg64yA6riw7KeB7JeQIOyeiOydhCDrlYwsIOustOyekeychOuhnCDsg53sgrDsp4HsnLzroZwg67aA66aEIOuwm+ydhCDsiJgg7J6I64uk64qUIOqyg+yXkCDrj5nsnZjtlanri4jri6QuIOydtOuVjCDruJTroZ3snYQg7IOd7ISx7ZWY7KeAIOuqu+2VmOuptCDsvZTrk5zripQg7Zal7ZuEIHZwYXkg67O07IOB7JeQIOuMgO2VnCDsspjrsozsnYQg7KeR7ZaJ7ZWgIOyImCDsnojsirXri4jri6QuCgrlpIfpgInoioLngrnpmo/mnLrova7mjaIKCuaIke+8jHt7IHByb2R1Y2VyIH1977yM5ZCM5oSP6Iul5pys6IqC54K55aSE5LqO5pyJ5YG/5aSH6YCJ54q25oCB77yM5Y+v6KKr6ZqP5py66LCD5YWl5Ye65Z2X54q25oCB44CC5aaC5p6c5oiR5peg5rOV5Ye65Z2X77yM5ZCI57qm5Luj56CB5Y+v6IO95Lya6Ieq5Yqo5omn6KGM5bCx5pyq5p2l55qEIHZwYXkg5oql6YWs6L+b6KGM5aSE572a44CCCgojIyMgMTAuIE1pc3NpbmcgVHdvIG9yIE1vcmUgUm91bmRzIG9mIEJsb2NrcwoKSSwge3sgcHJvZHVjZXIgfX0sIGFja25vd2xlZGdlIHRoYXQgaWYgYWZ0ZXIgbWlzc2luZyAyIG9yIG1vcmUgcm91bmRzIG9mIGJsb2NrcyBpbiBzdWNjZXNzaW9uIEkgYW0gdW5hYmxlIHRvIGJlIGNvbnRhY3RlZCB3aXRoaW4gMjAgbWludXRlcywgSSwge3sgcHJvZHVjZXIgfX0sIGFja25vd2xlZGdlIHRoYXQgSSBtYXkgYmUgcmVtb3ZlZCBmcm9tIGEgcHJvZHVjaW5nIHBvc2l0aW9uIGJ5IHVzZSBvZiB0aGUgYHJtdnByb2R1Y2VyYCBhY3Rpb24uCgpJLCB7eyBwcm9kdWNlciB9fSwgYWNrbm93bGVkZ2UgdGhhdCBhZnRlciBtaXNzaW5nIHR3byBvciBtb3JlIHJvdW5kcyBvZiBibG9ja3MgaW4gc3VjY2Vzc2lvbiwgc3RhbmRhcmQgcHJhY3RpY2Ugc3RpcHVsYXRlcyByZW1vdmluZyBteSBwcm9kdWNlciBieSB1c2luZyB0aGUgYHVucmVncHJvZGAgYWN0aW9uIHVudGlsIHRoZSBnaXZlbiBpc3N1ZSBpcyByZXNvbHZlZC4KCuuRkCDrnbzsmrTrk5wg7J207IOB7J2YIOu4lOuhnSDriITrnb0KCuuCmCwge3sgcHJvZHVjZXIgfX3ripQg65GQIOudvOyatOuTnCDsnbTsg4Eg7Jew7IaN7ZWY7JesIOu4lOuhneydhCDriITrnb0g7ZWcIO2bhCwgMjDrtoQg7J2064K07JeQIOyXsOudvSDtlaAg7IiYIOyXhuuLpOuptCB7eyBwcm9kdWNlciB9fSDqsIAgYHJtdnByb2R1Y2VyYCDslaHshZjsnZgg7IKs7Jqp65CY7Ja0IOyDneyCsCDsnITsuZjsl5DshJwg7KCc6rGwIOuQoCDsiJgg7J6I7J2M7J2EIOyduOygle2VqeuLiOuLpC4KCnt7IHByb2R1Y2VyIH1964qUIOuRkCDrnbzsmrTrk5wg7J207IOB7Jy866GcIOu4lOuhneydhCDsl7Dsho3soIHsnLzroZwg64iE65297ZWc64uk66m0LCDso7zslrTsp4Qg66y47KCc6rCAIO2VtOqysCDrkKAg65WM6rmM7KeAIGB1bnJlZ3Byb2RgIOyekeyXheydhCDsgqzsmqntlZjsl6wg67O47J247J20IOyDneyCsCDsnITsuZjsl5DshJwg7KCc6rGw65Co7J20IO2RnOykgCDqtIDtlonsnLzroZwg6rec7KCV65CY7Ja0IOyeiOydjOydhCDsnbjsoJXtlanri4jri6QuCgrkuKTova7miJbmm7TlpJrova7kuKLlnZfnmoTmg4XlvaIKCuaIke+8jHt7IHByb2R1Y2VyIH19LCDnoa7orqTlpoLmnpzov57nu63kuKTova7miJbmm7TlpJrova7kuKLlnZfkuJTml6Dms5XlnKgyMOWIhumSn+WGheiBlOezu+WIsOaIke+8jOaIke+8jHt7IHByb2R1Y2VyIH19LCDlkIzmhI/lj6/og73kvJrnlKggYHJtdnByb2R1Y2VyYCDmk43kvZzlsIbmiJHnp7vpmaTjgIIK5oiR77yMe3sgcHJvZHVjZXIgfX0sIOWmguaenOi/nue7reS4pOi9ruaIluabtOWkmui9ruS4ouWdl++8jOagueaNruagh+WHhuWunui3teS8muWPkei1tyBgdW5yZWdwcm9kYCDmk43kvZzlsIbmiJHnp7vpmaTlh7rlnZfotYTmoLzvvIznm7TliLDpl67popjop6PlhrPjgIIKCiMjIyAxMS4gVXJnZW50IFNlY3VyaXR5IFBhdGNoZXMKCkksIHt7IHByb2R1Y2VyIH19LCBhY2tub3dsZWRnZSB0aGF0IGlmIEkgYW0gbm90IGFibGUgdG8gYmUgY29udGFjdGVkIGluIGFueSBmb3JtIGFmdGVyIGFuIHVyZ2VudCBzZWN1cml0eSBwYXRjaCBpcyBhbm5vdW5jZWQsIEkgbWF5IGJlIHJlbW92ZWQgYnkgdXNlIG9mIHRoZSBgcm12cHJvZHVjZXJgIGFjdGlvbi4KCuq4tOq4iSDrs7TslYgg7Yyo7LmYCuq4tOq4iSDrs7TslYgg7Yyo7LmY6rCAIOuwnO2RnCDrkJwg7ZuELCDslrTrlqQg7ZiV7YOc66Gc65OgIOyXsOudvSDtlaAg7IiYIOyXhuuKlCDqsr3smrAgYHJtdnByb2R1Y2VyYCDsnpHsl4XsnYQg7IKs7Jqp7ZWY7JesIOygnOqxsCDrkKAg7IiYIOyeiOydjOydhCDrgpgsIHt7IHByb2R1Y2VyIH1964qUIOyduOygle2VqeuLiOuLpC4KCue0p+aApeWuieWFqOihpeS4gQoK5oiR77yMe3sgcHJvZHVjZXIgfX3vvIznoa7orqTlpoLmnpzlnKjntKfmgKXlronlhajooaXkuIHlj5HluIPlkI7nlKjku7vkvZXmlrnlvI/pg73ml6Dms5XogZTns7vliLDmiJHvvIzlj6/og73kvJrnlKggYHJtdnByb2R1Y2VyYCDmjIfku6TlsIbmiJHnp7vpmaTjgIIKCiMjIyAxMi4gRGlzY2xvc3VyZSBvZiBFbnRpdHkgYW5kIFNlcnZlciBJbmZvcm1hdGlvbgoKSSwge3sgcHJvZHVjZXIgfX0sIGF0dGVzdCB0aGF0IEkgaGF2ZSBkaXNjbG9zZWQgdGhlIGFwcHJveGltYXRlIGdlb2xvY2F0aW9uIGZvciBteSBtYWluIHByb2R1Y3Rpb24gbm9kZSBhcyBiZWluZyB7eyBsb2NhdGlvbiB9fS4KCuuyleyduCDrsI8g7ISc67KEIOygleuztOydmCDqs7XqsJwKCuuCmCwge3sgcHJvZHVjZXIgfX0g64qUIOyjvCDsg53sgrAg64W465Oc7JeQIOuMgO2VnCDsnITsuZgg7KCV67O066W8IOqzteqwnO2WiOydjOydhCDspp3rqoXtlanri4jri6QuCgrlrp7kvZPlkozmnI3liqHlmajnmoTkv6Hmga/miqvpnLIKCuaIke+8jHt7IHByb2R1Y2VyIH1977yM56Gu6K6k5oiR5bey57uP5oqr6Zyy5LqG5Li75Ye65Z2X6IqC54K55pyN5Yqh5Zmo5Zyw55CG5L2N572u55qE5YeG56Gu5L+h5oGv44CC5YW25Zyw5Z2A5Li6IHt7IGxvY2F0aW9uIH1944CCCgojIyMgMTMuIEVzdGFibGlzaGVzIHRoZSBwZW5hbHR5IGFuZCBwcm9jZWR1cmUgZm9yIHVud2lsbGluZ25lc3MgdG8gY29tcGx5IHdpdGggcGVuYWx0aWVzIG9yIHByb2NlZHVyZXMKCkksIHt7IHByb2R1Y2VyIH19LCBhY2tub3dsZWRnZSB0aGF0IGZhaWxpbmcgdG8gY29tcGx5IHdpdGggcGVuYWx0aWVzIG9yIHByb2NlZHVyZXMgZW5hY3RlZCBhZ2FpbnN0IG1lIHdpbGwgcmVzdWx0IGluIEJsb2NrIFByb2R1Y2VycyBleGVjdXRpbmcgdGhlIGBybXZwcm9kdWNlcmAgY29udHJhY3QgdG8gcmVtb3ZlIG1lLgoKSSwge3sgcHJvZHVjZXIgfX0sIHdpbGwgbm90IGV4ZWN1dGUgdGhlIGByZWdwcm9kdWNlcmAgY29udHJhY3QgdW50aWwgc2VydmluZyBvciBmdWxmaWxsaW5nIHRoZSByZXF1aXJlbWVudHMgZnJvbSBhIHBlbmFsdHkgb3IgcHJvY2VkdXJlIHRoYXQgcmVzdWx0cyBpbiBoYXZpbmcgdGhlIGBybXZwcm9kdWNlcmAgY29udHJhY3QgZXhlY3V0ZWQgdG8gcmVtb3ZlIG1lLgoKSSwge3sgcHJvZHVjZXIgfX0sIGFja25vd2xlZGdlIHRoYXQgaWYgSSBjb250aW51ZSB0byBjYWxsIHRoZSBgcmVncHJvZHVjZXJgIGFjdGlvbiB3aXRob3V0IHNlcnZpbmcgb3IgZnVsZmlsbGluZyB0aGUgcmVxdWlyZW1lbnRzIGZyb20gYnJlYWNoIG9mIGByZWdwcm9kdWNlcmAsIG15IGFjY291bnQga2V5cyBhc3NvY2lhdGVkIHdpdGggdGhlIHJlZ2lzdGVyZWQgQmxvY2sgUHJvZHVjZXIgaW4gcXVlc3Rpb24gbWF5IGJlIG51bGxlZCBieSBCbG9jayBQcm9kdWNlcnMgYnkgdXNpbmcgYGVvc2lvLndyYXBgLgoK7Y6Y64SQ7Yuw66W8IOykgOyImO2VmOyngCDslYrsnYQg6rK97JqwIOuyjOy5mQoK64KYLCB7eyBwcm9kdWNlciB9fSDripQg64KY7JeQ6rKMIOygnOyerOuQnCDsspjrsozsnYQg7KSA7IiY7ZWY7KeAIOyViuycvOuptCDruJTroZ3tlITroZzrk4DshJzrk6TsnbQgYHJtdnByb2R1Y2VyYCDqs4Tslb3snYQg7KeR7ZaJ7ZWY6rKMIOuQoCDqsoPsnbTrnbzqs6Ag7J247KCV7ZWp64uI64ukLiDrgpgsIHt7IHByb2R1Y2VyIH19IOuKlCBgcm12cHJvZHVjZXJgIOqzhOyVveydtCDsp5HtlonrkJzri6TrqbQg7JqU6rWsIOyCrO2VreydhCDstqnsobHrkKAg65WM6rmM7KeAIGByZWdwcm9kdWNlcmAg6rOE7JW97J2EIOydtO2Wie2VmOyngCDslYrsnYQg6rKD7J6F64uI64ukLgpgcmVncHJvZHVjZXJgIOqzhOyVvSDsnITrsJjsnLzroZwg7J247ZWcIOyalOq1rCDsgqztla3snYQg7Lap7KGx7Iuc7YKk7KeAIOyViuqzoCBgcmVncHJvZHVjZXJgIOqzhOyVveydhCDqs4Tsho0g7Zi47Lac7ZWY66m0IO2VtOuLuSDruJTroZ3tlITroZzrk4DshJzsmYAg6rSA66Co65CcIOqzhOyglSDtgqTqsIAgYGVvc2lvLndyYXBgIOydhCDsgqzsmqntlZjsl6wg67iU66Gd7ZSE66Gc65OA7ISc65Ok7JeQIOydmO2VtCDrrLTtmqjtmZQg65CgIOyImCDsnojsnYzsnYQg7J247KCV7ZWp64uI64ukLgoK5a+55LiN5oS/6YG15a6I5aSE572a55qE6KGM5Li65LqI5Lul5aSE572aCgrmiJHvvIx7eyBwcm9kdWNlciB9fe+8jOaJv+iupOiLpeS4jemBteWuiOWvueacrOS6uuWItuijgeeahOWkhOe9mu+8jEJQIOWPr+S7peWunuaWvSBgcm12cHJvZHVjZXJgIOWQiOe6pu+8jOaIkeaOpeWPl+aKleelqOeahOi1hOagvOWwhuiiq+WPlua2iOOAguiLpeaciemSiOWvueaIkeWunuaWvSBgcm12cHJvZHVjZXJgIOWQiOe6pueahOaDheWGteWPkeeUn++8jOaIkSwge3sgcHJvZHVjZXIgfX0g5Zyo6YG15a6IL+WxpeihjOaJgOaUtuWIsOeahOWkhOe9muS5i+WJje+8jOS4jeS8muWGjeasoeaJp+ihjCBgcmVncHJvZHVjZXJgIOWQiOe6puOAggoK5oiR77yMe3sgcHJvZHVjZXIgfX3vvIzlnKjlsaXooYzmg6nnvZrnqIvluo/nmoTopoHmsYLkuYvliY3vvIzkuI3kvJrmiafooYwgYHJlZ3Byb2R1Y2VyYCDlkIjlkIzjgILmiJHnn6XmmZPlpoLkuI3lsaXooYzmraTnqIvluo/vvIwgYHJtdnByb2R1Y2VyYCDlkIjlkIzlsIbkvJrlho3mrKHlsIbmiJHnp7vpmaTjgIIKCuaIkSx7eyBwcm9kdWNlciB9fSwg5om/6K6k5aaC5p6c5rKh5pyJ6YG15a6I5oiW5bGl6KGM5Zug6L+d5Y+NIGByZWdwcm9kdWNlcmAg6ICM5Y+X5Yiw55qE5oOp572a6KaB5rGC5Y2057un57ut6LCD55SoYHJlZ3Byb2R1Y2VyYOaTjeS9nO+8jEJQIOWPr+S7peiwg+eUqCBgZW9zaW8ud3JhcGAg5ZCI57qm5bCG5oiR55So5p2l5rOo5YaM5Ye65Z2X6IqC54K555qE6LSm5Y+35a+G6ZKl6K6+572u5Li65peg5pWI5YC844CCAAABInZhcmlhbnRfYmxvY2tfc2lnbmluZ19hdXRob3JpdHlfdjABGmJsb2NrX3NpZ25pbmdfYXV0aG9yaXR5X3Yw' ) @@ -775,7 +775,7 @@ export namespace Eosio { stake_net_quantity!: Asset @Struct.field(Asset) stake_cpu_quantity!: Asset - @Struct.field('boolean') + @Struct.field('bool') transfer!: boolean } @Struct.type('delegated_bandwidth') @@ -1535,4 +1535,4 @@ export namespace Eosio { limitauthchg: Types.LimitAuthChange, } } -export default Eosio +export default SystemContract diff --git a/src/index.ts b/src/index.ts index 54519ef..5c5f70e 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,6 +1,7 @@ export * from './account' export * from './permission' export * from './kit' +export * from './contracts/eosio' import {AccountKit} from './kit' diff --git a/src/kit.ts b/src/kit.ts index e618c4c..93bffca 100644 --- a/src/kit.ts +++ b/src/kit.ts @@ -1,14 +1,21 @@ import {APIClient, Name, NameType} from '@wharfkit/antelope' +import {Contract} from '@wharfkit/contract' + import {Account} from './account' export interface AccountKitArgs { client: APIClient + contract?: Contract } export class AccountKit { readonly client: APIClient + readonly contract?: Contract constructor(args: AccountKitArgs) { + if (args.contract) { + this.contract = args.contract + } if (args.client) { this.client = args.client } else { @@ -16,26 +23,11 @@ export class AccountKit { } } - /** - * Load an Account by name from an API endpoint - * - * @param account The name of the account to load - * @returns - */ async load(accountName: NameType): Promise { - const account = Name.from(accountName) - - let accountData - - try { - accountData = await this.client.v1.chain.get_account(account) - } catch (error) { - throw new Error(`Account ${account} does not exist`) - } - return new Account({ - accountData: accountData, client: this.client, + contract: this.contract, + data: await this.client.v1.chain.get_account(accountName), }) } } diff --git a/src/permission.ts b/src/permission.ts index b737d9f..b28590a 100644 --- a/src/permission.ts +++ b/src/permission.ts @@ -2,25 +2,26 @@ import { API, Authority, AuthorityType, + isInstanceOf, KeyWeight, Name, NameType, + PermissionLevel, PermissionLevelType, PermissionLevelWeight, + PublicKey, PublicKeyType, + Struct, + UInt16Type, UInt32Type, WaitWeight, } from '@wharfkit/antelope' -import type {Session} from '@wharfkit/session' -import type {Account} from './account' - export interface PermissionData { account: NameType parent: NameType permission: NameType auth: AuthorityType | Authority - authorized_by: NameType } export interface AddKeyActionParam { @@ -36,133 +37,123 @@ export interface ActionData { authorized_by: NameType } -export class Permission { - permission_name: Name - permission_data: PermissionData +export type PermissionType = + | Permission + | API.v1.AccountPermission + | { + perm_name: NameType + parent: NameType + required_auth: AuthorityType + linked_actions?: LinkedActionType[] + } - constructor(permissionName: NameType, permissionData: PermissionData) { - this.permission_name = Name.from(permissionName) - this.permission_data = permissionData - } +export type LinkedActionType = LinkedAction | {account: NameType; action: NameType} - get permissionName(): Name { - return this.permission_name - } +@Struct.type('linked_actions') +export class LinkedAction extends Struct { + @Struct.field('name') declare account: Name + @Struct.field('name') declare action: Name +} + +export type WaitWeightType = WaitWeight | {wait_sec: UInt32Type; weight: UInt16Type} - get actionData(): ActionData { - return { - ...this.permission_data, - auth: Authority.from({ - keys: this.permission_data.auth?.keys?.map(({key, weight}) => { - return { - key: String(key), - weight: Number(weight), - } - }), - accounts: this.permission_data.auth?.accounts?.map(({permission, weight}) => ({ - permission: { - actor: String(permission.actor), - permission: String(permission.permission), - }, - weight: Number(weight), - })), - waits: this.permission_data.auth?.waits?.map(({wait_sec, weight}) => ({ - wait_sec: Number(wait_sec), - weight: Number(weight), - })), - threshold: Number(this.permission_data.auth?.threshold), - }), +@Struct.type('permission') +export class Permission extends Struct { + @Struct.field('name') declare perm_name: Name + @Struct.field('name') declare parent: Name + @Struct.field(Authority) declare required_auth: Authority + @Struct.field(LinkedAction, {array: true, optional: true}) declare linked_actions?: LinkedAction + + static from(value: PermissionType): Permission { + if (isInstanceOf(value, Permission)) { + return value } + return super.from(value) as Permission + } + + get name(): Name { + return this.perm_name } addKey(key: PublicKeyType, weight = 1): void { - this.permission_data = { - ...this.permission_data, - auth: Authority.from({ - ...(this.permission_data.auth || {}), - keys: [ - ...(this.permission_data.auth?.keys || []), - KeyWeight.from({ - key: key, - weight: weight, - }), - ], - }), + const exists = this.required_auth.keys.find((k: KeyWeight) => + PublicKey.from(key).equals(k.key) + ) + if (exists) { + throw new Error( + `The provided key (${String(key)}) already exists on the "${ + this.perm_name + }" permission.` + ) } + this.required_auth.keys.push( + KeyWeight.from({ + key: key, + weight: weight, + }) + ) + // Always sort authorities, required by antelopeio/leap + this.required_auth.sort() } removeKey(key: PublicKeyType): void { - this.permission_data = { - ...this.permission_data, - auth: Authority.from({ - ...this.permission_data.auth, - keys: this.permission_data.auth?.keys?.filter((keyWeight: {key: PublicKeyType}) => { - return String(keyWeight.key) !== key - }), - }), + const index = this.required_auth.keys.findIndex((k: KeyWeight) => + PublicKey.from(key).equals(k.key) + ) + if (index === -1) { + throw new Error( + `The provided key (${String(key)}) does not exist on the "${ + this.perm_name + }" permission.` + ) } + this.required_auth.keys.splice(index, 1) } - addAccount(accountPermission: {actor: NameType; permission: NameType}, weight = 1): void { - this.permission_data = { - ...this.permission_data, - auth: Authority.from({ - ...this.permission_data.auth, - accounts: [ - ...(this.permission_data.auth.accounts || []), - PermissionLevelWeight.from({ - permission: { - actor: accountPermission.actor, - permission: accountPermission.permission, - }, - weight: weight, - }), - ], - }), + addAccount(permissionLevel: PermissionLevelType | string, weight = 1): void { + const exists = this.required_auth.accounts.find((k: PermissionLevelWeight) => + PermissionLevel.from(permissionLevel).equals(k.permission) + ) + if (exists) { + throw new Error( + `The provided account (${String( + PermissionLevel.from(permissionLevel) + )}) already exists on the "${this.perm_name}" permission.` + ) } + this.required_auth.accounts.push( + PermissionLevelWeight.from({ + permission: PermissionLevel.from(permissionLevel), + weight: weight, + }) + ) + // Always sort authorities, required by antelopeio/leap + this.required_auth.sort() } - removeAccount(account: NameType): void { - this.permission_data = { - ...this.permission_data, - auth: Authority.from({ - ...this.permission_data.auth, - accounts: this.permission_data.auth?.accounts?.filter( - (permissionWeight: {permission: PermissionLevelType}) => { - return String(permissionWeight.permission?.actor) !== account - } - ), - }), + removeAccount(permissionLevel: PermissionLevelType): void { + const index = this.required_auth.accounts.findIndex((a: PermissionLevelWeight) => + PermissionLevel.from(permissionLevel).equals(a.permission) + ) + if (index === -1) { + throw new Error( + `The provided permission (${String(permissionLevel)}) does not exist on the "${ + this.perm_name + }" permission.` + ) } + this.required_auth.accounts.splice(index, 1) } - addWait(wait_sec: number, weight = 1): void { - this.permission_data = { - ...this.permission_data, - auth: Authority.from({ - ...this.permission_data.auth, - waits: [ - ...(this.permission_data.auth.waits || []), - WaitWeight.from({ - wait_sec: wait_sec, - weight: weight, - }), - ], - }), - } + addWait(wait: WaitWeightType): void { + this.required_auth.waits.push(WaitWeight.from(wait)) + // Always sort authorities, required by antelopeio/leap + this.required_auth.sort() } - removeWait(wait_sec: UInt32Type): void { - this.permission_data = { - ...this.permission_data, - auth: Authority.from({ - ...this.permission_data.auth, - waits: this.permission_data.auth?.waits?.filter( - (waitWeight: {wait_sec: number; weight: number}) => { - return Number(waitWeight.wait_sec) !== wait_sec - } - ), - }), - } + removeWait(wait: WaitWeightType): void { + this.required_auth.waits = this.required_auth.waits.filter( + (w: WaitWeight) => !WaitWeight.from(wait).equals(w) + ) } } diff --git a/src/resource.ts b/src/resource.ts new file mode 100644 index 0000000..ef7efef --- /dev/null +++ b/src/resource.ts @@ -0,0 +1,50 @@ +import {API, Int64} from '@wharfkit/antelope' + +export type ResourceType = 'cpu' | 'net' | 'ram' + +export interface ResourceValues { + available: Int64 + used: Int64 + max: Int64 +} + +export class Resource { + public resource: ResourceType + public data: API.v1.AccountObject + + readonly available: Int64 + readonly used: Int64 + readonly max: Int64 + + readonly weight?: Int64 + + constructor(resource: ResourceType, data: API.v1.AccountObject) { + this.resource = resource + this.data = data + switch (resource) { + case 'cpu': { + this.available = this.data.cpu_limit.available + this.used = this.data.cpu_limit.used + this.max = this.data.cpu_limit.max + this.weight = this.data.cpu_weight + break + } + case 'net': { + this.available = this.data.net_limit.available + this.used = this.data.net_limit.used + this.max = this.data.net_limit.max + this.weight = this.data.net_weight + break + } + case 'ram': { + this.available = this.data.ram_quota.subtracting(this.data.ram_usage) + this.used = Int64.from(this.data.ram_usage) + this.max = this.data.ram_quota + break + } + default: { + throw new Error(`Unknown resource type (${resource}).`) + } + } + } +} diff --git a/test/data/1343515aa85d3148aedc98f52cbc3706fc33e53b.json b/test/data/1343515aa85d3148aedc98f52cbc3706fc33e53b.json new file mode 100644 index 0000000..1956bc2 --- /dev/null +++ b/test/data/1343515aa85d3148aedc98f52cbc3706fc33e53b.json @@ -0,0 +1,85 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/send_transaction", + "params": { + "method": "POST", + "body": "{\"signatures\":[\"SIG_K1_KiwjSKNiWmRhReYjUr3G38WFh18FmEX9EGophQDsaFdHHMR9wPBaRQaaN1T3E7pW1ykyoNjwr9SyxUpGPjLE2EjJTS1gaB\"],\"compression\":0,\"packed_context_free_data\":\"00\",\"packed_trx\":\"57cdf364f01af5e82a5800000000010000000000ea30550040cbdaa8aca24a01304608d9c1754de300000000a8ed323218304608d9c1754de300000019ab9cddd4000000000000000000\"}" + } + }, + "status": 202, + "json": { + "transaction_id": "0d31acef3a28426567d4d14391a7c68ff1bb4520e312a3d823fb97c624787b28", + "processed": { + "id": "0d31acef3a28426567d4d14391a7c68ff1bb4520e312a3d823fb97c624787b28", + "block_num": 95886535, + "block_time": "2023-09-03T00:02:43.000", + "producer_block_id": null, + "receipt": { + "status": "executed", + "cpu_usage_us": 157, + "net_usage_words": 15 + }, + "elapsed": 157, + "net_usage": 120, + "scheduled": false, + "action_traces": [ + { + "action_ordinal": 1, + "creator_action_ordinal": 0, + "closest_unnotified_ancestor_action_ordinal": 0, + "receipt": { + "receiver": "eosio", + "act_digest": "1fba57292b4bfba21434191601403dc0db84eae7538e41ef19fe3c828ec64baf", + "global_sequence": 128190592, + "recv_sequence": 95947487, + "auth_sequence": [ + [ + "wharfkit1133", + 30 + ] + ], + "code_sequence": 4, + "abi_sequence": 4 + }, + "receiver": "eosio", + "act": { + "account": "eosio", + "name": "deleteauth", + "authorization": [ + { + "actor": "wharfkit1133", + "permission": "active" + } + ], + "data": { + "account": "wharfkit1133", + "permission": "unittest", + "authorized_by": "" + }, + "hex_data": "304608d9c1754de300000019ab9cddd40000000000000000" + }, + "context_free": false, + "elapsed": 39, + "console": "", + "trx_id": "0d31acef3a28426567d4d14391a7c68ff1bb4520e312a3d823fb97c624787b28", + "block_num": 95886535, + "block_time": "2023-09-03T00:02:43.000", + "producer_block_id": null, + "account_ram_deltas": [ + { + "account": "wharfkit1133", + "delta": -338 + } + ], + "except": null, + "error_code": null, + "return_value_hex_data": "" + } + ], + "account_ram_delta": null, + "except": null, + "error_code": null + } + }, + "text": "{\"transaction_id\":\"0d31acef3a28426567d4d14391a7c68ff1bb4520e312a3d823fb97c624787b28\",\"processed\":{\"id\":\"0d31acef3a28426567d4d14391a7c68ff1bb4520e312a3d823fb97c624787b28\",\"block_num\":95886535,\"block_time\":\"2023-09-03T00:02:43.000\",\"producer_block_id\":null,\"receipt\":{\"status\":\"executed\",\"cpu_usage_us\":157,\"net_usage_words\":15},\"elapsed\":157,\"net_usage\":120,\"scheduled\":false,\"action_traces\":[{\"action_ordinal\":1,\"creator_action_ordinal\":0,\"closest_unnotified_ancestor_action_ordinal\":0,\"receipt\":{\"receiver\":\"eosio\",\"act_digest\":\"1fba57292b4bfba21434191601403dc0db84eae7538e41ef19fe3c828ec64baf\",\"global_sequence\":128190592,\"recv_sequence\":95947487,\"auth_sequence\":[[\"wharfkit1133\",30]],\"code_sequence\":4,\"abi_sequence\":4},\"receiver\":\"eosio\",\"act\":{\"account\":\"eosio\",\"name\":\"deleteauth\",\"authorization\":[{\"actor\":\"wharfkit1133\",\"permission\":\"active\"}],\"data\":{\"account\":\"wharfkit1133\",\"permission\":\"unittest\",\"authorized_by\":\"\"},\"hex_data\":\"304608d9c1754de300000019ab9cddd40000000000000000\"},\"context_free\":false,\"elapsed\":39,\"console\":\"\",\"trx_id\":\"0d31acef3a28426567d4d14391a7c68ff1bb4520e312a3d823fb97c624787b28\",\"block_num\":95886535,\"block_time\":\"2023-09-03T00:02:43.000\",\"producer_block_id\":null,\"account_ram_deltas\":[{\"account\":\"wharfkit1133\",\"delta\":-338}],\"except\":null,\"error_code\":null,\"return_value_hex_data\":\"\"}],\"account_ram_delta\":null,\"except\":null,\"error_code\":null}}" +} \ No newline at end of file diff --git a/test/data/2a1ce300eff8451d45f33f2c4d40bb35990f1868.json b/test/data/2a1ce300eff8451d45f33f2c4d40bb35990f1868.json new file mode 100644 index 0000000..efd8f42 --- /dev/null +++ b/test/data/2a1ce300eff8451d45f33f2c4d40bb35990f1868.json @@ -0,0 +1,17 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_raw_abi", + "params": { + "method": "POST", + "body": "{\"account_name\":\"eosio\"}" + } + }, + "status": 200, + "json": { + "account_name": "eosio", + "code_hash": "6b93a5f220b03a37e98298010aa8562a028f484f1775c9d14512eda7f5498c18", + "abi_hash": "61788bc26da987e1aa17600bc8327949146a5700bfbcbfb3cec4213b4120b3cd", + "abi": "DmVvc2lvOjphYmkvMS4yAhdibG9ja19zaWduaW5nX2F1dGhvcml0eSJ2YXJpYW50X2Jsb2NrX3NpZ25pbmdfYXV0aG9yaXR5X3YwF2Jsb2NrY2hhaW5fcGFyYW1ldGVyc190GGJsb2NrY2hhaW5fcGFyYW1ldGVyc192MWcIYWJpX2hhc2gAAgVvd25lcgRuYW1lBGhhc2gLY2hlY2tzdW0yNTYIYWN0aXZhdGUAAQ5mZWF0dXJlX2RpZ2VzdAtjaGVja3N1bTI1NglhdXRob3JpdHkABAl0aHJlc2hvbGQGdWludDMyBGtleXMMa2V5X3dlaWdodFtdCGFjY291bnRzGXBlcm1pc3Npb25fbGV2ZWxfd2VpZ2h0W10Fd2FpdHMNd2FpdF93ZWlnaHRbXQpiaWRfcmVmdW5kAAIGYmlkZGVyBG5hbWUGYW1vdW50BWFzc2V0B2JpZG5hbWUAAwZiaWRkZXIEbmFtZQduZXduYW1lBG5hbWUDYmlkBWFzc2V0CWJpZHJlZnVuZAACBmJpZGRlcgRuYW1lB25ld25hbWUEbmFtZQxibG9ja19oZWFkZXIACAl0aW1lc3RhbXAGdWludDMyCHByb2R1Y2VyBG5hbWUJY29uZmlybWVkBnVpbnQxNghwcmV2aW91cwtjaGVja3N1bTI1NhF0cmFuc2FjdGlvbl9tcm9vdAtjaGVja3N1bTI1NgxhY3Rpb25fbXJvb3QLY2hlY2tzdW0yNTYQc2NoZWR1bGVfdmVyc2lvbgZ1aW50MzINbmV3X3Byb2R1Y2VycxJwcm9kdWNlcl9zY2hlZHVsZT8RYmxvY2tfaW5mb19yZWNvcmQAAwd2ZXJzaW9uBXVpbnQ4DGJsb2NrX2hlaWdodAZ1aW50MzIPYmxvY2tfdGltZXN0YW1wCnRpbWVfcG9pbnQaYmxvY2tfc2lnbmluZ19hdXRob3JpdHlfdjAAAgl0aHJlc2hvbGQGdWludDMyBGtleXMMa2V5X3dlaWdodFtdFWJsb2NrY2hhaW5fcGFyYW1ldGVycwARE21heF9ibG9ja19uZXRfdXNhZ2UGdWludDY0GnRhcmdldF9ibG9ja19uZXRfdXNhZ2VfcGN0BnVpbnQzMhltYXhfdHJhbnNhY3Rpb25fbmV0X3VzYWdlBnVpbnQzMh5iYXNlX3Blcl90cmFuc2FjdGlvbl9uZXRfdXNhZ2UGdWludDMyEG5ldF91c2FnZV9sZWV3YXkGdWludDMyI2NvbnRleHRfZnJlZV9kaXNjb3VudF9uZXRfdXNhZ2VfbnVtBnVpbnQzMiNjb250ZXh0X2ZyZWVfZGlzY291bnRfbmV0X3VzYWdlX2RlbgZ1aW50MzITbWF4X2Jsb2NrX2NwdV91c2FnZQZ1aW50MzIadGFyZ2V0X2Jsb2NrX2NwdV91c2FnZV9wY3QGdWludDMyGW1heF90cmFuc2FjdGlvbl9jcHVfdXNhZ2UGdWludDMyGW1pbl90cmFuc2FjdGlvbl9jcHVfdXNhZ2UGdWludDMyGG1heF90cmFuc2FjdGlvbl9saWZldGltZQZ1aW50MzIeZGVmZXJyZWRfdHJ4X2V4cGlyYXRpb25fd2luZG93BnVpbnQzMhVtYXhfdHJhbnNhY3Rpb25fZGVsYXkGdWludDMyFm1heF9pbmxpbmVfYWN0aW9uX3NpemUGdWludDMyF21heF9pbmxpbmVfYWN0aW9uX2RlcHRoBnVpbnQxNhNtYXhfYXV0aG9yaXR5X2RlcHRoBnVpbnQxNhhibG9ja2NoYWluX3BhcmFtZXRlcnNfdjEVYmxvY2tjaGFpbl9wYXJhbWV0ZXJzARxtYXhfYWN0aW9uX3JldHVybl92YWx1ZV9zaXplB3VpbnQzMiQGYnV5cmFtAAMFcGF5ZXIEbmFtZQhyZWNlaXZlcgRuYW1lBXF1YW50BWFzc2V0C2J1eXJhbWJ5dGVzAAMFcGF5ZXIEbmFtZQhyZWNlaXZlcgRuYW1lBWJ5dGVzBnVpbnQzMgZidXlyZXgAAgRmcm9tBG5hbWUGYW1vdW50BWFzc2V0C2NhbmNlbGRlbGF5AAIOY2FuY2VsaW5nX2F1dGgQcGVybWlzc2lvbl9sZXZlbAZ0cnhfaWQLY2hlY2tzdW0yNTYKY2ZncG93ZXJ1cAABBGFyZ3MOcG93ZXJ1cF9jb25maWcMY2xhaW1yZXdhcmRzAAEFb3duZXIEbmFtZQhjbG9zZXJleAABBW93bmVyBG5hbWUMY25jbHJleG9yZGVyAAEFb3duZXIEbmFtZQljb25uZWN0b3IAAgdiYWxhbmNlBWFzc2V0BndlaWdodAdmbG9hdDY0C2NvbnNvbGlkYXRlAAEFb3duZXIEbmFtZQpkZWZjcHVsb2FuAAMEZnJvbQRuYW1lCGxvYW5fbnVtBnVpbnQ2NAZhbW91bnQFYXNzZXQKZGVmbmV0bG9hbgADBGZyb20EbmFtZQhsb2FuX251bQZ1aW50NjQGYW1vdW50BWFzc2V0CmRlbGVnYXRlYncABQRmcm9tBG5hbWUIcmVjZWl2ZXIEbmFtZRJzdGFrZV9uZXRfcXVhbnRpdHkFYXNzZXQSc3Rha2VfY3B1X3F1YW50aXR5BWFzc2V0CHRyYW5zZmVyBGJvb2wTZGVsZWdhdGVkX2JhbmR3aWR0aAAEBGZyb20EbmFtZQJ0bwRuYW1lCm5ldF93ZWlnaHQFYXNzZXQKY3B1X3dlaWdodAVhc3NldApkZWxldGVhdXRoAAMHYWNjb3VudARuYW1lCnBlcm1pc3Npb24EbmFtZQ1hdXRob3JpemVkX2J5BW5hbWUkB2RlcG9zaXQAAgVvd25lcgRuYW1lBmFtb3VudAVhc3NldBJlb3Npb19nbG9iYWxfc3RhdGUVYmxvY2tjaGFpbl9wYXJhbWV0ZXJzDQxtYXhfcmFtX3NpemUGdWludDY0GHRvdGFsX3JhbV9ieXRlc19yZXNlcnZlZAZ1aW50NjQPdG90YWxfcmFtX3N0YWtlBWludDY0HWxhc3RfcHJvZHVjZXJfc2NoZWR1bGVfdXBkYXRlFGJsb2NrX3RpbWVzdGFtcF90eXBlGGxhc3RfcGVydm90ZV9idWNrZXRfZmlsbAp0aW1lX3BvaW50DnBlcnZvdGVfYnVja2V0BWludDY0D3BlcmJsb2NrX2J1Y2tldAVpbnQ2NBN0b3RhbF91bnBhaWRfYmxvY2tzBnVpbnQzMhV0b3RhbF9hY3RpdmF0ZWRfc3Rha2UFaW50NjQbdGhyZXNoX2FjdGl2YXRlZF9zdGFrZV90aW1lCnRpbWVfcG9pbnQbbGFzdF9wcm9kdWNlcl9zY2hlZHVsZV9zaXplBnVpbnQxNhp0b3RhbF9wcm9kdWNlcl92b3RlX3dlaWdodAdmbG9hdDY0D2xhc3RfbmFtZV9jbG9zZRRibG9ja190aW1lc3RhbXBfdHlwZRNlb3Npb19nbG9iYWxfc3RhdGUyAAURbmV3X3JhbV9wZXJfYmxvY2sGdWludDE2EWxhc3RfcmFtX2luY3JlYXNlFGJsb2NrX3RpbWVzdGFtcF90eXBlDmxhc3RfYmxvY2tfbnVtFGJsb2NrX3RpbWVzdGFtcF90eXBlHHRvdGFsX3Byb2R1Y2VyX3ZvdGVwYXlfc2hhcmUHZmxvYXQ2NAhyZXZpc2lvbgV1aW50OBNlb3Npb19nbG9iYWxfc3RhdGUzAAIWbGFzdF92cGF5X3N0YXRlX3VwZGF0ZQp0aW1lX3BvaW50HHRvdGFsX3ZwYXlfc2hhcmVfY2hhbmdlX3JhdGUHZmxvYXQ2NBNlb3Npb19nbG9iYWxfc3RhdGU0AAMPY29udGludW91c19yYXRlB2Zsb2F0NjQUaW5mbGF0aW9uX3BheV9mYWN0b3IFaW50NjQOdm90ZXBheV9mYWN0b3IFaW50NjQOZXhjaGFuZ2Vfc3RhdGUAAwZzdXBwbHkFYXNzZXQEYmFzZQljb25uZWN0b3IFcXVvdGUJY29ubmVjdG9yC2Z1bmRjcHVsb2FuAAMEZnJvbQRuYW1lCGxvYW5fbnVtBnVpbnQ2NAdwYXltZW50BWFzc2V0C2Z1bmRuZXRsb2FuAAMEZnJvbQRuYW1lCGxvYW5fbnVtBnVpbnQ2NAdwYXltZW50BWFzc2V0BGluaXQAAgd2ZXJzaW9uCXZhcnVpbnQzMgRjb3JlBnN5bWJvbAprZXlfd2VpZ2h0AAIDa2V5CnB1YmxpY19rZXkGd2VpZ2h0BnVpbnQxNgxsaW1pdGF1dGhjaGcAAwdhY2NvdW50BG5hbWULYWxsb3dfcGVybXMGbmFtZVtdDmRpc2FsbG93X3Blcm1zBm5hbWVbXQhsaW5rYXV0aAAFB2FjY291bnQEbmFtZQRjb2RlBG5hbWUEdHlwZQRuYW1lC3JlcXVpcmVtZW50BG5hbWUNYXV0aG9yaXplZF9ieQVuYW1lJAttdmZyc2F2aW5ncwACBW93bmVyBG5hbWUDcmV4BWFzc2V0C212dG9zYXZpbmdzAAIFb3duZXIEbmFtZQNyZXgFYXNzZXQIbmFtZV9iaWQABAduZXduYW1lBG5hbWULaGlnaF9iaWRkZXIEbmFtZQhoaWdoX2JpZAVpbnQ2NA1sYXN0X2JpZF90aW1lCnRpbWVfcG9pbnQKbmV3YWNjb3VudAAEB2NyZWF0b3IEbmFtZQRuYW1lBG5hbWUFb3duZXIJYXV0aG9yaXR5BmFjdGl2ZQlhdXRob3JpdHkHb25ibG9jawABBmhlYWRlcgxibG9ja19oZWFkZXIHb25lcnJvcgACCXNlbmRlcl9pZAd1aW50MTI4CHNlbnRfdHJ4BWJ5dGVzGXBhaXJfdGltZV9wb2ludF9zZWNfaW50NjQAAgVmaXJzdA50aW1lX3BvaW50X3NlYwZzZWNvbmQFaW50NjQQcGVybWlzc2lvbl9sZXZlbAACBWFjdG9yBG5hbWUKcGVybWlzc2lvbgRuYW1lF3Blcm1pc3Npb25fbGV2ZWxfd2VpZ2h0AAIKcGVybWlzc2lvbhBwZXJtaXNzaW9uX2xldmVsBndlaWdodAZ1aW50MTYHcG93ZXJ1cAAGBXBheWVyBG5hbWUIcmVjZWl2ZXIEbmFtZQRkYXlzBnVpbnQzMghuZXRfZnJhYwVpbnQ2NAhjcHVfZnJhYwVpbnQ2NAttYXhfcGF5bWVudAVhc3NldA5wb3dlcnVwX2NvbmZpZwAEA25ldBdwb3dlcnVwX2NvbmZpZ19yZXNvdXJjZQNjcHUXcG93ZXJ1cF9jb25maWdfcmVzb3VyY2UMcG93ZXJ1cF9kYXlzB3VpbnQzMj8PbWluX3Bvd2VydXBfZmVlBmFzc2V0Pxdwb3dlcnVwX2NvbmZpZ19yZXNvdXJjZQAIFGN1cnJlbnRfd2VpZ2h0X3JhdGlvBmludDY0PxN0YXJnZXRfd2VpZ2h0X3JhdGlvBmludDY0PxRhc3N1bWVkX3N0YWtlX3dlaWdodAZpbnQ2ND8QdGFyZ2V0X3RpbWVzdGFtcA90aW1lX3BvaW50X3NlYz8IZXhwb25lbnQIZmxvYXQ2ND8KZGVjYXlfc2Vjcwd1aW50MzI/CW1pbl9wcmljZQZhc3NldD8JbWF4X3ByaWNlBmFzc2V0Pw1wb3dlcnVwX29yZGVyAAYHdmVyc2lvbgV1aW50OAJpZAZ1aW50NjQFb3duZXIEbmFtZQpuZXRfd2VpZ2h0BWludDY0CmNwdV93ZWlnaHQFaW50NjQHZXhwaXJlcw50aW1lX3BvaW50X3NlYw1wb3dlcnVwX3N0YXRlAAUHdmVyc2lvbgV1aW50OANuZXQWcG93ZXJ1cF9zdGF0ZV9yZXNvdXJjZQNjcHUWcG93ZXJ1cF9zdGF0ZV9yZXNvdXJjZQxwb3dlcnVwX2RheXMGdWludDMyD21pbl9wb3dlcnVwX2ZlZQVhc3NldBZwb3dlcnVwX3N0YXRlX3Jlc291cmNlAA8HdmVyc2lvbgV1aW50OAZ3ZWlnaHQFaW50NjQMd2VpZ2h0X3JhdGlvBWludDY0FGFzc3VtZWRfc3Rha2Vfd2VpZ2h0BWludDY0FGluaXRpYWxfd2VpZ2h0X3JhdGlvBWludDY0E3RhcmdldF93ZWlnaHRfcmF0aW8FaW50NjQRaW5pdGlhbF90aW1lc3RhbXAOdGltZV9wb2ludF9zZWMQdGFyZ2V0X3RpbWVzdGFtcA50aW1lX3BvaW50X3NlYwhleHBvbmVudAdmbG9hdDY0CmRlY2F5X3NlY3MGdWludDMyCW1pbl9wcmljZQVhc3NldAltYXhfcHJpY2UFYXNzZXQLdXRpbGl6YXRpb24FaW50NjQUYWRqdXN0ZWRfdXRpbGl6YXRpb24FaW50NjQVdXRpbGl6YXRpb25fdGltZXN0YW1wDnRpbWVfcG9pbnRfc2VjC3Bvd2VydXBleGVjAAIEdXNlcgRuYW1lA21heAZ1aW50MTYNcHJvZHVjZXJfaW5mbwAJBW93bmVyBG5hbWULdG90YWxfdm90ZXMHZmxvYXQ2NAxwcm9kdWNlcl9rZXkKcHVibGljX2tleQlpc19hY3RpdmUEYm9vbAN1cmwGc3RyaW5nDXVucGFpZF9ibG9ja3MGdWludDMyD2xhc3RfY2xhaW1fdGltZQp0aW1lX3BvaW50CGxvY2F0aW9uBnVpbnQxNhJwcm9kdWNlcl9hdXRob3JpdHkYYmxvY2tfc2lnbmluZ19hdXRob3JpdHkkDnByb2R1Y2VyX2luZm8yAAMFb3duZXIEbmFtZQ12b3RlcGF5X3NoYXJlB2Zsb2F0NjQZbGFzdF92b3RlcGF5X3NoYXJlX3VwZGF0ZQp0aW1lX3BvaW50DHByb2R1Y2VyX2tleQACDXByb2R1Y2VyX25hbWUEbmFtZRFibG9ja19zaWduaW5nX2tleQpwdWJsaWNfa2V5EXByb2R1Y2VyX3NjaGVkdWxlAAIHdmVyc2lvbgZ1aW50MzIJcHJvZHVjZXJzDnByb2R1Y2VyX2tleVtdBnJlZnVuZAABBW93bmVyBG5hbWUOcmVmdW5kX3JlcXVlc3QABAVvd25lcgRuYW1lDHJlcXVlc3RfdGltZQ50aW1lX3BvaW50X3NlYwpuZXRfYW1vdW50BWFzc2V0CmNwdV9hbW91bnQFYXNzZXQLcmVncHJvZHVjZXIABAhwcm9kdWNlcgRuYW1lDHByb2R1Y2VyX2tleQpwdWJsaWNfa2V5A3VybAZzdHJpbmcIbG9jYXRpb24GdWludDE2DHJlZ3Byb2R1Y2VyMgAECHByb2R1Y2VyBG5hbWUScHJvZHVjZXJfYXV0aG9yaXR5F2Jsb2NrX3NpZ25pbmdfYXV0aG9yaXR5A3VybAZzdHJpbmcIbG9jYXRpb24GdWludDE2CHJlZ3Byb3h5AAIFcHJveHkEbmFtZQdpc3Byb3h5BGJvb2wHcmVudGNwdQAEBGZyb20EbmFtZQhyZWNlaXZlcgRuYW1lDGxvYW5fcGF5bWVudAVhc3NldAlsb2FuX2Z1bmQFYXNzZXQHcmVudG5ldAAEBGZyb20EbmFtZQhyZWNlaXZlcgRuYW1lDGxvYW5fcGF5bWVudAVhc3NldAlsb2FuX2Z1bmQFYXNzZXQLcmV4X2JhbGFuY2UABgd2ZXJzaW9uBXVpbnQ4BW93bmVyBG5hbWUKdm90ZV9zdGFrZQVhc3NldAtyZXhfYmFsYW5jZQVhc3NldAttYXR1cmVkX3JleAVpbnQ2NA5yZXhfbWF0dXJpdGllcxtwYWlyX3RpbWVfcG9pbnRfc2VjX2ludDY0W10IcmV4X2Z1bmQAAwd2ZXJzaW9uBXVpbnQ4BW93bmVyBG5hbWUHYmFsYW5jZQVhc3NldAhyZXhfbG9hbgAIB3ZlcnNpb24FdWludDgEZnJvbQRuYW1lCHJlY2VpdmVyBG5hbWUHcGF5bWVudAVhc3NldAdiYWxhbmNlBWFzc2V0DHRvdGFsX3N0YWtlZAVhc3NldAhsb2FuX251bQZ1aW50NjQKZXhwaXJhdGlvbgp0aW1lX3BvaW50CXJleF9vcmRlcgAHB3ZlcnNpb24FdWludDgFb3duZXIEbmFtZQ1yZXhfcmVxdWVzdGVkBWFzc2V0CHByb2NlZWRzBWFzc2V0DHN0YWtlX2NoYW5nZQVhc3NldApvcmRlcl90aW1lCnRpbWVfcG9pbnQHaXNfb3BlbgRib29sCHJleF9wb29sAAgHdmVyc2lvbgV1aW50OAp0b3RhbF9sZW50BWFzc2V0DHRvdGFsX3VubGVudAVhc3NldAp0b3RhbF9yZW50BWFzc2V0DnRvdGFsX2xlbmRhYmxlBWFzc2V0CXRvdGFsX3JleAVhc3NldBBuYW1lYmlkX3Byb2NlZWRzBWFzc2V0CGxvYW5fbnVtBnVpbnQ2NBJyZXhfcmV0dXJuX2J1Y2tldHMAAgd2ZXJzaW9uBXVpbnQ4DnJldHVybl9idWNrZXRzG3BhaXJfdGltZV9wb2ludF9zZWNfaW50NjRbXQ9yZXhfcmV0dXJuX3Bvb2wABwd2ZXJzaW9uBXVpbnQ4Dmxhc3RfZGlzdF90aW1lDnRpbWVfcG9pbnRfc2VjE3BlbmRpbmdfYnVja2V0X3RpbWUOdGltZV9wb2ludF9zZWMSb2xkZXN0X2J1Y2tldF90aW1lDnRpbWVfcG9pbnRfc2VjF3BlbmRpbmdfYnVja2V0X3Byb2NlZWRzBWludDY0GGN1cnJlbnRfcmF0ZV9vZl9pbmNyZWFzZQVpbnQ2NAhwcm9jZWVkcwVpbnQ2NAdyZXhleGVjAAIEdXNlcgRuYW1lA21heAZ1aW50MTYLcm12cHJvZHVjZXIAAQhwcm9kdWNlcgRuYW1lB3NlbGxyYW0AAgdhY2NvdW50BG5hbWUFYnl0ZXMFaW50NjQHc2VsbHJleAACBGZyb20EbmFtZQNyZXgFYXNzZXQGc2V0YWJpAAMHYWNjb3VudARuYW1lA2FiaQVieXRlcwRtZW1vB3N0cmluZyQKc2V0YWNjdGNwdQACB2FjY291bnQEbmFtZQpjcHVfd2VpZ2h0BmludDY0PwpzZXRhY2N0bmV0AAIHYWNjb3VudARuYW1lCm5ldF93ZWlnaHQGaW50NjQ/CnNldGFjY3RyYW0AAgdhY2NvdW50BG5hbWUJcmFtX2J5dGVzBmludDY0PwpzZXRhbGltaXRzAAQHYWNjb3VudARuYW1lCXJhbV9ieXRlcwVpbnQ2NApuZXRfd2VpZ2h0BWludDY0CmNwdV93ZWlnaHQFaW50NjQHc2V0Y29kZQAFB2FjY291bnQEbmFtZQZ2bXR5cGUFdWludDgJdm12ZXJzaW9uBXVpbnQ4BGNvZGUFYnl0ZXMEbWVtbwdzdHJpbmckDHNldGluZmxhdGlvbgADC2FubnVhbF9yYXRlBWludDY0FGluZmxhdGlvbl9wYXlfZmFjdG9yBWludDY0DnZvdGVwYXlfZmFjdG9yBWludDY0CXNldHBhcmFtcwABBnBhcmFtcxdibG9ja2NoYWluX3BhcmFtZXRlcnNfdAdzZXRwcml2AAIHYWNjb3VudARuYW1lB2lzX3ByaXYFdWludDgGc2V0cmFtAAEMbWF4X3JhbV9zaXplBnVpbnQ2NApzZXRyYW1yYXRlAAEPYnl0ZXNfcGVyX2Jsb2NrBnVpbnQxNgZzZXRyZXgAAQdiYWxhbmNlBWFzc2V0DHVuZGVsZWdhdGVidwAEBGZyb20EbmFtZQhyZWNlaXZlcgRuYW1lFHVuc3Rha2VfbmV0X3F1YW50aXR5BWFzc2V0FHVuc3Rha2VfY3B1X3F1YW50aXR5BWFzc2V0CnVubGlua2F1dGgABAdhY2NvdW50BG5hbWUEY29kZQRuYW1lBHR5cGUEbmFtZQ1hdXRob3JpemVkX2J5BW5hbWUkCXVucmVncHJvZAABCHByb2R1Y2VyBG5hbWUMdW5zdGFrZXRvcmV4AAQFb3duZXIEbmFtZQhyZWNlaXZlcgRuYW1lCGZyb21fbmV0BWFzc2V0CGZyb21fY3B1BWFzc2V0CnVwZGF0ZWF1dGgABQdhY2NvdW50BG5hbWUKcGVybWlzc2lvbgRuYW1lBnBhcmVudARuYW1lBGF1dGgJYXV0aG9yaXR5DWF1dGhvcml6ZWRfYnkFbmFtZSQJdXBkYXRlcmV4AAEFb3duZXIEbmFtZQx1cGR0cmV2aXNpb24AAQhyZXZpc2lvbgV1aW50OA51c2VyX3Jlc291cmNlcwAEBW93bmVyBG5hbWUKbmV0X3dlaWdodAVhc3NldApjcHVfd2VpZ2h0BWFzc2V0CXJhbV9ieXRlcwVpbnQ2NAx2b3RlcHJvZHVjZXIAAwV2b3RlcgRuYW1lBXByb3h5BG5hbWUJcHJvZHVjZXJzBm5hbWVbXQp2b3Rlcl9pbmZvAAoFb3duZXIEbmFtZQVwcm94eQRuYW1lCXByb2R1Y2VycwZuYW1lW10Gc3Rha2VkBWludDY0EGxhc3Rfdm90ZV93ZWlnaHQHZmxvYXQ2NBNwcm94aWVkX3ZvdGVfd2VpZ2h0B2Zsb2F0NjQIaXNfcHJveHkEYm9vbAZmbGFnczEGdWludDMyCXJlc2VydmVkMgZ1aW50MzIJcmVzZXJ2ZWQzBWFzc2V0CnZvdGV1cGRhdGUAAQp2b3Rlcl9uYW1lBG5hbWULd2FpdF93ZWlnaHQAAgh3YWl0X3NlYwZ1aW50MzIGd2VpZ2h0BnVpbnQxNgd3YXNtY2ZnAAEIc2V0dGluZ3MEbmFtZQh3aXRoZHJhdwACBW93bmVyBG5hbWUGYW1vdW50BWFzc2V0EWxpbWl0X2F1dGhfY2hhbmdlAAQHdmVyc2lvbgV1aW50OAdhY2NvdW50BG5hbWULYWxsb3dfcGVybXMGbmFtZVtdDmRpc2FsbG93X3Blcm1zBm5hbWVbXT4AAAAqm+0yMghhY3RpdmF0ZQAAAABASTOTOwdiaWRuYW1lAAAASFMvdZM7CWJpZHJlZnVuZAAAAAAASHO9PgZidXlyYW0AALDK/khzvT4LYnV5cmFtYnl0ZXMAAAAAAHR1vT4GYnV5cmV4AAC8iSpFhaZBC2NhbmNlbGRlbGF5AABA1VdxWtlCCmNmZ3Bvd2VydXAAgNM1XF3pTEQMY2xhaW1yZXdhcmRzAAAAAF1dhWlECGNsb3NlcmV4AHBVurSrG9FEDGNuY2xyZXhvcmRlcgAAVDbJRYonRQtjb25zb2xpZGF0ZQAAwDQ06oqWSgpkZWZjcHVsb2FuAADANDRmNZdKCmRlZm5ldGxvYW4AAAA/KhumokoKZGVsZWdhdGVidwAAQMvaqKyiSgpkZWxldGVhdXRoAAAAACA7TKtKB2RlcG9zaXQAAKahUVeUpl4LZnVuZGNwdWxvYW4AAKahMauZpl4LZnVuZG5ldGxvYW4AAAAAAACQ3XQEaW5pdADAGmpZm+ykiwxsaW1pdGF1dGhjaGcAAAAALWsDp4sIbGlua2F1dGgAADCbbht815YLbXZmcnNhdmluZ3MAADCbbhtM85YLbXZ0b3NhdmluZ3MAAECemiJkuJoKbmV3YWNjb3VudAAAAAAAIhrPpAdvbmJsb2NrAAAAAODSe9WkB29uZXJyb3IAAAAAoOqrOK0HcG93ZXJ1cAAAkOqq6qs4rQtwb3dlcnVwZXhlYwAAAAAApKmXugZyZWZ1bmQAAK5COtFbmboLcmVncHJvZHVjZXIAIK5COtFbmboMcmVncHJvZHVjZXIyAAAAAL7TW5m6CHJlZ3Byb3h5AAAAAEBXlKe6B3JlbnRjcHUAAAAAIKuZp7oHcmVudG5ldAAAAAAAqa66ugdyZXhleGVjAACuQjrRW7e8C3JtdnByb2R1Y2VyAAAAAECaG6PCB3NlbGxyYW0AAAAAoKsbo8IHc2VsbHJleAAAAAAAuGOywgZzZXRhYmkAAICuKCNkssIKc2V0YWNjdGNwdQAAQFYzI2SywgpzZXRhY2N0bmV0AACANDcjZLLCCnNldGFjY3RyYW0AAADOTrpossIKc2V0YWxpbWl0cwAAAABAJYqywgdzZXRjb2RlADCpyyau6bLCDHNldGluZmxhdGlvbgAAAMDSXFOzwglzZXRwYXJhbXMAAAAAYLtbs8IHc2V0cHJpdgAAAAAASHOzwgZzZXRyYW0AAIDK5kpzs8IKc2V0cmFtcmF0ZQAAAAAAdHWzwgZzZXRyZXgAwI/Khqmo0tQMdW5kZWxlZ2F0ZWJ3AABAy9rA6eLUCnVubGlua2F1dGgAAABI9Fam7tQJdW5yZWdwcm9kANDVpVlBk/HUDHVuc3Rha2V0b3JleAAAQMvaqGxS1Qp1cGRhdGVhdXRoAAAA6OqqbFLVCXVwZGF0ZXJleAAwqcNuq5tT1Qx1cGR0cmV2aXNpb24AcBXSid6qMt0Mdm90ZXByb2R1Y2VyAACAyiZVrTLdCnZvdGV1cGRhdGUAAAAAgC0kseEHd2FzbWNmZwAAAADc3NSy4wh3aXRoZHJhdwAaAAAAoGHT3DEDaTY0AAAIYWJpX2hhc2gAAE5TL3WTOwNpNjQAAApiaWRfcmVmdW5kAACgazqIaDwDaTY0AAARYmxvY2tfaW5mb19yZWNvcmQAAABgGhp1RQNpNjQAAAhyZXhfbG9hbgAAACBNc6JKA2k2NAAAE2RlbGVnYXRlZF9iYW5kd2lkdGgAAAAARHNoZANpNjQAABJlb3Npb19nbG9iYWxfc3RhdGUAAABARHNoZANpNjQAABNlb3Npb19nbG9iYWxfc3RhdGUyAAAAYERzaGQDaTY0AAATZW9zaW9fZ2xvYmFsX3N0YXRlMwAAAIBEc2hkA2k2NAAAE2Vvc2lvX2dsb2JhbF9zdGF0ZTQAAAA4uaOkmQNpNjQAAAhuYW1lX2JpZAAAAGAaGrOaA2k2NAAACHJleF9sb2FuAK5Kl4KqOa0DaTY0AAANcG93ZXJ1cF9vcmRlcgBUNhmDqjmtA2k2NAAADXBvd2VydXBfc3RhdGUAAMBXIZ3orQNpNjQAAA1wcm9kdWNlcl9pbmZvAIDAVyGd6K0DaTY0AAAOcHJvZHVjZXJfaW5mbzIAAMgKXiOluQNpNjQAAA5leGNoYW5nZV9zdGF0ZQAAAACnqZe6A2k2NAAADnJlZnVuZF9yZXF1ZXN0AADOCiJ9sroDaTY0AAAScmV4X3JldHVybl9idWNrZXRzAAAAAERzuroDaTY0AAALcmV4X2JhbGFuY2UAAAAgTb26ugNpNjQAAAhyZXhfZnVuZAAAACBSWru6A2k2NAAACHJleF9wb29sAAAASittu7oDaTY0AAAJcmV4X29yZGVyAECktGZ1u7oDaTY0AAAPcmV4X3JldHVybl9wb29sAAAAAKt7FdYDaTY0AAAOdXNlcl9yZXNvdXJjZXMAAAAA4Ksy3QNpNjQAAAp2b3Rlcl9pbmZvwBpqWZvspIsDaTY0AAARbGltaXRfYXV0aF9jaGFuZ2UAAAABInZhcmlhbnRfYmxvY2tfc2lnbmluZ19hdXRob3JpdHlfdjABGmJsb2NrX3NpZ25pbmdfYXV0aG9yaXR5X3Yw=" + }, + "text": "{\"account_name\":\"eosio\",\"code_hash\":\"6b93a5f220b03a37e98298010aa8562a028f484f1775c9d14512eda7f5498c18\",\"abi_hash\":\"61788bc26da987e1aa17600bc8327949146a5700bfbcbfb3cec4213b4120b3cd\",\"abi\":\"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\"}" +} \ No newline at end of file diff --git a/test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json b/test/data/55af4bbf54779cc94867d7eb559e69cb0cd62238.json similarity index 69% rename from test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json rename to test/data/55af4bbf54779cc94867d7eb559e69cb0cd62238.json index e34b15f..9c0fc9c 100644 --- a/test/data/c311e7695d5c028152f877e9d67b3b8a570ed634.json +++ b/test/data/55af4bbf54779cc94867d7eb559e69cb0cd62238.json @@ -1,14 +1,10 @@ { - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "489", - "content-type": "application/json", - "date": "Thu, 31 Aug 2023 06:13:20 GMT", - "server": "nginx", - "x-cached": "MISS" + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_account", + "params": { + "method": "POST", + "body": "{\"account_name\":\"nonexistent\"}" + } }, "status": 500, "json": { @@ -22,11 +18,11 @@ { "message": "unknown key (boost::tuples::tuple): (0 nonexistent)", "file": "http_plugin.cpp", - "line_number": 519, + "line_number": 954, "method": "handle_exception" } ] } }, - "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":0,\"name\":\"exception\",\"what\":\"unspecified\",\"details\":[{\"message\":\"unknown key (boost::tuples::tuple): (0 nonexistent)\",\"file\":\"http_plugin.cpp\",\"line_number\":519,\"method\":\"handle_exception\"}]}}" + "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":0,\"name\":\"exception\",\"what\":\"unspecified\",\"details\":[{\"message\":\"unknown key (boost::tuples::tuple): (0 nonexistent)\",\"file\":\"http_plugin.cpp\",\"line_number\":954,\"method\":\"handle_exception\"}]}}" } \ No newline at end of file diff --git a/test/data/600d407d0997a4756acbc477220ba0de7064a8b5.json b/test/data/600d407d0997a4756acbc477220ba0de7064a8b5.json new file mode 100644 index 0000000..f51deb5 --- /dev/null +++ b/test/data/600d407d0997a4756acbc477220ba0de7064a8b5.json @@ -0,0 +1,14 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_currency_balance", + "params": { + "method": "POST", + "body": "{\"account\":\"wharfkit1133\",\"code\":\"eosio.token\",\"symbol\":\"EOS\"}" + } + }, + "status": 200, + "json": [ + "5.0000 EOS" + ], + "text": "[\"5.0000 EOS\"]" +} \ No newline at end of file diff --git a/test/data/641e5bfbeee9679a87c18073de5a96be7fe56ebe.json b/test/data/641e5bfbeee9679a87c18073de5a96be7fe56ebe.json new file mode 100644 index 0000000..626e380 --- /dev/null +++ b/test/data/641e5bfbeee9679a87c18073de5a96be7fe56ebe.json @@ -0,0 +1,100 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_account", + "params": { + "method": "POST", + "body": "{\"account_name\":\"teamgreymass\"}" + } + }, + "status": 200, + "json": { + "account_name": "teamgreymass", + "head_block_num": 95886407, + "head_block_time": "2023-09-03T00:01:39.000", + "privileged": false, + "last_code_update": "1970-01-01T00:00:00.000", + "created": "2022-03-09T18:59:11.000", + "core_liquid_balance": "14.7176 EOS", + "ram_quota": 5495, + "net_weight": 10000, + "cpu_weight": 10000, + "net_limit": { + "used": 0, + "available": 15416, + "max": 15416 + }, + "cpu_limit": { + "used": 0, + "available": 2865, + "max": 2865 + }, + "ram_usage": 3446, + "permissions": [ + { + "perm_name": "active", + "parent": "owner", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS5w2WYgoiFT41Ad3Ax1ZkD47D4qriGaRXRsXmkFuC1hKwjbrXe3", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [] + }, + { + "perm_name": "owner", + "parent": "", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS5w2WYgoiFT41Ad3Ax1ZkD47D4qriGaRXRsXmkFuC1hKwjbrXe3", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [] + } + ], + "total_resources": { + "owner": "teamgreymass", + "net_weight": "1.0000 EOS", + "cpu_weight": "1.0000 EOS", + "ram_bytes": 4095 + }, + "self_delegated_bandwidth": { + "from": "teamgreymass", + "to": "teamgreymass", + "net_weight": "1.0000 EOS", + "cpu_weight": "1.0000 EOS" + }, + "refund_request": null, + "voter_info": { + "owner": "teamgreymass", + "proxy": "", + "producers": [], + "staked": 20000, + "last_vote_weight": "0.00000000000000000", + "proxied_vote_weight": "0.00000000000000000", + "is_proxy": 0, + "flags1": 0, + "reserved2": 0, + "reserved3": "0 " + }, + "rex_info": null, + "subjective_cpu_bill_limit": { + "used": 0, + "available": 0, + "max": 0 + }, + "eosio_any_linked_actions": [] + }, + "text": "{\"account_name\":\"teamgreymass\",\"head_block_num\":95886407,\"head_block_time\":\"2023-09-03T00:01:39.000\",\"privileged\":false,\"last_code_update\":\"1970-01-01T00:00:00.000\",\"created\":\"2022-03-09T18:59:11.000\",\"core_liquid_balance\":\"14.7176 EOS\",\"ram_quota\":5495,\"net_weight\":10000,\"cpu_weight\":10000,\"net_limit\":{\"used\":0,\"available\":15416,\"max\":15416},\"cpu_limit\":{\"used\":0,\"available\":2865,\"max\":2865},\"ram_usage\":3446,\"permissions\":[{\"perm_name\":\"active\",\"parent\":\"owner\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS5w2WYgoiFT41Ad3Ax1ZkD47D4qriGaRXRsXmkFuC1hKwjbrXe3\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"owner\",\"parent\":\"\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS5w2WYgoiFT41Ad3Ax1ZkD47D4qriGaRXRsXmkFuC1hKwjbrXe3\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]}],\"total_resources\":{\"owner\":\"teamgreymass\",\"net_weight\":\"1.0000 EOS\",\"cpu_weight\":\"1.0000 EOS\",\"ram_bytes\":4095},\"self_delegated_bandwidth\":{\"from\":\"teamgreymass\",\"to\":\"teamgreymass\",\"net_weight\":\"1.0000 EOS\",\"cpu_weight\":\"1.0000 EOS\"},\"refund_request\":null,\"voter_info\":{\"owner\":\"teamgreymass\",\"proxy\":\"\",\"producers\":[],\"staked\":20000,\"last_vote_weight\":\"0.00000000000000000\",\"proxied_vote_weight\":\"0.00000000000000000\",\"is_proxy\":0,\"flags1\":0,\"reserved2\":0,\"reserved3\":\"0 \"},\"rex_info\":null,\"subjective_cpu_bill_limit\":{\"used\":0,\"available\":0,\"max\":0},\"eosio_any_linked_actions\":[]}" +} \ No newline at end of file diff --git a/test/data/789d7d35b2defaefba811b35b2d09c2a5a7b6d67.json b/test/data/789d7d35b2defaefba811b35b2d09c2a5a7b6d67.json new file mode 100644 index 0000000..84bd84b --- /dev/null +++ b/test/data/789d7d35b2defaefba811b35b2d09c2a5a7b6d67.json @@ -0,0 +1,14 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_currency_balance", + "params": { + "method": "POST", + "body": "{\"account\":\"wharfkit1133\",\"code\":\"eosio.token\"}" + } + }, + "status": 200, + "json": [ + "5.0000 EOS" + ], + "text": "[\"5.0000 EOS\"]" +} \ No newline at end of file diff --git a/test/data/78f7b1aaa2f758958d774220fd09a76171b37df9.json b/test/data/78f7b1aaa2f758958d774220fd09a76171b37df9.json new file mode 100644 index 0000000..7296a15 --- /dev/null +++ b/test/data/78f7b1aaa2f758958d774220fd09a76171b37df9.json @@ -0,0 +1,97 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/send_transaction", + "params": { + "method": "POST", + "body": "{\"signatures\":[\"SIG_K1_Kde6NAnnGGJTWHycDj14WLojzJePjSKpVJF4SpEzDEZ2MEidNyhTjzkQjh3nZvma9cHh3fPxG6wFhfDojXsT5oQtmqN5LR\"],\"compression\":0,\"packed_context_free_data\":\"00\",\"packed_trx\":\"57cdf364f01af5e82a5800000000010000000000ea30550040cbdaa86c52d501304608d9c1754de300000000a8ed32324b304608d9c1754de300000019ab9cddd400000000a8ed323201000000010002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf01000000000000000000000000\"}" + } + }, + "status": 202, + "json": { + "transaction_id": "859ffba3fe71cbb5c45bfbdc19cf8e08e69d209d07ad6d36118f539a960fa7cb", + "processed": { + "id": "859ffba3fe71cbb5c45bfbdc19cf8e08e69d209d07ad6d36118f539a960fa7cb", + "block_num": 95886402, + "block_time": "2023-09-03T00:01:36.500", + "producer_block_id": null, + "receipt": { + "status": "executed", + "cpu_usage_us": 179, + "net_usage_words": 21 + }, + "elapsed": 179, + "net_usage": 168, + "scheduled": false, + "action_traces": [ + { + "action_ordinal": 1, + "creator_action_ordinal": 0, + "closest_unnotified_ancestor_action_ordinal": 0, + "receipt": { + "receiver": "eosio", + "act_digest": "0274f4685922f32b188ad3507c2fde9c83b010f912767be505501ad1a1c367e1", + "global_sequence": 128190447, + "recv_sequence": 95947351, + "auth_sequence": [ + [ + "wharfkit1133", + 27 + ] + ], + "code_sequence": 4, + "abi_sequence": 4 + }, + "receiver": "eosio", + "act": { + "account": "eosio", + "name": "updateauth", + "authorization": [ + { + "actor": "wharfkit1133", + "permission": "active" + } + ], + "data": { + "account": "wharfkit1133", + "permission": "unittest", + "parent": "active", + "auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "authorized_by": "" + }, + "hex_data": "304608d9c1754de300000019ab9cddd400000000a8ed323201000000010002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf010000000000000000000000" + }, + "context_free": false, + "elapsed": 57, + "console": "", + "trx_id": "859ffba3fe71cbb5c45bfbdc19cf8e08e69d209d07ad6d36118f539a960fa7cb", + "block_num": 95886402, + "block_time": "2023-09-03T00:01:36.500", + "producer_block_id": null, + "account_ram_deltas": [ + { + "account": "wharfkit1133", + "delta": 338 + } + ], + "except": null, + "error_code": null, + "return_value_hex_data": "" + } + ], + "account_ram_delta": null, + "except": null, + "error_code": null + } + }, + "text": "{\"transaction_id\":\"859ffba3fe71cbb5c45bfbdc19cf8e08e69d209d07ad6d36118f539a960fa7cb\",\"processed\":{\"id\":\"859ffba3fe71cbb5c45bfbdc19cf8e08e69d209d07ad6d36118f539a960fa7cb\",\"block_num\":95886402,\"block_time\":\"2023-09-03T00:01:36.500\",\"producer_block_id\":null,\"receipt\":{\"status\":\"executed\",\"cpu_usage_us\":179,\"net_usage_words\":21},\"elapsed\":179,\"net_usage\":168,\"scheduled\":false,\"action_traces\":[{\"action_ordinal\":1,\"creator_action_ordinal\":0,\"closest_unnotified_ancestor_action_ordinal\":0,\"receipt\":{\"receiver\":\"eosio\",\"act_digest\":\"0274f4685922f32b188ad3507c2fde9c83b010f912767be505501ad1a1c367e1\",\"global_sequence\":128190447,\"recv_sequence\":95947351,\"auth_sequence\":[[\"wharfkit1133\",27]],\"code_sequence\":4,\"abi_sequence\":4},\"receiver\":\"eosio\",\"act\":{\"account\":\"eosio\",\"name\":\"updateauth\",\"authorization\":[{\"actor\":\"wharfkit1133\",\"permission\":\"active\"}],\"data\":{\"account\":\"wharfkit1133\",\"permission\":\"unittest\",\"parent\":\"active\",\"auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"authorized_by\":\"\"},\"hex_data\":\"304608d9c1754de300000019ab9cddd400000000a8ed323201000000010002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf010000000000000000000000\"},\"context_free\":false,\"elapsed\":57,\"console\":\"\",\"trx_id\":\"859ffba3fe71cbb5c45bfbdc19cf8e08e69d209d07ad6d36118f539a960fa7cb\",\"block_num\":95886402,\"block_time\":\"2023-09-03T00:01:36.500\",\"producer_block_id\":null,\"account_ram_deltas\":[{\"account\":\"wharfkit1133\",\"delta\":338}],\"except\":null,\"error_code\":null,\"return_value_hex_data\":\"\"}],\"account_ram_delta\":null,\"except\":null,\"error_code\":null}}" +} \ No newline at end of file diff --git a/test/data/7bb57e23b35a734db0875477bf749505aa9a3c0a.json b/test/data/7bb57e23b35a734db0875477bf749505aa9a3c0a.json new file mode 100644 index 0000000..00b9a7d --- /dev/null +++ b/test/data/7bb57e23b35a734db0875477bf749505aa9a3c0a.json @@ -0,0 +1,105 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_account", + "params": { + "method": "POST", + "body": "{\"account_name\":\"wharfkit1111\"}" + } + }, + "status": 200, + "json": { + "account_name": "wharfkit1111", + "head_block_num": 95886408, + "head_block_time": "2023-09-03T00:01:39.500", + "privileged": false, + "last_code_update": "1970-01-01T00:00:00.000", + "created": "2022-12-07T01:11:58.500", + "core_liquid_balance": "996.6302 EOS", + "ram_quota": 13477, + "net_weight": 1010000, + "cpu_weight": 5010000, + "net_limit": { + "used": 153, + "available": 1556955, + "max": 1557108 + }, + "cpu_limit": { + "used": 73, + "available": 1435568, + "max": 1435641 + }, + "ram_usage": 3606, + "permissions": [ + { + "perm_name": "active", + "parent": "owner", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6VFW9DYN", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [] + }, + { + "perm_name": "owner", + "parent": "", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6VFW9DYN", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [] + }, + { + "perm_name": "test", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "eosio.token", + "action": "transfer" + } + ] + } + ], + "total_resources": { + "owner": "wharfkit1111", + "net_weight": "101.0000 EOS", + "cpu_weight": "501.0000 EOS", + "ram_bytes": 12077 + }, + "self_delegated_bandwidth": null, + "refund_request": null, + "voter_info": null, + "rex_info": null, + "subjective_cpu_bill_limit": { + "used": 0, + "available": 0, + "max": 0 + }, + "eosio_any_linked_actions": [] + }, + "text": "{\"account_name\":\"wharfkit1111\",\"head_block_num\":95886408,\"head_block_time\":\"2023-09-03T00:01:39.500\",\"privileged\":false,\"last_code_update\":\"1970-01-01T00:00:00.000\",\"created\":\"2022-12-07T01:11:58.500\",\"core_liquid_balance\":\"996.6302 EOS\",\"ram_quota\":13477,\"net_weight\":1010000,\"cpu_weight\":5010000,\"net_limit\":{\"used\":153,\"available\":1556955,\"max\":1557108},\"cpu_limit\":{\"used\":73,\"available\":1435568,\"max\":1435641},\"ram_usage\":3606,\"permissions\":[{\"perm_name\":\"active\",\"parent\":\"owner\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6VFW9DYN\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"owner\",\"parent\":\"\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6VFW9DYN\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"test\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio.token\",\"action\":\"transfer\"}]}],\"total_resources\":{\"owner\":\"wharfkit1111\",\"net_weight\":\"101.0000 EOS\",\"cpu_weight\":\"501.0000 EOS\",\"ram_bytes\":12077},\"self_delegated_bandwidth\":null,\"refund_request\":null,\"voter_info\":null,\"rex_info\":null,\"subjective_cpu_bill_limit\":{\"used\":0,\"available\":0,\"max\":0},\"eosio_any_linked_actions\":[]}" +} \ No newline at end of file diff --git a/test/data/8745e40a973fe2860ad803d3c20a76541d3b9392.json b/test/data/8745e40a973fe2860ad803d3c20a76541d3b9392.json deleted file mode 100644 index be62b02..0000000 --- a/test/data/8745e40a973fe2860ad803d3c20a76541d3b9392.json +++ /dev/null @@ -1,277 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "3602", - "content-type": "application/json", - "date": "Thu, 31 Aug 2023 05:54:24 GMT", - "host": "eos.greymass.com", - "server": "nginx", - "x-cached": "EXPIRED" - }, - "status": 200, - "json": { - "account_name": "teamgreymass", - "head_block_num": 328546110, - "head_block_time": "2023-08-31T05:54:25.000", - "privileged": false, - "last_code_update": "1970-01-01T00:00:00.000", - "created": "2018-06-10T13:04:15.000", - "core_liquid_balance": "4968.2348 EOS", - "ram_quota": 67988, - "net_weight": 4496537, - "cpu_weight": "15730337072", - "net_limit": { - "used": 247633, - "available": 8225481, - "max": 8473114, - "last_usage_update_time": "2023-08-31T05:54:00.000", - "current_used": 247561 - }, - "cpu_limit": { - "used": 1018013, - "available": 400021, - "max": 1418034, - "last_usage_update_time": "2023-08-31T05:54:00.000", - "current_used": 1017718 - }, - "ram_usage": 18101, - "permissions": [ - { - "perm_name": "active", - "parent": "owner", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS6gqJ7sdPgjHLFLtks9cRPs5qYHa9U3CwK4P2JasTLWKQ9kXZK1", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [] - }, - { - "perm_name": "claim", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS6DLD9HxMcwn73U41jjdGsNe9vDFRKB26um6qTAqrtYcJFtED4C", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio", - "action": "claimrewards" - } - ] - }, - { - "perm_name": "decentium", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS7knG7M5TUEdRv1bkVjTPddVoDQnwS7oEZXAgFk3A4hhocA3eJf", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "decentiumorg" - } - ] - }, - { - "perm_name": "killswitch", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS7CjC7GL71msPzAuAzd2WwiBEAzTcPL47ACrjSuiNmnnGGufYSn", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio", - "action": "unregprod" - } - ] - }, - { - "perm_name": "oracle", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS88VqmDmJJ9S23eNqdeWYf2zySxv3ckQrWBKy7EvVRCUuhSU4f3", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "delphioracle", - "action": "write" - } - ] - }, - { - "perm_name": "owner", - "parent": "", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS8QzGtCea2thiqcTVeXGdyRZpdKYptQznbcWSMj73FD5RgwKN82", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [] - }, - { - "perm_name": "producerjson", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS5JCEciUdfXnQmTyj85T98bXTAZZ1g7Nmajseu7ZWB8DrDa6Etp", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "producerjson", - "action": "set" - } - ] - }, - { - "perm_name": "transfer", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS7qZ8nnmn6KBnjQL4oukyZFWCj8DmC9nJE2nkAYAZbwgKhMu8cW", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio.token", - "action": "transfer" - } - ] - }, - { - "perm_name": "vote", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS65NrHPVXaV4voxepQREmYCmnMJm4tAWdxPaK46CbUN1rrVmRzg", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio", - "action": "voteproducer" - } - ] - }, - { - "perm_name": "voting", - "parent": "active", - "required_auth": { - "threshold": 1, - "keys": [ - { - "key": "EOS7pn6P5FftyNAKRfx9VcUzBFMvC4UitNbnoKbfxNe8SShELo2it", - "weight": 1 - } - ], - "accounts": [], - "waits": [] - }, - "linked_actions": [ - { - "account": "eosio.forum", - "action": "vote" - }, - { - "account": "eosio.forum", - "action": "unvote" - } - ] - } - ], - "total_resources": { - "owner": "teamgreymass", - "net_weight": "449.6537 EOS", - "cpu_weight": "1573033.7072 EOS", - "ram_bytes": 66588 - }, - "self_delegated_bandwidth": null, - "refund_request": null, - "voter_info": { - "owner": "teamgreymass", - "proxy": "greymassvote", - "producers": [], - "staked": 100202, - "last_vote_weight": "863265464502.93908691406250000", - "proxied_vote_weight": "0.00000000000000000", - "is_proxy": 0, - "flags1": 0, - "reserved2": 0, - "reserved3": "0.0000 EOS" - }, - "rex_info": null, - "subjective_cpu_bill_limit": { - "used": 0, - "available": 0, - "max": 0, - "last_usage_update_time": "2000-01-01T00:00:00.000", - "current_used": 0 - }, - "eosio_any_linked_actions": [] - }, - "text": "{\"account_name\":\"teamgreymass\",\"head_block_num\":328546110,\"head_block_time\":\"2023-08-31T05:54:25.000\",\"privileged\":false,\"last_code_update\":\"1970-01-01T00:00:00.000\",\"created\":\"2018-06-10T13:04:15.000\",\"core_liquid_balance\":\"4968.2348 EOS\",\"ram_quota\":67988,\"net_weight\":4496537,\"cpu_weight\":\"15730337072\",\"net_limit\":{\"used\":247633,\"available\":8225481,\"max\":8473114,\"last_usage_update_time\":\"2023-08-31T05:54:00.000\",\"current_used\":247561},\"cpu_limit\":{\"used\":1018013,\"available\":400021,\"max\":1418034,\"last_usage_update_time\":\"2023-08-31T05:54:00.000\",\"current_used\":1017718},\"ram_usage\":18101,\"permissions\":[{\"perm_name\":\"active\",\"parent\":\"owner\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6gqJ7sdPgjHLFLtks9cRPs5qYHa9U3CwK4P2JasTLWKQ9kXZK1\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"claim\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6DLD9HxMcwn73U41jjdGsNe9vDFRKB26um6qTAqrtYcJFtED4C\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio\",\"action\":\"claimrewards\"}]},{\"perm_name\":\"decentium\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7knG7M5TUEdRv1bkVjTPddVoDQnwS7oEZXAgFk3A4hhocA3eJf\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"decentiumorg\"}]},{\"perm_name\":\"killswitch\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7CjC7GL71msPzAuAzd2WwiBEAzTcPL47ACrjSuiNmnnGGufYSn\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio\",\"action\":\"unregprod\"}]},{\"perm_name\":\"oracle\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS88VqmDmJJ9S23eNqdeWYf2zySxv3ckQrWBKy7EvVRCUuhSU4f3\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"delphioracle\",\"action\":\"write\"}]},{\"perm_name\":\"owner\",\"parent\":\"\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS8QzGtCea2thiqcTVeXGdyRZpdKYptQznbcWSMj73FD5RgwKN82\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"producerjson\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS5JCEciUdfXnQmTyj85T98bXTAZZ1g7Nmajseu7ZWB8DrDa6Etp\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"producerjson\",\"action\":\"set\"}]},{\"perm_name\":\"transfer\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7qZ8nnmn6KBnjQL4oukyZFWCj8DmC9nJE2nkAYAZbwgKhMu8cW\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio.token\",\"action\":\"transfer\"}]},{\"perm_name\":\"vote\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS65NrHPVXaV4voxepQREmYCmnMJm4tAWdxPaK46CbUN1rrVmRzg\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio\",\"action\":\"voteproducer\"}]},{\"perm_name\":\"voting\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS7pn6P5FftyNAKRfx9VcUzBFMvC4UitNbnoKbfxNe8SShELo2it\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio.forum\",\"action\":\"vote\"},{\"account\":\"eosio.forum\",\"action\":\"unvote\"}]}],\"total_resources\":{\"owner\":\"teamgreymass\",\"net_weight\":\"449.6537 EOS\",\"cpu_weight\":\"1573033.7072 EOS\",\"ram_bytes\":66588},\"self_delegated_bandwidth\":null,\"refund_request\":null,\"voter_info\":{\"owner\":\"teamgreymass\",\"proxy\":\"greymassvote\",\"producers\":[],\"staked\":100202,\"last_vote_weight\":\"863265464502.93908691406250000\",\"proxied_vote_weight\":\"0.00000000000000000\",\"is_proxy\":0,\"flags1\":0,\"reserved2\":0,\"reserved3\":\"0.0000 EOS\"},\"rex_info\":null,\"subjective_cpu_bill_limit\":{\"used\":0,\"available\":0,\"max\":0,\"last_usage_update_time\":\"2000-01-01T00:00:00.000\",\"current_used\":0},\"eosio_any_linked_actions\":[]}" -} \ No newline at end of file diff --git a/test/data/aaa72e8c80195f8444c725e12d56dd32bd74fc6e.json b/test/data/aaa72e8c80195f8444c725e12d56dd32bd74fc6e.json new file mode 100644 index 0000000..f58cabc --- /dev/null +++ b/test/data/aaa72e8c80195f8444c725e12d56dd32bd74fc6e.json @@ -0,0 +1,105 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_account", + "params": { + "method": "POST", + "body": "{\"account_name\":\"wharfkit1133\"}" + } + }, + "status": 200, + "json": { + "account_name": "wharfkit1133", + "head_block_num": 95886398, + "head_block_time": "2023-09-03T00:01:34.500", + "privileged": false, + "last_code_update": "1970-01-01T00:00:00.000", + "created": "2023-09-02T23:23:15.000", + "core_liquid_balance": "5.0000 EOS", + "ram_quota": 13479, + "net_weight": 1010000, + "cpu_weight": 1010000, + "net_limit": { + "used": 3996, + "available": 1553112, + "max": 1557108 + }, + "cpu_limit": { + "used": 5396, + "available": 284024, + "max": 289420 + }, + "ram_usage": 3478, + "permissions": [ + { + "perm_name": "active", + "parent": "owner", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [] + }, + { + "perm_name": "owner", + "parent": "", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6VFW9DYN", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [] + }, + { + "perm_name": "test", + "parent": "active", + "required_auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "linked_actions": [ + { + "account": "eosio.token", + "action": "transfer" + } + ] + } + ], + "total_resources": { + "owner": "wharfkit1133", + "net_weight": "101.0000 EOS", + "cpu_weight": "101.0000 EOS", + "ram_bytes": 12079 + }, + "self_delegated_bandwidth": null, + "refund_request": null, + "voter_info": null, + "rex_info": null, + "subjective_cpu_bill_limit": { + "used": 0, + "available": 0, + "max": 0 + }, + "eosio_any_linked_actions": [] + }, + "text": "{\"account_name\":\"wharfkit1133\",\"head_block_num\":95886398,\"head_block_time\":\"2023-09-03T00:01:34.500\",\"privileged\":false,\"last_code_update\":\"1970-01-01T00:00:00.000\",\"created\":\"2023-09-02T23:23:15.000\",\"core_liquid_balance\":\"5.0000 EOS\",\"ram_quota\":13479,\"net_weight\":1010000,\"cpu_weight\":1010000,\"net_limit\":{\"used\":3996,\"available\":1553112,\"max\":1557108},\"cpu_limit\":{\"used\":5396,\"available\":284024,\"max\":289420},\"ram_usage\":3478,\"permissions\":[{\"perm_name\":\"active\",\"parent\":\"owner\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"owner\",\"parent\":\"\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6VFW9DYN\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[]},{\"perm_name\":\"test\",\"parent\":\"active\",\"required_auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"linked_actions\":[{\"account\":\"eosio.token\",\"action\":\"transfer\"}]}],\"total_resources\":{\"owner\":\"wharfkit1133\",\"net_weight\":\"101.0000 EOS\",\"cpu_weight\":\"101.0000 EOS\",\"ram_bytes\":12079},\"self_delegated_bandwidth\":null,\"refund_request\":null,\"voter_info\":null,\"rex_info\":null,\"subjective_cpu_bill_limit\":{\"used\":0,\"available\":0,\"max\":0},\"eosio_any_linked_actions\":[]}" +} \ No newline at end of file diff --git a/test/data/b5616398369b9af478c9ece8462aad7ee1fe7fb7.json b/test/data/b5616398369b9af478c9ece8462aad7ee1fe7fb7.json new file mode 100644 index 0000000..0cfbebd --- /dev/null +++ b/test/data/b5616398369b9af478c9ece8462aad7ee1fe7fb7.json @@ -0,0 +1,101 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/send_transaction", + "params": { + "method": "POST", + "body": "{\"signatures\":[\"SIG_K1_KhEYRyq47MbxxsnZy9w74xVaNHyD2gFFPdnHvi7gnhXDFUKb2JQVrYzudjodaWJUgHXmXFrS9S1AyJM89JcYhKDWUpBNSu\"],\"compression\":0,\"packed_context_free_data\":\"00\",\"packed_trx\":\"57cdf364f01af5e82a5800000000010000000000ea30550040cbdaa86c52d501304608d9c1754de300000000a8ed32326f304608d9c1754de300000000a8ed32320000000080ab26a701000000020002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf01000002c9c679952fe122a7a2982e104bb4ced99e165226acb76318f367c0dd992a0d5501000000000000000000000000\"}" + } + }, + "status": 202, + "json": { + "transaction_id": "f51dccebad945d76bcd1d57d7160cd33bcd72d2f8bfb5c892bee265a07e5b343", + "processed": { + "id": "f51dccebad945d76bcd1d57d7160cd33bcd72d2f8bfb5c892bee265a07e5b343", + "block_num": 95886403, + "block_time": "2023-09-03T00:01:37.000", + "producer_block_id": null, + "receipt": { + "status": "executed", + "cpu_usage_us": 193, + "net_usage_words": 26 + }, + "elapsed": 193, + "net_usage": 208, + "scheduled": false, + "action_traces": [ + { + "action_ordinal": 1, + "creator_action_ordinal": 0, + "closest_unnotified_ancestor_action_ordinal": 0, + "receipt": { + "receiver": "eosio", + "act_digest": "212955b8945f634a0f98b8fad6eea1e9ecf2b8ef0ba910b1d5a33d818ce3cebd", + "global_sequence": 128190449, + "recv_sequence": 95947353, + "auth_sequence": [ + [ + "wharfkit1133", + 28 + ] + ], + "code_sequence": 4, + "abi_sequence": 4 + }, + "receiver": "eosio", + "act": { + "account": "eosio", + "name": "updateauth", + "authorization": [ + { + "actor": "wharfkit1133", + "permission": "active" + } + ], + "data": { + "account": "wharfkit1133", + "permission": "active", + "parent": "owner", + "auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV", + "weight": 1 + }, + { + "key": "EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "authorized_by": "" + }, + "hex_data": "304608d9c1754de300000000a8ed32320000000080ab26a701000000020002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf01000002c9c679952fe122a7a2982e104bb4ced99e165226acb76318f367c0dd992a0d55010000000000000000000000" + }, + "context_free": false, + "elapsed": 62, + "console": "", + "trx_id": "f51dccebad945d76bcd1d57d7160cd33bcd72d2f8bfb5c892bee265a07e5b343", + "block_num": 95886403, + "block_time": "2023-09-03T00:01:37.000", + "producer_block_id": null, + "account_ram_deltas": [ + { + "account": "wharfkit1133", + "delta": 50 + } + ], + "except": null, + "error_code": null, + "return_value_hex_data": "" + } + ], + "account_ram_delta": null, + "except": null, + "error_code": null + } + }, + "text": "{\"transaction_id\":\"f51dccebad945d76bcd1d57d7160cd33bcd72d2f8bfb5c892bee265a07e5b343\",\"processed\":{\"id\":\"f51dccebad945d76bcd1d57d7160cd33bcd72d2f8bfb5c892bee265a07e5b343\",\"block_num\":95886403,\"block_time\":\"2023-09-03T00:01:37.000\",\"producer_block_id\":null,\"receipt\":{\"status\":\"executed\",\"cpu_usage_us\":193,\"net_usage_words\":26},\"elapsed\":193,\"net_usage\":208,\"scheduled\":false,\"action_traces\":[{\"action_ordinal\":1,\"creator_action_ordinal\":0,\"closest_unnotified_ancestor_action_ordinal\":0,\"receipt\":{\"receiver\":\"eosio\",\"act_digest\":\"212955b8945f634a0f98b8fad6eea1e9ecf2b8ef0ba910b1d5a33d818ce3cebd\",\"global_sequence\":128190449,\"recv_sequence\":95947353,\"auth_sequence\":[[\"wharfkit1133\",28]],\"code_sequence\":4,\"abi_sequence\":4},\"receiver\":\"eosio\",\"act\":{\"account\":\"eosio\",\"name\":\"updateauth\",\"authorization\":[{\"actor\":\"wharfkit1133\",\"permission\":\"active\"}],\"data\":{\"account\":\"wharfkit1133\",\"permission\":\"active\",\"parent\":\"owner\",\"auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV\",\"weight\":1},{\"key\":\"EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"authorized_by\":\"\"},\"hex_data\":\"304608d9c1754de300000000a8ed32320000000080ab26a701000000020002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf01000002c9c679952fe122a7a2982e104bb4ced99e165226acb76318f367c0dd992a0d55010000000000000000000000\"},\"context_free\":false,\"elapsed\":62,\"console\":\"\",\"trx_id\":\"f51dccebad945d76bcd1d57d7160cd33bcd72d2f8bfb5c892bee265a07e5b343\",\"block_num\":95886403,\"block_time\":\"2023-09-03T00:01:37.000\",\"producer_block_id\":null,\"account_ram_deltas\":[{\"account\":\"wharfkit1133\",\"delta\":50}],\"except\":null,\"error_code\":null,\"return_value_hex_data\":\"\"}],\"account_ram_delta\":null,\"except\":null,\"error_code\":null}}" +} \ No newline at end of file diff --git a/test/data/b5ae1f53ef4cf6544fe89a0deb7a7d1043f43149.json b/test/data/b5ae1f53ef4cf6544fe89a0deb7a7d1043f43149.json new file mode 100644 index 0000000..5467364 --- /dev/null +++ b/test/data/b5ae1f53ef4cf6544fe89a0deb7a7d1043f43149.json @@ -0,0 +1,32 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_info", + "params": { + "method": "POST" + } + }, + "status": 200, + "json": { + "server_version": "905c5cc9", + "chain_id": "73e4385a2708e6d7048834fbc1079f2fabb17b3c125b146af438971e90716c4d", + "head_block_num": 95886399, + "last_irreversible_block_num": 95886064, + "last_irreversible_block_id": "05b71af0b00b62c5f5e82a58ae5e9bac8d7f386c5a6e08d69fab71c38ef4b854", + "head_block_id": "05b71c3f60cdc58df06f76a5723e1dbf5c3cf3cd2b8453d734aee5ee089bf044", + "head_block_time": "2023-09-03T00:01:35.000", + "head_block_producer": "eosnationftw", + "virtual_block_cpu_limit": 200000000, + "virtual_block_net_limit": 1048576000, + "block_cpu_limit": 200000, + "block_net_limit": 1048576, + "server_version_string": "v3.1.3", + "fork_db_head_block_num": 95886399, + "fork_db_head_block_id": "05b71c3f60cdc58df06f76a5723e1dbf5c3cf3cd2b8453d734aee5ee089bf044", + "server_full_version_string": "v3.1.3-905c5cc900b4e88aed4ab6912009127bf9f4f140", + "total_cpu_weight": "120605081503422", + "total_net_weight": "117529275413365", + "earliest_available_block_num": 95706957, + "last_irreversible_block_time": "2023-09-02T23:58:47.500" + }, + "text": "{\"server_version\":\"905c5cc9\",\"chain_id\":\"73e4385a2708e6d7048834fbc1079f2fabb17b3c125b146af438971e90716c4d\",\"head_block_num\":95886399,\"last_irreversible_block_num\":95886064,\"last_irreversible_block_id\":\"05b71af0b00b62c5f5e82a58ae5e9bac8d7f386c5a6e08d69fab71c38ef4b854\",\"head_block_id\":\"05b71c3f60cdc58df06f76a5723e1dbf5c3cf3cd2b8453d734aee5ee089bf044\",\"head_block_time\":\"2023-09-03T00:01:35.000\",\"head_block_producer\":\"eosnationftw\",\"virtual_block_cpu_limit\":200000000,\"virtual_block_net_limit\":1048576000,\"block_cpu_limit\":200000,\"block_net_limit\":1048576,\"server_version_string\":\"v3.1.3\",\"fork_db_head_block_num\":95886399,\"fork_db_head_block_id\":\"05b71c3f60cdc58df06f76a5723e1dbf5c3cf3cd2b8453d734aee5ee089bf044\",\"server_full_version_string\":\"v3.1.3-905c5cc900b4e88aed4ab6912009127bf9f4f140\",\"total_cpu_weight\":\"120605081503422\",\"total_net_weight\":\"117529275413365\",\"earliest_available_block_num\":95706957,\"last_irreversible_block_time\":\"2023-09-02T23:58:47.500\"}" +} \ No newline at end of file diff --git a/test/data/c53d9d71a7787aac0e342e10f4be8f132415095f.json b/test/data/c53d9d71a7787aac0e342e10f4be8f132415095f.json deleted file mode 100644 index 63282cd..0000000 --- a/test/data/c53d9d71a7787aac0e342e10f4be8f132415095f.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "19", - "content-type": "application/json", - "date": "Thu, 31 Aug 2023 05:54:25 GMT", - "host": "eos.greymass.com", - "server": "nginx" - }, - "status": 200, - "json": [ - "1000.0000 BINGO" - ], - "text": "[\"1000.0000 BINGO\"]" -} \ No newline at end of file diff --git a/test/data/c6bc5d3be92c14699da438430c6cdc6d776b1692.json b/test/data/c6bc5d3be92c14699da438430c6cdc6d776b1692.json new file mode 100644 index 0000000..7488c1d --- /dev/null +++ b/test/data/c6bc5d3be92c14699da438430c6cdc6d776b1692.json @@ -0,0 +1,97 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/send_transaction", + "params": { + "method": "POST", + "body": "{\"signatures\":[\"SIG_K1_K8b5rHrrWdYsX3x4g5GRjcYpvT8JcYYQyCk3zw3Gq2PRGJFdGFdqgzqCfJDcmzy4Hdn4JZYKSB1udu4gbJQejTvCDJa7CL\"],\"compression\":0,\"packed_context_free_data\":\"00\",\"packed_trx\":\"57cdf364f01af5e82a5800000000010000000000ea30550040cbdaa86c52d501304608d9c1754de300000000a8ed32324b304608d9c1754de300000000a8ed32320000000080ab26a701000000010002c9c679952fe122a7a2982e104bb4ced99e165226acb76318f367c0dd992a0d5501000000000000000000000000\"}" + } + }, + "status": 202, + "json": { + "transaction_id": "0294f4e7e66c033b229cdb7c5ec4c6259a3aa0152c2a750728a307b27e8da6e2", + "processed": { + "id": "0294f4e7e66c033b229cdb7c5ec4c6259a3aa0152c2a750728a307b27e8da6e2", + "block_num": 95886404, + "block_time": "2023-09-03T00:01:37.500", + "producer_block_id": null, + "receipt": { + "status": "executed", + "cpu_usage_us": 219, + "net_usage_words": 21 + }, + "elapsed": 219, + "net_usage": 168, + "scheduled": false, + "action_traces": [ + { + "action_ordinal": 1, + "creator_action_ordinal": 0, + "closest_unnotified_ancestor_action_ordinal": 0, + "receipt": { + "receiver": "eosio", + "act_digest": "5d8239b83dcdbae9a7a29f2a5ed47b183e597d7dd16a911270c5c1749230299f", + "global_sequence": 128190450, + "recv_sequence": 95947354, + "auth_sequence": [ + [ + "wharfkit1133", + 28 + ] + ], + "code_sequence": 4, + "abi_sequence": 4 + }, + "receiver": "eosio", + "act": { + "account": "eosio", + "name": "updateauth", + "authorization": [ + { + "actor": "wharfkit1133", + "permission": "active" + } + ], + "data": { + "account": "wharfkit1133", + "permission": "active", + "parent": "owner", + "auth": { + "threshold": 1, + "keys": [ + { + "key": "EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6", + "weight": 1 + } + ], + "accounts": [], + "waits": [] + }, + "authorized_by": "" + }, + "hex_data": "304608d9c1754de300000000a8ed32320000000080ab26a701000000010002c9c679952fe122a7a2982e104bb4ced99e165226acb76318f367c0dd992a0d55010000000000000000000000" + }, + "context_free": false, + "elapsed": 67, + "console": "", + "trx_id": "0294f4e7e66c033b229cdb7c5ec4c6259a3aa0152c2a750728a307b27e8da6e2", + "block_num": 95886404, + "block_time": "2023-09-03T00:01:37.500", + "producer_block_id": null, + "account_ram_deltas": [ + { + "account": "wharfkit1133", + "delta": 0 + } + ], + "except": null, + "error_code": null, + "return_value_hex_data": "" + } + ], + "account_ram_delta": null, + "except": null, + "error_code": null + } + }, + "text": "{\"transaction_id\":\"0294f4e7e66c033b229cdb7c5ec4c6259a3aa0152c2a750728a307b27e8da6e2\",\"processed\":{\"id\":\"0294f4e7e66c033b229cdb7c5ec4c6259a3aa0152c2a750728a307b27e8da6e2\",\"block_num\":95886404,\"block_time\":\"2023-09-03T00:01:37.500\",\"producer_block_id\":null,\"receipt\":{\"status\":\"executed\",\"cpu_usage_us\":219,\"net_usage_words\":21},\"elapsed\":219,\"net_usage\":168,\"scheduled\":false,\"action_traces\":[{\"action_ordinal\":1,\"creator_action_ordinal\":0,\"closest_unnotified_ancestor_action_ordinal\":0,\"receipt\":{\"receiver\":\"eosio\",\"act_digest\":\"5d8239b83dcdbae9a7a29f2a5ed47b183e597d7dd16a911270c5c1749230299f\",\"global_sequence\":128190450,\"recv_sequence\":95947354,\"auth_sequence\":[[\"wharfkit1133\",28]],\"code_sequence\":4,\"abi_sequence\":4},\"receiver\":\"eosio\",\"act\":{\"account\":\"eosio\",\"name\":\"updateauth\",\"authorization\":[{\"actor\":\"wharfkit1133\",\"permission\":\"active\"}],\"data\":{\"account\":\"wharfkit1133\",\"permission\":\"active\",\"parent\":\"owner\",\"auth\":{\"threshold\":1,\"keys\":[{\"key\":\"EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6\",\"weight\":1}],\"accounts\":[],\"waits\":[]},\"authorized_by\":\"\"},\"hex_data\":\"304608d9c1754de300000000a8ed32320000000080ab26a701000000010002c9c679952fe122a7a2982e104bb4ced99e165226acb76318f367c0dd992a0d55010000000000000000000000\"},\"context_free\":false,\"elapsed\":67,\"console\":\"\",\"trx_id\":\"0294f4e7e66c033b229cdb7c5ec4c6259a3aa0152c2a750728a307b27e8da6e2\",\"block_num\":95886404,\"block_time\":\"2023-09-03T00:01:37.500\",\"producer_block_id\":null,\"account_ram_deltas\":[{\"account\":\"wharfkit1133\",\"delta\":0}],\"except\":null,\"error_code\":null,\"return_value_hex_data\":\"\"}],\"account_ram_delta\":null,\"except\":null,\"error_code\":null}}" +} \ No newline at end of file diff --git a/test/data/2e1bfb5d12c7491faabd3d5487c2e048e69f35aa.json b/test/data/d1798039abbae9504b0188c5e3e560ef39516d35.json similarity index 60% rename from test/data/2e1bfb5d12c7491faabd3d5487c2e048e69f35aa.json rename to test/data/d1798039abbae9504b0188c5e3e560ef39516d35.json index 760e902..feb3e2a 100644 --- a/test/data/2e1bfb5d12c7491faabd3d5487c2e048e69f35aa.json +++ b/test/data/d1798039abbae9504b0188c5e3e560ef39516d35.json @@ -1,13 +1,10 @@ { - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "266", - "content-type": "application/json", - "date": "Thu, 31 Aug 2023 05:54:25 GMT", - "server": "nginx" + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_currency_balance", + "params": { + "method": "POST", + "body": "{\"account\":\"wharfkit1133\",\"code\":\"nonexist\"}" + } }, "status": 500, "json": { @@ -21,11 +18,11 @@ { "message": "Fail to retrieve account for nonexist", "file": "chain_plugin.cpp", - "line_number": 1695, + "line_number": 1662, "method": "get_abi" } ] } }, - "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":3060002,\"name\":\"account_query_exception\",\"what\":\"Account Query Exception\",\"details\":[{\"message\":\"Fail to retrieve account for nonexist\",\"file\":\"chain_plugin.cpp\",\"line_number\":1695,\"method\":\"get_abi\"}]}}" + "text": "{\"code\":500,\"message\":\"Internal Service Error\",\"error\":{\"code\":3060002,\"name\":\"account_query_exception\",\"what\":\"Account Query Exception\",\"details\":[{\"message\":\"Fail to retrieve account for nonexist\",\"file\":\"chain_plugin.cpp\",\"line_number\":1662,\"method\":\"get_abi\"}]}}" } \ No newline at end of file diff --git a/test/data/de917d312f52e009a605e668a07af7b68f5c8fdd.json b/test/data/de917d312f52e009a605e668a07af7b68f5c8fdd.json deleted file mode 100644 index 7c0b7ae..0000000 --- a/test/data/de917d312f52e009a605e668a07af7b68f5c8fdd.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "2", - "content-type": "application/json", - "date": "Thu, 31 Aug 2023 05:54:25 GMT", - "host": "eos.greymass.com", - "server": "nginx" - }, - "status": 200, - "json": [], - "text": "[]" -} \ No newline at end of file diff --git a/test/data/dfd6e7528200581cc18d9d6586cac3b8e09b7663.json b/test/data/dfd6e7528200581cc18d9d6586cac3b8e09b7663.json deleted file mode 100644 index 5f7af26..0000000 --- a/test/data/dfd6e7528200581cc18d9d6586cac3b8e09b7663.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "headers": { - "access-control-allow-headers": "X-Requested-With,Accept,Content-Type,Origin", - "access-control-allow-methods": "GET, POST, OPTIONS", - "access-control-allow-origin": "*", - "connection": "close", - "content-length": "17", - "content-type": "application/json", - "date": "Thu, 31 Aug 2023 05:54:25 GMT", - "host": "eos.greymass.com", - "server": "nginx" - }, - "status": 200, - "json": [ - "4968.2348 EOS" - ], - "text": "[\"4968.2348 EOS\"]" -} \ No newline at end of file diff --git a/test/data/ea99f667562175555c6f11cb723045a5bf8e0216.json b/test/data/ea99f667562175555c6f11cb723045a5bf8e0216.json new file mode 100644 index 0000000..7ad790d --- /dev/null +++ b/test/data/ea99f667562175555c6f11cb723045a5bf8e0216.json @@ -0,0 +1,12 @@ +{ + "request": { + "path": "https://jungle4.greymass.com/v1/chain/get_currency_balance", + "params": { + "method": "POST", + "body": "{\"account\":\"wharfkit1133\",\"code\":\"eosio.token\",\"symbol\":\"nonexist\"}" + } + }, + "status": 200, + "json": [], + "text": "[]" +} \ No newline at end of file diff --git a/test/tests/account.ts b/test/tests/account.ts index d41ff7d..0cb9cd5 100644 --- a/test/tests/account.ts +++ b/test/tests/account.ts @@ -1,229 +1,506 @@ import {assert} from 'chai' -import {API, APIClient} from '@wharfkit/antelope' +import {API, Asset, Authority, Int64, KeyWeight, Serializer} from '@wharfkit/antelope' +import {makeClient, mockSessionArgs, mockSessionOptions} from '@wharfkit/mock-data' +import {Session} from '@wharfkit/session' +import {PlaceholderAuth} from '@wharfkit/signing-request' -import {Account, AccountKit, Permission} from '../../src' -import {MockProvider} from '../utils/mock-provider' -import {deserializedMockAccountObject} from '../utils/mock-data' -import {Name} from '@greymass/eosio' -import {deserialize} from 'test/utils/helpers' +import {Account, AccountKit, Permission, SystemContract} from '../../src' -const eosApiClient = new APIClient({ - provider: new MockProvider('https://eos.greymass.com'), -}) +const mockAccountName = 'wharfkit1133' + +const client = makeClient('https://jungle4.greymass.com') +const accountKit = new AccountKit({client}) +const session = new Session( + { + ...mockSessionArgs, + actor: mockAccountName, + permission: 'active', + permissionLevel: `${mockAccountName}@active`, + }, + mockSessionOptions +) suite('Account', function () { let testAccount: Account - this.beforeAll(async function () { - testAccount = await new AccountKit({client: eosApiClient}).load('teamgreymass') + setup(async function () { + testAccount = await accountKit.load(mockAccountName) }) test('construct', function () { const account = new Account({ - client: eosApiClient, - accountData: deserializedMockAccountObject, + client, + data: testAccount.data, }) assert.instanceOf(account, Account) }) test('accountName', function () { - assert.isTrue(testAccount.accountName.equals('teamgreymass')) + assert.isTrue(testAccount.accountName.equals('wharfkit1133')) }) - suite('account_data', function () { + suite('data', function () { test('returns account data', async function () { - assert.instanceOf(testAccount.account_data, API.v1.AccountObject) + assert.instanceOf(testAccount.data, API.v1.AccountObject) }) }) - suite('getPermission', function () { + suite('permission', function () { test('returns permission object', async function () { - assert.instanceOf(testAccount.getPermission('active'), Permission) + assert.instanceOf(testAccount.permission('active'), Permission) }) test('throws error when permission does not exist', function () { - try { - testAccount.getPermission('nonexistent') - assert.fail() - } catch (error) { - assert.equal( - (error as Error).message, - 'Permission nonexistent does not exist on account teamgreymass.' - ) - } + assert.throws(() => testAccount.permission('nonexistent')) }) }) - suite('getResources', function () { + suite('resource', function () { this.slow(200) this.timeout(5 * 1000) - test('returns resources data', async function () { - assert.deepEqual(testAccount.getResources(), { - cpu_available: 400021, - cpu_used: 1018013, - net_available: 8225481, - net_used: 8225481, - ram_quota: 67988, - ram_usage: 18101, - }) + test('cpu', async function () { + const resources = testAccount.resource('cpu') + assert.instanceOf(resources.available, Int64) + assert.instanceOf(resources.used, Int64) + assert.instanceOf(resources.max, Int64) + }) + + test('net', async function () { + const resources = testAccount.resource('net') + assert.instanceOf(resources.available, Int64) + assert.instanceOf(resources.used, Int64) + assert.instanceOf(resources.max, Int64) + }) + + test('ram', async function () { + const resources = testAccount.resource('ram') + assert.instanceOf(resources.available, Int64) + assert.instanceOf(resources.used, Int64) + assert.instanceOf(resources.max, Int64) }) }) - suite('updatePermission', () => { - test('returns current Action', () => { - const permission = new Permission('permission', { - account: '............1', - parent: '............1', - permission: '............1', - authorized_by: '............1', - auth: { - accounts: [], - keys: [ - { - key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', - weight: 1, - }, - ], - threshold: 1, - waits: [], - }, - }) - const action = testAccount.updatePermission(permission) - assert.deepEqual(deserialize(action), { - account: 'eosio', - authorization: [ - { - actor: '............1', - permission: '............2', - }, - ], - data: '01000000000000000100000000000000010000000000000001000000010002c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf010000000100000000000000', - name: 'updateauth', + suite('setPermission', () => { + test('basic syntax', () => { + const auth = Authority.from({ + accounts: [], + keys: [], + threshold: 1, + waits: [], + }) + const permission = Permission.from({ + parent: 'active', + perm_name: 'foo', + required_auth: auth, + }) + const action = testAccount.setPermission(permission) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('updateauth')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Updateauth, }) + assert.isTrue(decoded.account.equals('wharfkit1133')) + assert.isTrue(decoded.parent.equals('active')) + assert.isTrue(decoded.permission.equals('foo')) + assert.isTrue(decoded.auth.equals(auth)) }) - }) + suite('create and remove permission', function () { + test('create new permission', async () => { + // Setup new permission, will be removed in next test + const permission = Permission.from({ + parent: 'active', + perm_name: 'unittest', + required_auth: Authority.from({ + accounts: [], + keys: [], + threshold: 1, + waits: [], + }), + }) + // Mutate to add a key + permission.addKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') + // Get action to commit change to chain + const action = testAccount.setPermission(permission) + await session.transact({action}, {broadcast: true}) + }) + test('remove it', async () => { + const action = testAccount.removePermission('unittest') + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('deleteauth')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Deleteauth, + }) + assert.isTrue(decoded.account.equals('wharfkit1133')) + assert.isTrue(decoded.permission.equals('unittest')) + + await session.transact({action}, {broadcast: true}) + }) + }) + suite('modify existing', function () { + test('adding key', async () => { + // Retrieve existing permission + const permission = testAccount.permission('active') + const originalKey = 'EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6' + // Mutate to add a key + permission.addKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') + // Get action to commit change to chain + const action = testAccount.setPermission(permission) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('updateauth')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Updateauth, + }) + assert.isTrue(decoded.account.equals('wharfkit1133')) + assert.isTrue(decoded.parent.equals('owner')) + assert.isTrue(decoded.permission.equals('active')) + assert.isTrue(decoded.auth.keys[0].key.equals(permission.required_auth.keys[0].key)) + assert.isTrue( + decoded.auth.keys[0].weight.equals(permission.required_auth.keys[0].weight) + ) + // The keys will be reordered due to sorting requirements + assert.isTrue( + decoded.auth.keys[0].key.equals( + 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63' + ) + ) + assert.isTrue(decoded.auth.keys[1].key.equals(originalKey)) + assert.isTrue(decoded.auth.keys[1].weight.equals(1)) + assert.isTrue(decoded.auth.equals(permission.required_auth)) + + await session.transact({action}, {broadcast: true}) + }) + test('remove key', async () => { + // Retrieve existing permission + const permission = testAccount.permission('active') + const originalKey = 'EOS6RMS3nvoN9StPzZizve6WdovaDkE5KkEcCDXW7LbepyAioMiK6' + // It needs to be added here because the cached record doesn't have it. + // It should exist on-chain already due to the previous test. + // Unsure how to get around this. + permission.required_auth.keys.push( + KeyWeight.from({ + key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', + weight: 1, + }) + ) + permission.required_auth.sort() + // Mutate to remove a key + permission.removeKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') + // Get action to commit change to chain + const action = testAccount.setPermission(permission) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('updateauth')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) - suite('removePermission', () => { - test('returns current Action', () => { - const action = testAccount.removePermission('someName') - assert.deepEqual(deserialize(action), { - account: 'eosio', - authorization: [ - { - actor: '............1', - permission: '............2', - }, - ], - data: '01000000000000000000004a1aa024c50100000000000000', - name: 'deleteauth', + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Updateauth, + }) + assert.isTrue(decoded.account.equals('wharfkit1133')) + assert.isTrue(decoded.parent.equals('owner')) + assert.isTrue(decoded.permission.equals('active')) + assert.isTrue(decoded.auth.keys[0].key.equals(originalKey)) + assert.isTrue(decoded.auth.keys[0].weight.equals(1)) + assert.isTrue(decoded.auth.equals(permission.required_auth)) + + await session.transact({action}, {broadcast: true}) }) }) }) suite('buyRam', () => { - test('returns current Action', () => { + test('only amount', () => { const action = testAccount.buyRam('1.0000 EOS') - assert.deepEqual(deserialize(action), { - account: 'eosio', - authorization: [ - { - actor: '............1', - permission: '............2', - }, - ], - data: '01000000000000000100000000000000102700000000000004454f5300000000', - name: 'buyram', + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('buyram')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Buyram, }) + assert.isTrue(decoded.payer.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.quant.equals('1.0000 EOS')) + }) + test('override receiver', () => { + const action = testAccount.buyRam('1.0000 EOS', { + receiver: 'wharfkit1112', + }) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('buyram')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Buyram, + }) + assert.isTrue(decoded.payer.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1112')) + assert.isTrue(decoded.quant.equals('1.0000 EOS')) }) }) suite('buyRamBytes', () => { - test('returns current Action', () => { + test('only bytes', () => { const action = testAccount.buyRamBytes(1024) - assert.deepEqual(deserialize(action), { - account: 'eosio', - authorization: [ - { - actor: '............1', - permission: '............2', - }, - ], - data: '0100000000000000010000000000000000040000', - name: 'buyrambytes', + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('buyrambytes')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Buyrambytes, }) + assert.isTrue(decoded.payer.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.bytes.equals(1024)) }) - }) + test('override receiver', () => { + const action = testAccount.buyRamBytes(1024, { + receiver: 'wharfkit1112', + }) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('buyrambytes')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) - suite('sellRam', () => { - test('returns current Action', () => { - const action = testAccount.sellRam(1024) - assert.deepEqual(deserialize(action), { - account: 'eosio', - authorization: [ - { - actor: '............1', - permission: '............2', - }, - ], - data: '01000000000000000004000000000000', - name: 'sellram', + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Buyrambytes, }) + assert.isTrue(decoded.payer.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1112')) + assert.isTrue(decoded.bytes.equals(1024)) }) }) - suite('delegateResources', () => { - test('returns current Action', () => { - const action = testAccount.delegateResources('1.0000 EOS', '0.5000 EOS') - assert.deepEqual(deserialize(action), { - account: 'eosio', - authorization: [ - { - actor: '............1', - permission: '............2', - }, - ], - data: '01000000000000000100000000000000881300000000000004454f5300000000102700000000000004454f530000000000', - name: 'delegatebw', + test('sellRam', () => { + const action = testAccount.sellRam(1024) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('sellram')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({data: action.data, type: SystemContract.Types.Sellram}) + assert.isTrue(decoded.account.equals('wharfkit1133')) + assert.isTrue(decoded.bytes.equals(1024)) + }) + + suite('delegate', () => { + test('no data', () => { + const action = testAccount.delegate({}) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('delegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Delegatebw, + }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.stake_cpu_quantity.equals('0.0000 EOS')) + assert.isTrue(decoded.stake_net_quantity.equals('0.0000 EOS')) + assert.isFalse(decoded.transfer) + }) + test('cpu only', () => { + const action = testAccount.delegate({cpu: '1.0000 EOS'}) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('delegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Delegatebw, + }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.stake_cpu_quantity.equals('1.0000 EOS')) + assert.isTrue(decoded.stake_net_quantity.equals('0.0000 EOS')) + assert.isFalse(decoded.transfer) + }) + test('net only', () => { + const action = testAccount.delegate({net: '1.0000 EOS'}) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('delegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Delegatebw, + }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.stake_cpu_quantity.equals('0.0000 EOS')) + assert.isTrue(decoded.stake_net_quantity.equals('1.0000 EOS')) + assert.isFalse(decoded.transfer) + }) + test('cpu and net', () => { + const action = testAccount.delegate({cpu: '1.0000 EOS', net: '0.5000 EOS'}) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('delegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Delegatebw, + }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.stake_cpu_quantity.equals('1.0000 EOS')) + assert.isTrue(decoded.stake_net_quantity.equals('0.5000 EOS')) + assert.isFalse(decoded.transfer) + }) + test('override receiver', () => { + const action = testAccount.delegate({ + cpu: '1.0000 EOS', + net: '0.5000 EOS', + receiver: 'wharfkit1112', + }) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('delegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Delegatebw, }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1112')) + assert.isTrue(decoded.stake_cpu_quantity.equals('1.0000 EOS')) + assert.isTrue(decoded.stake_net_quantity.equals('0.5000 EOS')) + assert.isFalse(decoded.transfer) + }) + test('override receiver and enable transfer', () => { + const action = testAccount.delegate({ + cpu: '1.0000 EOS', + net: '0.5000 EOS', + receiver: 'wharfkit1112', + transfer: true, + }) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('delegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Delegatebw, + }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1112')) + assert.isTrue(decoded.stake_cpu_quantity.equals('1.0000 EOS')) + assert.isTrue(decoded.stake_net_quantity.equals('0.5000 EOS')) + assert.isTrue(decoded.transfer) }) }) - suite('undelegateResources', () => { - test('returns current Action', () => { - const action = testAccount.undelegateResources('0.5000 EOS', '1.0000 EOS') - assert.deepEqual(deserialize(action), { - account: 'eosio', - authorization: [ - { - actor: '............1', - permission: '............2', - }, - ], - data: '01000000000000000100000000000000102700000000000004454f5300000000881300000000000004454f5300000000', - name: 'undelegatebw', + suite('undelegate', () => { + test('no data', () => { + const action = testAccount.undelegate({}) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('undelegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Undelegatebw, + }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.unstake_cpu_quantity.equals('0.0000 EOS')) + assert.isTrue(decoded.unstake_net_quantity.equals('0.0000 EOS')) + }) + test('cpu only', () => { + const action = testAccount.undelegate({cpu: '1.0000 EOS'}) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('undelegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Undelegatebw, + }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.unstake_cpu_quantity.equals('1.0000 EOS')) + assert.isTrue(decoded.unstake_net_quantity.equals('0.0000 EOS')) + }) + test('net only', () => { + const action = testAccount.undelegate({net: '1.0000 EOS'}) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('undelegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Undelegatebw, + }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.unstake_cpu_quantity.equals('0.0000 EOS')) + assert.isTrue(decoded.unstake_net_quantity.equals('1.0000 EOS')) + }) + test('cpu and net', () => { + const action = testAccount.undelegate({cpu: '1.0000 EOS', net: '0.5000 EOS'}) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('undelegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Undelegatebw, + }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1133')) + assert.isTrue(decoded.unstake_cpu_quantity.equals('1.0000 EOS')) + assert.isTrue(decoded.unstake_net_quantity.equals('0.5000 EOS')) + }) + test('override receiver', () => { + const action = testAccount.undelegate({ + cpu: '1.0000 EOS', + net: '0.5000 EOS', + receiver: 'wharfkit1112', + }) + assert.isTrue(action.account.equals('eosio')) + assert.isTrue(action.name.equals('undelegatebw')) + assert.isTrue(action.authorization[0].equals(PlaceholderAuth)) + + const decoded = Serializer.decode({ + data: action.data, + type: SystemContract.Types.Undelegatebw, }) + assert.isTrue(decoded.from.equals('wharfkit1133')) + assert.isTrue(decoded.receiver.equals('wharfkit1112')) + assert.isTrue(decoded.unstake_cpu_quantity.equals('1.0000 EOS')) + assert.isTrue(decoded.unstake_net_quantity.equals('0.5000 EOS')) }) }) - suite('getBalance', function () { + suite('balance', function () { this.slow(200) this.timeout(5 * 1000) test('returns resources object for system token', async function () { - assert.equal(String(await testAccount.getBalance()), '4968.2348 EOS') + const balance = await testAccount.balance() + assert.instanceOf(balance, Asset) }) test('returns resources object for secondary token', async function () { - assert.equal( - String(await testAccount.getBalance('bingobetoken', 'BINGO')), - '1000.0000 BINGO' - ) + const balance = await testAccount.balance('eosio.token', 'EOS') + assert.instanceOf(balance, Asset) }) test('throws error when token does not exist for given contract', function (done) { testAccount - .getBalance('eosio.token', 'nonexist') + .balance('eosio.token', 'nonexist') .catch((error) => { assert.equal( (error as Error).message, @@ -238,7 +515,7 @@ suite('Account', function () { test('throws error when token contract does not exist', function (done) { testAccount - .getBalance('nonexist') + .balance('nonexist') .catch((error) => { assert.equal( (error as Error).message, diff --git a/test/tests/kit.ts b/test/tests/kit.ts index b872015..82a13a6 100644 --- a/test/tests/kit.ts +++ b/test/tests/kit.ts @@ -1,19 +1,14 @@ import {assert, expect} from 'chai' -import {APIClient} from '@wharfkit/antelope' +import {Account, AccountKit, SystemContract} from '../../src' +import {makeClient} from '@wharfkit/mock-data' -import {Account, AccountKit} from '../../src' -import {MockProvider} from 'test/utils/mock-provider' - -const eosApiClient = new APIClient({ - provider: new MockProvider('https://eos.greymass.com'), -}) +const client = makeClient('https://jungle4.greymass.com') suite('AccountKit', function () { let accountKit: AccountKit this.beforeAll(function () { - const client = eosApiClient accountKit = new AccountKit({client}) }) @@ -32,6 +27,13 @@ suite('AccountKit', function () { test('sets client if provided', function () { expect(accountKit.client).to.exist }) + + test('allow overriding of default contract', function () { + const kit = new AccountKit({ + client, + contract: new SystemContract.Contract({client: makeClient()}), + }) + }) }) suite('load', function () { @@ -40,7 +42,7 @@ suite('AccountKit', function () { await accountKit.load('nonexistent') assert.fail() } catch (error) { - assert.equal(error.message, 'Account nonexistent does not exist') + assert.instanceOf(error, Error) } }) diff --git a/test/tests/permission.ts b/test/tests/permission.ts index 2d52faf..ccbb7f6 100644 --- a/test/tests/permission.ts +++ b/test/tests/permission.ts @@ -1,130 +1,283 @@ import {assert} from 'chai' -import {Authority, AuthorityType, Name, NameType} from '@wharfkit/antelope' +import { + Authority, + KeyWeight, + Name, + PermissionLevel, + PermissionLevelWeight, + PublicKey, + UInt16, + WaitWeight, +} from '@wharfkit/antelope' +import {makeClient, mockAccountName} from '@wharfkit/mock-data' -import {ActionData, Permission} from '../../src' -import {deserialize} from '../utils/helpers' +import AccountKit, {Account, Permission} from '../../src' -const authorityExample = { - threshold: 1, - keys: [ - { - key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', - weight: 1, - }, - ], - accounts: [], - waits: [], -} +const client = makeClient('https://jungle4.greymass.com') +const accountKit = new AccountKit({client}) suite('Permission', function () { - test('construct', function () { - const permission = new Permission(Name.from('active'), { - account: 'teamgreymass', - parent: 'owner', - permission: 'active', - auth: Authority.from(authorityExample), - authorized_by: 'teamgreymass', + let testAccount: Account + let testPermission: Permission + + setup(async function () { + testAccount = await accountKit.load(mockAccountName) + testPermission = testAccount.permission('active') + }) + + suite('construct', function () { + test('vanilla objects', function () { + Permission.from({ + parent: 'owner', + perm_name: 'active', + required_auth: { + threshold: 1, + keys: [ + { + key: 'PUB_K1_6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6V9t8aT5', + weight: 1, + }, + ], + accounts: [ + { + permission: {actor: 'foo', permission: 'bar'}, + weight: 1, + }, + ], + waits: [ + { + wait_sec: 600, + weight: 1, + }, + ], + }, + }) + }) + test('empty', function () { + Permission.from({ + parent: 'owner', + perm_name: 'active', + required_auth: { + threshold: 1, + keys: [], + accounts: [], + waits: [], + }, + }) + }) + test('typed objects', function () { + const permission = Permission.from({ + parent: Name.from('owner'), + perm_name: Name.from('active'), + required_auth: Authority.from({ + threshold: UInt16.from(1), + keys: [ + KeyWeight.from({ + key: PublicKey.from( + 'PUB_K1_6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6V9t8aT5' + ), + weight: UInt16.from(1), + }), + ], + accounts: [ + PermissionLevelWeight.from({ + permission: PermissionLevel.from({ + actor: Name.from('foo'), + permission: Name.from('bar'), + }), + weight: UInt16.from(1), + }), + ], + waits: [ + WaitWeight.from({ + wait_sec: 600, + weight: UInt16.from(1), + }), + ], + }), + }) + // Coverage on recursion + Permission.from(permission) }) - assert.instanceOf(permission, Permission) }) - test('permissionName', function () { - assert.equal(String(testPermission().permissionName), 'active') + test('name (getter)', function () { + assert.equal(String(testPermission.name), 'active') }) - test('actionData', function () { - assert.deepEqual(deserialize(testPermission().actionData), { - account: 'teamgreymass', - permission: 'active', - authorized_by: 'teamgreymass', - parent: 'owner', - auth: { - accounts: [], - keys: [ - { + suite('key-based authority', function () { + suite('addKey', function () { + test('add (string)', function () { + testPermission.addKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') + assert.equal(testPermission.required_auth.keys.length, 2) + // Will be position 0 due to authority sorting + assert.isTrue( + testPermission.required_auth.keys[0].equals({ key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', weight: 1, - }, - ], - threshold: 1, - waits: [], - }, + }) + ) + }) + test('add (string, legacy)', function () { + const publicKey = PublicKey.from( + 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63' + ) + testPermission.addKey(publicKey.toLegacyString()) + assert.equal(testPermission.required_auth.keys.length, 2) + // Will be position 0 due to authority sorting + assert.isTrue( + testPermission.required_auth.keys[0].equals({ + key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', + weight: 1, + }) + ) + }) + test('add (PublicKey)', function () { + const publicKey = PublicKey.from( + 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63' + ) + testPermission.addKey(publicKey) + assert.equal(testPermission.required_auth.keys.length, 2) + // Will be position 0 due to authority sorting + assert.isTrue( + testPermission.required_auth.keys[0].equals({ + key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', + weight: 1, + }) + ) + }) + test('add with weight', function () { + const publicKey = PublicKey.from( + 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63' + ) + testPermission.addKey(publicKey, 10) + assert.equal(testPermission.required_auth.keys.length, 2) + // Will be position 0 due to authority sorting + assert.isTrue( + testPermission.required_auth.keys[0].equals({ + key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', + weight: 10, + }) + ) + }) + test('prevent duplicate', function () { + assert.throws(() => + testPermission.addKey( + 'PUB_K1_6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6V9t8aT5' + ) + ) + }) }) - }) - - test('addKey', function () { - const permission = testPermission() - permission.addKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') - assert.equal(permission.actionData.auth.keys?.length, 2) - }) - test('removeKey', function () { - const permission = testPermission() - assert.equal(permission.actionData.auth.keys?.length, 1) - permission.removeKey('PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63') - assert.equal(permission.actionData.auth.keys?.length, 0) + suite('removeKey', function () { + test('remove', function () { + assert.equal(testPermission.required_auth.keys.length, 1) + testPermission.removeKey( + 'PUB_K1_6XXTaRpWhPwnb7CTV9zVsCBrvCpYMMPSk8E8hsJxhf6V9t8aT5' + ) + assert.equal(testPermission.required_auth.keys.length, 0) + }) + test('throw if key not found', function () { + assert.throws(() => + testPermission.removeKey( + 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63' + ) + ) + }) + }) }) - test('addAccount', function () { - const permission = testPermission() - permission.addAccount({actor: 'trust.gm', permission: 'active'}) - assert.deepEqual(deserialize(permission.actionData.auth), { - ...authorityExample, - accounts: [ - { - permission: { - actor: 'trust.gm', - permission: 'active', + suite('account-based authority', function () { + suite('addAccount', function () { + test('add (object)', function () { + testPermission.addAccount({actor: 'trust.gm', permission: 'active'}) + assert.lengthOf(testPermission.required_auth.keys, 1) + assert.lengthOf(testPermission.required_auth.accounts, 1) + assert.isTrue( + testPermission.required_auth.accounts[0].permission.equals( + PermissionLevel.from({actor: 'trust.gm', permission: 'active'}) + ) + ) + }) + test('add (string)', function () { + testPermission.addAccount('trust.gm@active') + assert.lengthOf(testPermission.required_auth.keys, 1) + assert.lengthOf(testPermission.required_auth.accounts, 1) + assert.isTrue( + testPermission.required_auth.accounts[0].permission.equals( + PermissionLevel.from({actor: 'trust.gm', permission: 'active'}) + ) + ) + }) + test('add (PermissionLevel)', function () { + testPermission.addAccount( + PermissionLevel.from({actor: 'trust.gm', permission: 'active'}) + ) + assert.lengthOf(testPermission.required_auth.keys, 1) + assert.lengthOf(testPermission.required_auth.accounts, 1) + assert.isTrue( + testPermission.required_auth.accounts[0].permission.equals( + PermissionLevel.from({actor: 'trust.gm', permission: 'active'}) + ) + ) + }) + test('add and prevent duplicates', function () { + const test = Permission.from({ + parent: 'owner', + perm_name: 'active', + required_auth: { + threshold: 1, + keys: [], + accounts: [ + { + permission: {actor: 'foo', permission: 'bar'}, + weight: 1, + }, + ], + waits: [], }, - weight: 1, - }, - ], + }) + assert.throws(() => test.addAccount({actor: 'foo', permission: 'bar'})) + }) }) - }) - test('removeAccount', function () { - const permission = testPermission() - permission.addAccount({actor: 'trust.gm', permission: 'active'}) - permission.removeAccount('trust.gm') - assert.deepEqual(deserialize(permission.actionData.auth), { - ...authorityExample, - accounts: [], + suite('removeAccount', function () { + test('remove', function () { + testPermission.addAccount({actor: 'trust.gm', permission: 'active'}) + testPermission.removeAccount({actor: 'trust.gm', permission: 'active'}) + assert.lengthOf(testPermission.required_auth.keys, 1) + assert.lengthOf(testPermission.required_auth.accounts, 0) + }) + test('throw if account not found', function () { + assert.throws(() => + testPermission.removeAccount({actor: 'trust.gm', permission: 'active'}) + ) + }) }) }) - test('addWait', function () { - const permission = testPermission() - permission.addWait(100) - assert.deepEqual(JSON.parse(JSON.stringify(permission.actionData.auth.waits)), [ - {wait_sec: 100, weight: 1}, - ]) - }) + suite('wait-based authority', function () { + test('addWait', function () { + assert.lengthOf(testPermission.required_auth.waits, 0) + testPermission.addWait({ + wait_sec: 100, + weight: 1, + }) + assert.lengthOf(testPermission.required_auth.waits, 1) + assert.isTrue(testPermission.required_auth.waits[0].equals({wait_sec: 100, weight: 1})) + }) - test('removeWait', function () { - const permission = testPermission() - permission.addWait(100) - assert.equal(permission.actionData.auth.waits?.length, 1) - permission.removeWait(100) - assert.equal(permission.actionData.auth.waits?.length, 0) + test('removeWait', function () { + testPermission.addWait({ + wait_sec: 100, + weight: 1, + }) + assert.equal(testPermission.required_auth.waits?.length, 1) + testPermission.removeWait({ + wait_sec: 100, + weight: 1, + }) + assert.equal(testPermission.required_auth.waits?.length, 0) + }) }) }) - -function testPermission() { - return new Permission('active', { - account: 'teamgreymass', - parent: 'owner', - permission: 'active', - authorized_by: 'teamgreymass', - auth: Authority.from({ - threshold: 1, - keys: [ - { - key: 'PUB_K1_6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5BoDq63', - weight: 1, - }, - ], - accounts: [], - waits: [], - }), - }) -} diff --git a/test/utils/helpers.ts b/test/utils/helpers.ts deleted file mode 100644 index 91a2526..0000000 --- a/test/utils/helpers.ts +++ /dev/null @@ -1,3 +0,0 @@ -export function deserialize(data: DataType) { - return JSON.parse(JSON.stringify(data)) -} diff --git a/test/utils/mock-data.ts b/test/utils/mock-data.ts deleted file mode 100644 index 5b72cc1..0000000 --- a/test/utils/mock-data.ts +++ /dev/null @@ -1,48 +0,0 @@ -import {API, Asset, Name, TimePoint, UInt32, UInt64} from '@greymass/eosio' -import {deserialize} from './helpers' - -export const mockAccountObject = API.v1.AccountObject.from({ - cpu_weight: UInt64.from(236250), - net_weight: UInt64.from(8253324), - ram_quota: UInt64.from(67988), - account_name: Name.from('test'), - head_block_num: UInt32.from(0), - head_block_time: TimePoint.from(new Date()), - privileged: false, - last_code_update: TimePoint.from(new Date()), - created: TimePoint.from(new Date()), - core_liquid_balance: Asset.from('0.0000 EOS'), - net_limit: API.v1.AccountResourceLimit.from({ - used: UInt64.from(8253324), - available: UInt64.from(8253324), - max: UInt64.from(8253324 + 8253324), - }), - cpu_limit: API.v1.AccountResourceLimit.from({ - used: UInt64.from(826079), - available: UInt64.from(236250), - max: UInt64.from(826079 + 236250), - }), - ram_usage: UInt64.from(17086), - permissions: [], - total_resources: API.v1.AccountTotalResources.from({ - owner: Name.from('test'), - net_weight: Asset.from('1.0000 EOS'), - cpu_weight: Asset.from('1.0000 EOS'), - ram_bytes: UInt64.from(1000), - }), - self_delegated_bandwidth: API.v1.AccountSelfDelegatedBandwidth.from({ - from: Name.from('test'), - to: Name.from('test'), - net_weight: Asset.from('0.0000 EOS'), - cpu_weight: Asset.from('0.0000 EOS'), - }), - refund_request: API.v1.AccountRefundRequest.from({ - owner: Name.from('test'), - request_time: TimePoint.from(new Date()), - net_amount: Asset.from('0.0000 EOS'), - cpu_amount: Asset.from('0.0000 EOS'), - }), - getPermission: () => undefined, -}) - -export const deserializedMockAccountObject = deserialize(mockAccountObject) diff --git a/test/utils/mock-provider.ts b/test/utils/mock-provider.ts deleted file mode 100644 index 89082b4..0000000 --- a/test/utils/mock-provider.ts +++ /dev/null @@ -1,52 +0,0 @@ -import fetch from 'node-fetch' - -import {APIProvider, Bytes, Checksum160, FetchProvider} from '@greymass/eosio' - -import {join as joinPath} from 'path' -import {promisify} from 'util' -import {readFile as _readFile, writeFile as _writeFile} from 'fs' - -const readFile = promisify(_readFile) -const writeFile = promisify(_writeFile) - -export class MockProvider implements APIProvider { - recordProvider = new FetchProvider(this.api, {fetch}) - - constructor(private api: string = 'https://jungle3.greymass.com') {} - - getFilename(path: string, params?: unknown) { - const digest = Checksum160.hash( - Bytes.from(this.api + path + (params ? JSON.stringify(params) : ''), 'utf8') - ).hexString - return joinPath(__dirname, '../data', digest + '.json') - } - - async getExisting(filename: string) { - try { - const data = await readFile(filename) - return JSON.parse(data.toString('utf8')) - } catch (error) { - if ((error).code !== 'ENOENT') { - throw error - } - } - } - - async call(path: string, params?: unknown) { - const filename = this.getFilename(path, params) - if (process.env['MOCK_RECORD'] !== 'overwrite') { - const existing = await this.getExisting(filename) - if (existing) { - return existing - } - } - if (process.env['MOCK_RECORD']) { - const response = await this.recordProvider.call(path, params) - const json = JSON.stringify(response, undefined, 4) - await writeFile(filename, json) - return response - } else { - throw new Error(`No data for ${path}`) - } - } -} diff --git a/yarn.lock b/yarn.lock index 033d6ff..05f59a0 100644 --- a/yarn.lock +++ b/yarn.lock @@ -233,17 +233,6 @@ resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.48.0.tgz#642633964e217905436033a2bd08bf322849b7fb" integrity sha512-ZSjtmelB7IJfWD2Fvb7+Z+ChTIKWq6kjda95fLcQKNS5aheVHn4IkfgRQE3sIIzTcSLwLcLZUD9UBt+V7+h+Pw== -"@greymass/eosio@^0.6.0", "@greymass/eosio@^0.6.4": - version "0.6.11" - resolved "https://registry.yarnpkg.com/@greymass/eosio/-/eosio-0.6.11.tgz#9bd1783f8467834563ac893d41524c01aba0228c" - integrity sha512-Ud6V7+vQJ+OLxqD7QcKTv/ik/Hd5uaRHyGY9Hzc+cJXezYU4sADX4TyQ8sn6XIr8ebVVNZFvWpc5JR0a9lBzKw== - dependencies: - bn.js "^4.11.9" - brorand "^1.1.0" - elliptic "^6.5.4" - hash.js "^1.0.0" - tslib "^2.0.3" - "@humanwhocodes/config-array@^0.11.10": version "0.11.11" resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.11.tgz#88a04c570dbbc7dd943e4712429c3df09bc32844" @@ -573,6 +562,13 @@ hash.js "^1.0.0" tslib "^2.0.3" +"@wharfkit/common@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@wharfkit/common/-/common-1.1.0.tgz#1ee9dd1ba9e202002fadd20593f5f42a3e67c827" + integrity sha512-A1Ta8zrEXkuEQcEiEexG0BVrYOxqm75qbLYU9tGNhyw4z/vQiF6rzmCOqhmWGg6nE2J2GYPvrPZPZzDmRGtG+w== + dependencies: + tslib "^2.1.0" + "@wharfkit/contract@0.4.2": version "0.4.2" resolved "https://registry.yarnpkg.com/@wharfkit/contract/-/contract-0.4.2.tgz#cec2ca9585bf1c63b9458089cbd0388b727b800f" @@ -583,13 +579,35 @@ "@wharfkit/signing-request" "^3.0.0" tslib "^2.1.0" -"@wharfkit/session@^0.2.0": - version "0.2.0" - resolved "https://registry.yarnpkg.com/@wharfkit/session/-/session-0.2.0.tgz#2293dc2582f003292c419152a64735c1f6a6e455" - integrity sha512-QF6T3NGCGdPqp+apeGRte48DKuufgCBl0DX/HwmSs3mof20pMdrVLtvQ8fgHqnynxWD+2lPL3Ip/43Hx0vtnAg== +"@wharfkit/mock-data@^1.0.2": + version "1.0.2" + resolved "https://registry.yarnpkg.com/@wharfkit/mock-data/-/mock-data-1.0.2.tgz#81d6327c76032b40e5acf209d507cf6ca2a3ae9f" + integrity sha512-Mbf/rZX2dqj5r+h+6NcRsDfRdHZ5OWEk0oIZ6iarXEBV65jmODoLdZlS906m9ndC1bi1ewCm/276JDimIqtLkQ== + dependencies: + "@wharfkit/antelope" "^0.7.3" + "@wharfkit/session" "^1.0.0" + "@wharfkit/wallet-plugin-privatekey" "^1.0.0" + node-fetch "^2.6.1" + tslib "^2.1.0" + +"@wharfkit/resources@^1.0.0": + version "1.0.0" + resolved "https://registry.yarnpkg.com/@wharfkit/resources/-/resources-1.0.0.tgz#3ad4b6ebea78e061238f2f166374d893e120c95c" + integrity sha512-q71ttU3ixuoUgkg1azpmRvR66PaznmESn0fCaUd9LZNbV2fm3STRumRRDvqlyARFG+y0sEICxqpj9JKMWv6KgA== dependencies: - "@greymass/eosio" "^0.6.4" - eosio-signing-request "^2.5.2" + "@wharfkit/antelope" "^0.7.3" + bn.js "^4.11.9" + tslib "^2.1.0" + +"@wharfkit/session@^1.0.0": + version "1.0.0" + resolved "https://registry.yarnpkg.com/@wharfkit/session/-/session-1.0.0.tgz#09c60d01a6185ab2e451d34462d84de2d7013220" + integrity sha512-wXmvOVBZ1Rp/9HPUzGPaD/vpGXv2FCNgl8JRLopKgKPHkkEX/u4untshHR8AwSc0ZitjOlv6ubR2h9/UW8h6ug== + dependencies: + "@wharfkit/abicache" "^1.1.1" + "@wharfkit/antelope" "^0.7.3" + "@wharfkit/common" "^1.1.0" + "@wharfkit/signing-request" "^3.0.0" pako "^2.0.4" tslib "^2.1.0" @@ -601,6 +619,13 @@ "@wharfkit/antelope" "^0.7.3" tslib "^2.0.3" +"@wharfkit/wallet-plugin-privatekey@^1.0.0": + version "1.0.0" + resolved "https://registry.yarnpkg.com/@wharfkit/wallet-plugin-privatekey/-/wallet-plugin-privatekey-1.0.0.tgz#2600cce1117ce9391c8078649e05ceaf93780f1d" + integrity sha512-V+/7T/cwoHM8fDaM3MZ1DFKrX2+NddBkkWJ8BIFfmEZnGR1W8Qr77t+piOP0/6UM2etmuZh98XLwZS33vORQ0A== + dependencies: + tslib "^2.1.0" + acorn-jsx@^5.3.2: version "5.3.2" resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937" @@ -1050,14 +1075,6 @@ emoji-regex@^8.0.0: resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== -eosio-signing-request@^2.5.2: - version "2.5.3" - resolved "https://registry.yarnpkg.com/eosio-signing-request/-/eosio-signing-request-2.5.3.tgz#4b15bcc67d2814393a83084c45e4473d638b16e1" - integrity sha512-jb4cKjQM+NI8+JwtGClYiCDX9sgSeUreRTE7YkIAga0fo21vtLTjTn0ZUH1zyfQU5b4Drdcs/yUMXdPUtqp9bg== - dependencies: - "@greymass/eosio" "^0.6.0" - tslib "^2.0.3" - es6-error@^4.0.1: version "4.1.1" resolved "https://registry.yarnpkg.com/es6-error/-/es6-error-4.1.1.tgz#9e3af407459deed47e9a91f9b885a84eb05c561d"