auto accept owner work address assignment

Author: Iztok

packages/fasset-bots-cli/src/run/run-agent.ts

@@ -3,7 +3,7 @@ import "source-map-support/register";
 
 import { AgentBotRunner, PricePublisherService, startActivityTimestampUpdater, stopActivityTimestampUpdater, TimeKeeperService, TimekeeperTimingConfig } from "@flarenetwork/fasset-bots-core";
 import { closeBotConfig, createBotConfig, loadAgentConfigFile, Secrets } from "@flarenetwork/fasset-bots-core/config";
-import { assertNotNullCmd, authenticatedHttpProvider, CommandLineError, formatFixed, initWeb3, isNotNull, logger, sendWeb3Transaction, toBN, toBNExp, web3 } from "@flarenetwork/fasset-bots-core/utils";
+import { assertCmd, assertNotNullCmd, authenticatedHttpProvider, CommandLineError, formatFixed, initWeb3, isNotNull, logger, sendWeb3Transaction, toBN, toBNExp, web3 } from "@flarenetwork/fasset-bots-core/utils";
 import BN from "bn.js";
 import { programWithCommonOptions } from "../utils/program";
 import { toplevelRun } from "../utils/toplevel";
@@ -78,7 +78,7 @@ program.action(async () => {
         // create timekeepers
         const timekeeperService = await TimeKeeperService.create(botConfig, timekeeper.address, timekeeperConfig);
         timekeeperService.startAll();
-        // run price publisher only if price feed api path is set
+        // run price publisher (only if price feed api path is set)
         let pricePublisherService: PricePublisherService | null = null;
         if (runConfig.pricePublisherConfig?.enabled) {
             assertNotNullCmd(pricePublisher, "Price publisher address and private key required");
@@ -89,6 +89,9 @@ program.action(async () => {
             pricePublisherService = await PricePublisherService.create(runConfig, secrets, pricePublisher.address);
             pricePublisherService.start();
         }
+        // update work address mapping
+        const workAddressCorrect = await AgentBotRunner.acceptOwnerWorkAddressAssignment(botConfig);
+        assertCmd(workAddressCorrect, `Work address ${owner.address} does not match owner's management address. Please use setWorkAddress.`);
         // create runner and agents
         const runner = await AgentBotRunner.create(secrets, botConfig, timekeeperService);
         runner.serviceAccounts = serviceAccounts;

packages/fasset-bots-core/src/actors/AgentBot.ts

@@ -224,6 +224,10 @@ export class AgentBot {
         return new AgentBot(agent, agentBotSettings, notifier, owner, ownerUnderlyingAddress);
     }
 
+    static ownerAddressPair(secrets: Secrets) {
+        return new OwnerAddressPair(secrets.required("owner.management.address"), secrets.required("owner.native.address"));
+    }
+
     static underlyingAddress(secrets: Secrets, chainId: ChainId) {
         return secrets.required(`owner.${chainId.chainName}.address`);
     }

packages/fasset-bots-core/src/actors/AgentBotRunner.ts

@@ -8,7 +8,7 @@ import { ORM } from "../config/orm";
 import { AgentEntity } from "../entities/agent";
 import { IAssetAgentContext } from "../fasset-bots/IAssetBotContext";
 import { ChainId } from "../underlying-chain/ChainId";
-import { EVMNativeTokenBalance, sendWeb3Transaction, SimpleThrottler, squashSpace } from "../utils";
+import { artifacts, EVMNativeTokenBalance, sendWeb3Transaction, SimpleThrottler, squashSpace } from "../utils";
 import { firstValue, getOrCreate, requireNotNull, sleep } from "../utils/helpers";
 import { logger } from "../utils/logger";
 import { AgentNotifier } from "../utils/notifier/AgentNotifier";
@@ -262,6 +262,13 @@ export class AgentBotRunner {
         return new AgentBotRunner(secrets, contexts, settings, botConfig.orm, botConfig.loopDelay, botConfig.notifiers, timekeeperService);
     }
 
+    static async acceptOwnerWorkAddressAssignment(botConfig: AgentBotConfig) {
+        const AgentOwnerRegistry = artifacts.require("AgentOwnerRegistry");
+        const owner = AgentBot.ownerAddressPair(botConfig.secrets);
+        const agentOwnerRegistry = await botConfig.contractRetriever.getContract(AgentOwnerRegistry);
+        return await owner.acceptWorkAddressAssignment(agentOwnerRegistry);
+    }
+
     async addSimpleWalletToLoop(agentBot: AgentBot) {
         this.agentAddressFromUnderlying.set(agentBot.agent.underlyingAddress, agentBot.agent.vaultAddress);
         const chainId = agentBot.context.chainInfo.chainId;

packages/fasset-bots-core/src/commands/AgentBotCommands.ts

@@ -71,7 +71,7 @@ export class AgentBotCommands {
     }
 
     static async createBotConfig(secrets: Secrets, configFileName: string, registerCleanup?: CleanupRegistration, validate: boolean = true) {
-        const owner = AgentBotCommands.getOwnerAddressPair(secrets);
+        const owner = AgentBot.ownerAddressPair(secrets);
         // load config
         logger.info(`Owner ${owner.managementAddress} started to initialize cli environment.`);
         const configFile = loadAgentConfigFile(configFileName, `Owner ${owner.managementAddress}`);
@@ -96,7 +96,8 @@ export class AgentBotCommands {
         assertNotNullCmd(chainConfig, `Invalid FAsset symbol ${fAssetSymbol}`);
         const context = await createAgentBotContext(botConfig, chainConfig);
         // verify keys
-        const owner = AgentBotCommands.getOwnerAddressPair(secrets);
+        const owner = AgentBot.ownerAddressPair(secrets);
+        await owner.acceptWorkAddressAssignment(context.agentOwnerRegistry);
         if (validate) {
             await AgentBotOwnerValidation.verifyAgentWhitelisted(context.agentOwnerRegistry, owner);
             await AgentBotOwnerValidation.verifyWorkAddress(context.agentOwnerRegistry, owner);
@@ -110,10 +111,6 @@ export class AgentBotCommands {
         return new AgentBotCommands(context, chainConfig.agentBotSettings, owner, underlyingAddress, botConfig.orm, botConfig.notifiers);
     }
 
-    static getOwnerAddressPair(secrets: Secrets) {
-        return new OwnerAddressPair(secrets.required("owner.management.address"), secrets.required("owner.native.address"));
-    }
-
     notifierFor(agentVault: string) {
         return new AgentNotifier(agentVault, this.notifiers);
     }

packages/fasset-bots-core/src/commands/AgentBotOwnerValidation.ts

@@ -16,6 +16,7 @@ import { ZERO_ADDRESS, requireNotNull } from "../utils/helpers";
 import { logger } from "../utils/logger";
 import { artifacts, authenticatedHttpProvider, initWeb3, web3 } from "../utils/web3";
 import { ORM } from "../config/orm";
+import { AgentBot } from "../actors/AgentBot";
 
 const AgentOwnerRegistry = artifacts.require("AgentOwnerRegistry");
 
@@ -53,7 +54,7 @@ export class AgentBotOwnerValidation {
 
     static async create(secretsFile: string, configFileName: string, reporter: Reporter = throwingReporter) {
         const secrets = await Secrets.load(secretsFile);
-        const owner = new OwnerAddressPair(secrets.required("owner.management.address"), secrets.required("owner.native.address"));
+        const owner = AgentBot.ownerAddressPair(secrets);
         const configFile = loadConfigFile(configFileName);
         const apiKey = secrets.optional("apiKey.native_rpc");
         await initWeb3(authenticatedHttpProvider(configFile.rpcUrl, apiKey), [], null);
@@ -68,7 +69,7 @@ export class AgentBotOwnerValidation {
 
     static async fromContext(context: IAssetAgentContext, secretsFile: string, configFileName: string, reporter: Reporter = throwingReporter) {
         const secrets = await Secrets.load(secretsFile);
-        const owner = new OwnerAddressPair(secrets.required("owner.management.address"), secrets.required("owner.native.address"));
+        const owner = AgentBot.ownerAddressPair(secrets);
         const configFile = loadConfigFile(configFileName);
         const fassets = new Map<string, FAssetInstance>([[context.fAssetSymbol, context.fAsset]]);
         const botConfig = await createBotConfig("agent", secrets, configFile, owner.workAddress);
@@ -97,6 +98,7 @@ export class AgentBotOwnerValidation {
         this.reporter.log(`Verifying owner whitelisting...`);
         await AgentBotOwnerValidation.verifyAgentWhitelisted(this.agentOwnerRegistry, owner, this.reporter);
         this.reporter.log(`Verifying owner work address...`);
+        await owner.acceptWorkAddressAssignment(this.agentOwnerRegistry);
         await AgentBotOwnerValidation.verifyWorkAddress(this.agentOwnerRegistry, owner, this.reporter);
         await this.verifyOwnerManagementBalance(owner);
         await this.verifyOwnerWorkBalance(owner);

packages/fasset-bots-core/src/fasset/Agent.ts

@@ -1,6 +1,6 @@
 import { AddressValidity } from "@flarenetwork/state-connector-protocol";
 import BN from "bn.js";
-import { AgentVaultInstance, CollateralPoolInstance, CollateralPoolTokenInstance } from "../../typechain-truffle";
+import { AgentOwnerRegistryInstance, AgentVaultInstance, CollateralPoolInstance, CollateralPoolTokenInstance } from "../../typechain-truffle";
 import {
     AgentAvailable,
     AgentDestroyed,
@@ -35,13 +35,22 @@ const IERC20 = artifacts.require("IERC20");
 
 export class OwnerAddressPair {
     constructor(
-        public managementAddress: string,
-        public workAddress: string,
+        public readonly managementAddress: string,
+        public readonly workAddress: string,
     ) {}
 
     toString() {
         return `${this.managementAddress} with work address ${this.workAddress}`;
     }
+
+    async acceptWorkAddressAssignment(agentOwnerRegistry: AgentOwnerRegistryInstance) {
+        const currentWorkAddress = await agentOwnerRegistry.getWorkAddress(this.managementAddress);
+        if (currentWorkAddress === this.workAddress) return true;
+        const pendingWorkAddress = await agentOwnerRegistry.getPendingWorkAddress(this.managementAddress);
+        if (pendingWorkAddress !== this.workAddress) return false;
+        await agentOwnerRegistry.acceptWorkAddressAssignment(this.managementAddress, { from: this.workAddress });
+        return true;
+    }
 }
 
 export class Agent {
@@ -77,13 +86,11 @@ export class Agent {
         return getAgentSettings(agentInfo);
     }
 
-
     async getAgentSetting(settingsName: string): Promise<BN | string> {
         const settings = await this.assetManager.getAgentSetting(this.vaultAddress, settingsName)
         return settings;
     }
 
-
     async getAgentInfo(): Promise<AgentInfo> {
         return await this.assetManager.getAgentInfo(this.agentVault.address);
     }

packages/fasset-bots-core/test-hardhat/integration/agentBot.ts

@@ -27,6 +27,7 @@ import { FaultyNotifierTransport } from "../test-utils/FaultyNotifierTransport";
 import { TestAssetBotContext, createTestAssetContext } from "../test-utils/create-test-asset-context";
 import { loadFixtureCopyVars } from "../test-utils/hardhat-test-helpers";
 import { QUERY_WINDOW_SECONDS, convertFromUSD5, createCRAndPerformMinting, createCRAndPerformMintingAndRunSteps, createTestAgent, createTestAgentAndMakeAvailable, createTestAgentBotAndMakeAvailable, createTestMinter, createTestRedeemer, getAgentStatus, mintVaultCollateralToOwner, runWithManualFDCFinalization, updateAgentBotUnderlyingBlockProof } from "../test-utils/helpers";
+import { OwnerAddressPair } from "../../src/fasset/Agent";
 use(spies);
 
 const IERC20 = artifacts.require("IERC20");
@@ -50,12 +51,16 @@ describe("Agent bot tests", () => {
 
     async function testWhitelistAndSetWorkAddress(agentOwnerRegistry: AgentOwnerRegistryInstance, managementAddress: string, managementPrivateKey: string, workAddress: string) {
         await agentOwnerRegistry.whitelistAndDescribeAgent(managementAddress, "Agent Name", "Agent Description", "Icon", "URL");
+        // set work address, signing it "externally" with management private key
         const methodAbi = requireNotNull(agentOwnerRegistry.abi.find(it => it.name === "setWorkAddress"));
         const data = web3.eth.abi.encodeFunctionCall(methodAbi, [workAddress]);
         const account = web3.eth.accounts.privateKeyToAccount(managementPrivateKey);
         assert.equal(account.address, managementAddress);
         const signedTx = await web3.eth.accounts.signTransaction({ from: managementAddress, to: agentOwnerRegistry.address, data: data, gas: 100000 }, managementPrivateKey);
         await web3.eth.sendSignedTransaction(requireNotNull(signedTx.rawTransaction));
+        // accept work address
+        const owner = new OwnerAddressPair(managementAddress, workAddress);
+        await owner.acceptWorkAddressAssignment(agentOwnerRegistry);
     }
 
     before(async () => {

packages/fasset-bots-core/test-hardhat/integration/runner-and-commands.ts

@@ -29,9 +29,8 @@ describe("Toplevel runner and commands integration test", () => {
     const loopDelay = 100; // ms
     let accounts: string[];
     let orm: ORM;
-    let ownerManagementAddress: string;
+    let owner: OwnerAddressPair;
     const ownerUnderlyingAddress = "owner_underlying_1";
-    let ownerWorkAddress: string;
     let userAddress: string;
     let submitterAddress: string;
     const userUnderlyingAddress = "user_underlying_1";
@@ -118,8 +117,7 @@ describe("Toplevel runner and commands integration test", () => {
     }
 
     function createAgentCommands(context: IAssetAgentContext) {
-        const ownerAddressPair = new OwnerAddressPair(ownerManagementAddress, ownerWorkAddress);
-        return new AgentBotCommands(context, agentBotSettings, ownerAddressPair, ownerUnderlyingAddress, orm, testNotifierTransports);
+        return new AgentBotCommands(context, agentBotSettings, owner, ownerUnderlyingAddress, orm, testNotifierTransports);
     }
 
     async function createUserCommands(context: IAssetAgentContext) {
@@ -128,8 +126,7 @@ describe("Toplevel runner and commands integration test", () => {
 
     before(async () => {
         accounts = await web3.eth.getAccounts();
-        ownerManagementAddress = accounts[2];
-        ownerWorkAddress = accounts[3];
+        owner = new OwnerAddressPair(accounts[2], accounts[3]);
         userAddress = accounts[4];
         submitterAddress = accounts[5];
     });
@@ -142,7 +139,7 @@ describe("Toplevel runner and commands integration test", () => {
         const fdcHub = await FdcHub.at(contracts.FdcHub.address);
         const flareDataConnectorClient = new MockFlareDataConnectorClient(fdcHub, relay, {}, "auto", submitterAddress);
         // secrets
-        secrets = createTestSecrets(testChainInfos.map(ci => ci.chainId), ownerManagementAddress, ownerWorkAddress, ownerUnderlyingAddress);
+        secrets = createTestSecrets(testChainInfos.map(ci => ci.chainId), owner.managementAddress, owner.workAddress, ownerUnderlyingAddress);
         // create contexts
         for (const chainInfo of testChainInfos) {
             const chain = await getOrCreateAsync(chains, chainInfo.chainId, () => createTestChain(chainInfo));
@@ -152,22 +149,23 @@ describe("Toplevel runner and commands integration test", () => {
         }
         // set work address mapping
         const context0 = firstValue(contexts)!;
-        await context0.agentOwnerRegistry.whitelistAndDescribeAgent(ownerManagementAddress, "Agent Name", "Agent Description", "Icon", "URL");
-        await context0.agentOwnerRegistry.setWorkAddress(ownerWorkAddress, { from: ownerManagementAddress });
+        await context0.agentOwnerRegistry.whitelistAndDescribeAgent(owner.managementAddress, "Agent Name", "Agent Description", "Icon", "URL");
+        await context0.agentOwnerRegistry.setWorkAddress(owner.workAddress, { from: owner.managementAddress });
+        await owner.acceptWorkAddressAssignment(context0.agentOwnerRegistry);
         // decrease setting change time
         const assetManagers = await context0.assetManagerController.getAssetManagers();
         const resSetUpd = await context0.assetManagerController.setAgentFeeChangeTimelockSeconds(assetManagers, 300);
         await waitForTimelock(resSetUpd, context0.assetManagerController, await context0.assetManagerController.governance());
         // timekeeper
-        timekeeperService = new TimeKeeperService(contexts, ownerWorkAddress, testTimekeeperTimingConfig({ loopDelayMs: loopDelay }));
+        timekeeperService = new TimeKeeperService(contexts, owner.workAddress, testTimekeeperTimingConfig({ loopDelayMs: loopDelay }));
         // agent bot runner
         botRunner = new AgentBotRunner(secrets, contexts, agentBotSettingsMap, orm, loopDelay, testNotifierTransports, timekeeperService);
         // currencies
         const usdc = context0.stablecoins.usdc as FakeERC20Instance;
         usdcCurrency = await Currencies.erc20(usdc as IERC20MetadataInstance);
         xrpCurrency = Currencies.chain(testXrpChainInfo);
         // mint some collaterals to owner
-        await usdc.mintAmount(ownerWorkAddress, usdcCurrency.parse("1000"));
+        await usdc.mintAmount(owner.workAddress, usdcCurrency.parse("1000"));
         // mint some underlying
         for (const chain of chains.values()) {
             // to owner