eulith-web3js-core
Version:
Eulith core web3js SDK (code to access Eulith services via web3js)
374 lines • 63.3 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.OnChainAgents = void 0;
const protocol_kit_1 = require("@safe-global/protocol-kit");
const assert_1 = require("assert");
const safe_core_sdk_1 = __importDefault(require("@safe-global/safe-core-sdk"));
const Eulith = __importStar(require("../src/index"));
// note returns contract_type, but doesn't filter on contract_type
function fetchContractDetailsForAuthorizedAddress_(provider, authorizedAddress) {
return __awaiter(this, void 0, void 0, function* () {
const authorizedAddressLC = authorizedAddress.toLowerCase();
const result = yield provider.request({ method: "eulith_get_contracts", params: [] });
const firstMatch = result == null
? null
: result["contracts"].find((contract) => contract.authorized_address.toLowerCase() == authorizedAddressLC);
if (firstMatch) {
return {
contract_address: firstMatch === null || firstMatch === void 0 ? void 0 : firstMatch.contract_address,
authorized_address: firstMatch === null || firstMatch === void 0 ? void 0 : firstMatch.authorized_address,
safe_address: firstMatch === null || firstMatch === void 0 ? void 0 : firstMatch.safe_address,
contract_type: firstMatch === null || firstMatch === void 0 ? void 0 : firstMatch.contract_type,
network_name: firstMatch === null || firstMatch === void 0 ? void 0 : firstMatch.network_name,
chain_id: firstMatch === null || firstMatch === void 0 ? void 0 : firstMatch.chain_id
};
}
else {
throw new Error(`No agent found for the authorized address: ${authorizedAddress}; did you call Eulith.OnChainAgents.createUncheckedAgent, or Eulith.OnChainAgents.createArmorAgent, or Eulith.OnChainAgents.getAgent(createUncheckedAgentIfNoneExists)?`);
}
});
}
function createUnchecked_(provider, authorizedAddress) {
return __awaiter(this, void 0, void 0, function* () {
const result = yield provider.request({
method: "eulith_new_contract",
params: [{ authorized_address: authorizedAddress }]
});
return result === null || result === void 0 ? void 0 : result.contract_address; // should never return null - caller checks
});
}
/**
* OnChainAgents are smart contracts employed mostly transparently to execute programmed sequences
* of ethereum transactions on your behelf.
*
* OnChainAgents are key to how AtomicTx (atomic transactions) work, for example, but other facilities also
* leverage this special contract.
*
* Frequently, the Eulith APIs manage these OnChainAgents completely transparently, and it can be ignored.
* But, in some cases, the user must be aware of the agent (contract) (for example, to approve transfers).
*
* Typically, all the user will need to know is, occasionally, to get information about the agent (like its contract address)
* via accessing its object:
* const contractAddress: string = Eulith.OnChainAgents.getAgent({provider, authorizedAddress}).contractAddress OR
* const contractAddress: string = Eulith.OnChainAgents.getAgent({provider, authoriziedSigner}).contractAddress
*/
var OnChainAgents;
(function (OnChainAgents) {
/**
* @typedef Eulith.OnChainAgents.Type
*/
let Type;
(function (Type) {
/**
* An Unchecked Agent is the historical one, basic one, of of pre-april 2023.
*
* It provides less checking and security than the armor contracts.
*
* Associated value 'call' is historical.
*/
Type["Unchecked"] = "call";
/**
* An Armor Agent is one that uses a Safe (see URL)
*/
Type["Armor"] = "armor";
})(Type = OnChainAgents.Type || (OnChainAgents.Type = {}));
/**
* Eulith.OnChainAgents.getAgent
*
* Fetch the current agent refernece for the argument authorized address (or authoriziedSigner).
* provider (maybe Eulith.Provider | Eulith.Web3) used to communicate with the Ethereum network.
* createUncheckedAgentIfNoneExists - defaults to true if not specified.
*
* Note - there can never be more than one IAgent associated with a given authorizedAddress.
*
* See also Eulith.OnChainAgents.createUncheckedAgent
* See also Eulith.OnChainAgents.createArmorAgent
*/
function getAgent({ provider, authorizedAddress, authoriziedSigner, createUncheckedAgentIfNoneExists }) {
return __awaiter(this, void 0, void 0, function* () {
const useProvider = Eulith.Provider.ProviderOrWeb3(provider);
const useAuthorizedAddress = authorizedAddress !== null && authorizedAddress !== void 0 ? authorizedAddress : authoriziedSigner.address;
try {
const r = yield fetchContractDetailsForAuthorizedAddress_(useProvider, useAuthorizedAddress);
switch (r.contract_type) {
case "call":
return new UncheckedAgent_(r.contract_address, useAuthorizedAddress);
case "armor":
return new ArmorAgent_(r.contract_address, useAuthorizedAddress, r.safe_address);
default:
throw new Error("getAgent: unrecognized contract-type");
}
}
catch (e) {
if (createUncheckedAgentIfNoneExists !== null && createUncheckedAgentIfNoneExists !== void 0 ? createUncheckedAgentIfNoneExists : true) {
return yield createUncheckedAgent({ provider: useProvider, authorizedAddress: useAuthorizedAddress });
}
}
return null;
});
}
OnChainAgents.getAgent = getAgent;
/**
* Eulith.OnChainAgents.createUncheckedAgent is provided for logical consistency, but typically won't be used directly - instead - just use Eulith.OnChainAgents.getAgent();
*
* Note this routine will fail if the agent already exists (another reason to just call Eulith.OnChainAgents.getAgent ())
*/
function createUncheckedAgent({ provider, authorizedAddress }) {
return __awaiter(this, void 0, void 0, function* () {
const useProvider = Eulith.Provider.ProviderOrWeb3(provider);
const constractAddress = yield createUnchecked_(useProvider, authorizedAddress);
return new UncheckedAgent_(constractAddress, authorizedAddress);
});
}
OnChainAgents.createUncheckedAgent = createUncheckedAgent;
/**
* Eulith.OnChainAgents.createArmorAgent
*
* A Eulith 'armor' agent, is like any Eulith agent, allowing you to automate a sequence of operations on the
* Ethereum network, but in this case, much of that automation is actually performed by a 'safe' <https://safe.global/>
*
* This creation process may optionally either create your safe, or re-use an existing safe. But either way, it registers
* a Eulith armor agent as a module on that safe, allowing it to direct the safe to perform transactions on it's behalf
* (transitively on your behalf, triggered by your use of an 'authorizedSigner').
*
* You own/control that authorizedSigner. This allows the safe to operated by a SINGLE signer, instead of the requiring the N (safe threshold)
* signers.
*
* The basic process is:
*
* - construct an armor contract with this API (passing in a safe, or the data needed to create a safe).
* - get the owners of the safe to 'sign' the request to enable the Eulith Armor agent.
* - enableArmor () - which completes the setup - activating your safe and your authorized signers ability to use it
* - then start using your authorized signer - its now allowed to use the contents of this safe.
*
* provider is the Eulith provider Ethereum network provider (or a Eulith.Web from which a provider can be extracted)
*
* authorizedAddress is the address of some user-controlled signer (typically KMS-based, for example),
* which will be used to OPERATE and make requests on some associated safe (via the armor agent).
*
* safeAddress is the address of the existing safe to associate with the new armor, and if null or omitted
* a new safe will be automatically created.
*
* NOTE, if safeAddress is not specified, the safe will be automatically created by the Eulith server
* and owners etc calculated automatically.
*
* setupSigner: a signer is needed to send any ethereum transaction message, but which one is used here does not matter, except that it pays the
* gas for this setup transaction.
*
* Note - this will FAIL if any Eulith Agent already exists for this authorizedAddress.
*
* Exactly one of safeAddress (case of existing safe), or safeCreationParamters, must be provided (NOTE KRISTIAN - THIS IS A DEPARTURE FROM YOUR CURRENT API - A SUGGESTION).
*/
function createArmorAgent({ provider, authorizedAddress, safeAddress, setupSigner }) {
return __awaiter(this, void 0, void 0, function* () {
const useProvider = Eulith.Provider.ProviderOrWeb3(provider);
assert_1.strict.notEqual(provider, null, "provider is required for Eulith.OnChainAgents.createArmorAgent");
assert_1.strict.notEqual(authorizedAddress, null, "authorizedAddress is required for Eulith.OnChainAgents.createArmorAgent");
assert_1.strict.notEqual(setupSigner, null, "setupSigner is required for Eulith.OnChainAgents.createArmorAgent");
function createArmorContractInEulith(provider, authorizedAddress, preexistingSafeAddress) {
return __awaiter(this, void 0, void 0, function* () {
// @Kristian/Moh/Ian: I suggest replacing the safe_already_exists parameter with a preexisting_save_address parameter, which can be null
const result = yield provider.request({
method: "eulith_new_contract",
params: [
{
authorized_address: authorizedAddress,
contract_type: "armor",
safe_already_exists: preexistingSafeAddress != null
}
]
});
return new Eulith.Signing.UnsignedTransaction(result);
});
}
// Create the armor contract.
// First create it in the eulith db, and that then generates some gorp to be run on the ethereum network to complete
// the setup (creates various contract instances - I'm guessing). Though this CODE be done inside the Eulith call
// server, it isn't for gas cost reasons.
const preexistingSafeAddress = safeAddress;
const contractCreateTx = yield createArmorContractInEulith(useProvider, authorizedAddress, preexistingSafeAddress);
// const txHash: string = (await contractCreateTx.signAndSendAndWait(setupSigner, useProvider)).transactionHash;
const useSetupSigner = Eulith.Signing.SigningService.assure(setupSigner, useProvider);
const txHash = (yield useSetupSigner.sendTransactionAndWait(contractCreateTx)).transactionHash;
function eulithSubmitArmorHash(provider, txHash, preexistingSafeAddress) {
return __awaiter(this, void 0, void 0, function* () {
const result = yield provider.request({
method: "eulith_submit_armor_hash",
params: [{ tx_hash: txHash, safe_address: preexistingSafeAddress !== null && preexistingSafeAddress !== void 0 ? preexistingSafeAddress : undefined }]
});
if (result != true) {
throw new Error("eulith_submit_armor_hash failed");
}
});
}
yield eulithSubmitArmorHash(useProvider, txHash, preexistingSafeAddress);
const r = yield getAgent({ provider, authorizedAddress });
assert_1.strict.equal(r.type, Type.Armor, "internal error: agent associasted with this address is not an armor agent");
return r;
});
}
OnChainAgents.createArmorAgent = createArmorAgent;
/**
* Eulith.OnChainAgents.contractAddress
*
* Shorthand for getAgent(...sameargs).contractAddress
*/
function contractAddress({ provider, authorizedAddress, authoriziedSigner, createUncheckedAgentIfNoneExists }) {
return __awaiter(this, void 0, void 0, function* () {
return (yield getAgent({ provider, authorizedAddress, authoriziedSigner, createUncheckedAgentIfNoneExists }))
.contractAddress;
});
}
OnChainAgents.contractAddress = contractAddress;
/**
* Eulith.OnChainAgents.armorAgent
*
* Access the existing armor agent for authorized address/signer: Shorthand for getAgent(...sameargs) - check is right type, and return it as IArmorAgent
*
* note - never returns null, or creates anything - just returns the existing agent, or throws
*/
function armorAgent({ provider, authorizedAddress, authoriziedSigner }) {
return __awaiter(this, void 0, void 0, function* () {
const agent = yield getAgent({
provider,
authorizedAddress,
authoriziedSigner,
createUncheckedAgentIfNoneExists: false
});
assert_1.strict.equal(agent.type, Type.Armor, "Eulith.OnChainAgents.armorAgent found agent but not armor agent");
return agent;
});
}
OnChainAgents.armorAgent = armorAgent;
class UncheckedAgent_ {
constructor(contractAddress, authorizedAddress) {
this.contractAddress_ = contractAddress;
this.authorizedAddress_ = authorizedAddress;
}
get type() {
return Type.Unchecked;
}
get contractAddress() {
return this.contractAddress_;
}
get authorizedAddress() {
return this.authorizedAddress_;
}
}
class ArmorAgent_ {
constructor(contractAddress, authorizedAddress, safeAddress) {
this.contractAddress_ = contractAddress;
this.authorizedAddress_ = authorizedAddress;
this.safeAddress_ = safeAddress;
}
authorizeForOwner({ provider, authorizingOwner }) {
var _a;
return __awaiter(this, void 0, void 0, function* () {
if (this.authorizedAddress_ == authorizingOwner.address) {
(_a = provider.logger) === null || _a === void 0 ? void 0 : _a.log(Eulith.Logging.LogLevel.WARNING, `Generally ill-advised, having the same owner be authorized address and owner`);
}
const useProvider = Eulith.Provider.ProviderOrWeb3(provider);
const useAuthorizingOwner = Eulith.Signing.SigningService.assure(authorizingOwner, provider);
const ethAdapter = new protocol_kit_1.Web3Adapter({
web3: new Eulith.Web3({ provider: useProvider, signer: useAuthorizingOwner }),
signerAddress: useAuthorizingOwner.address
});
const agentContractInfo = yield fetchContractDetailsForAuthorizedAddress_(useProvider, this.authorizedAddress_);
if (agentContractInfo.contract_type != "armor") {
throw new Error(`No armor contract found for the authorized address: ${this.authorizedAddress_}; did you call createArmor?`);
}
let safeAddress = agentContractInfo.safe_address;
let armorAddress = agentContractInfo.contract_address;
const safe = yield safe_core_sdk_1.default.create({ ethAdapter, safeAddress });
const enableModuleTx = yield safe.createEnableModuleTx(armorAddress);
const signature = yield safe.signTypedData(enableModuleTx);
function submitEnableModuleSignature(provider, signature, moduleAddress, ownerAddress) {
return __awaiter(this, void 0, void 0, function* () {
const result = yield provider.request({
method: "eulith_submit_enable_safe_signature",
params: [{ signature, module_address: moduleAddress, owner_address: ownerAddress }]
});
});
}
yield submitEnableModuleSignature(useProvider, signature.data, armorAddress, authorizingOwner.address);
});
}
enableArmor({ provider, signerForThisTx, forSafe }) {
return __awaiter(this, void 0, void 0, function* () {
const useProvider = Eulith.Provider.ProviderOrWeb3(provider).cloneWithURLAdditions({
auth_address: this.authorizedAddress
});
if (forSafe.safeAddress) {
// const result = await provider.request({
// method: "eulith_submit_armor_hash",
// params: [{ signature, module_address: moduleAddress, owner_address: ownerAddress }]
// });
throw new Error("NYI");
}
else if (forSafe.newSafe.owners && forSafe.newSafe.approvalThreshold) {
const result = yield useProvider.request({
method: "eulith_enable_safe_tx",
params: [{ owners: forSafe.newSafe.owners, owner_threshold: forSafe.newSafe.approvalThreshold }]
});
// @todo document/rethink this use of defaultSigner
// const txHash = await useProvider.signAndSendTransaction(result, signerForThisTx);
const txHash = yield Eulith.Signing.SigningService.assure(signerForThisTx, provider).sendTransaction(result);
// @kristian - UNCLEAR if we need to wait for this tx, so assuming yes. But sample rust code I looked at didn't
yield Eulith.Utils.waitForTxReceipt({ provider: useProvider, txHash });
// I THINK that's it - and we have enabled the armor?
}
else {
throw new Error("enableArmor requires either forSafe.safeAddress or forSafe.newSafe parameters to be filled out");
}
});
}
get type() {
return Type.Armor;
}
get safeAddress() {
return this.safeAddress_;
}
get contractAddress() {
return this.contractAddress_;
}
get authorizedAddress() {
return this.authorizedAddress_;
}
}
})(OnChainAgents = exports.OnChainAgents || (exports.OnChainAgents = {}));
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"on-chain-agents.js","sourceRoot":"","sources":["../../src/on-chain-agents.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionConfig } from \"web3-core\";\nimport { SafeTransaction, SafeSignature, EthAdapter } from \"@safe-global/safe-core-sdk-types\";\nimport { Web3Adapter } from \"@safe-global/protocol-kit\";\nimport { strict as assert } from \"assert\";\nimport Safe from \"@safe-global/safe-core-sdk\";\n\nimport * as Eulith from \"../src/index\";\n\n// note returns contract_type, but doesn't filter on contract_type\nasync function fetchContractDetailsForAuthorizedAddress_(provider: Eulith.Provider, authorizedAddress: string) {\n    const authorizedAddressLC = authorizedAddress.toLowerCase();\n    const result = await provider.request({ method: \"eulith_get_contracts\", params: [] });\n    const firstMatch =\n        result == null\n            ? null\n            : result[\"contracts\"].find((contract) => contract.authorized_address.toLowerCase() == authorizedAddressLC);\n    if (firstMatch) {\n        return {\n            contract_address: firstMatch?.contract_address,\n            authorized_address: firstMatch?.authorized_address,\n            safe_address: firstMatch?.safe_address,\n            contract_type: firstMatch?.contract_type,\n            network_name: firstMatch?.network_name,\n            chain_id: firstMatch?.chain_id\n        };\n    } else {\n        throw new Error(\n            `No agent found for the authorized address: ${authorizedAddress}; did you call Eulith.OnChainAgents.createUncheckedAgent, or Eulith.OnChainAgents.createArmorAgent, or Eulith.OnChainAgents.getAgent(createUncheckedAgentIfNoneExists)?`\n        );\n    }\n}\n\nasync function createUnchecked_(provider: Eulith.Provider, authorizedAddress: string): Promise<string> {\n    const result = await provider.request({\n        method: \"eulith_new_contract\",\n        params: [{ authorized_address: authorizedAddress }]\n    });\n    return result?.contract_address; // should never return null - caller checks\n}\n\n/**\n *  OnChainAgents are smart contracts employed mostly transparently to execute programmed sequences\n *  of ethereum transactions on your behelf.\n *\n *  OnChainAgents are key to how AtomicTx (atomic transactions) work, for example, but other facilities also\n *  leverage this special contract.\n *\n *  Frequently, the Eulith APIs manage these OnChainAgents completely transparently, and it can be ignored.\n *  But, in some cases, the user must be aware of the agent (contract) (for example,  to approve transfers).\n *\n *  Typically, all the user will need to know is, occasionally, to get information about the agent (like its contract address)\n *  via accessing its object:\n *      const contractAddress: string = Eulith.OnChainAgents.getAgent({provider, authorizedAddress}).contractAddress    OR\n *      const contractAddress: string = Eulith.OnChainAgents.getAgent({provider, authoriziedSigner}).contractAddress\n */\nexport module OnChainAgents {\n    /**\n     *  @typedef Eulith.OnChainAgents.Type\n     */\n    export enum Type {\n        /**\n         *  An Unchecked Agent is the historical one, basic one, of of pre-april 2023.\n         *\n         *  It provides less checking and security than the armor contracts.\n         *\n         *  Associated value 'call' is historical.\n         */\n        Unchecked = \"call\",\n\n        /**\n         *  An Armor Agent is one that uses a Safe (see URL)\n         */\n        Armor = \"armor\"\n    }\n\n    /**\n     *  @typedef Eulith.OnChainAgents.IAgent\n     *\n     *     An Agent is a Eulith object that lives on the Ethereum network (its a special contract instance), that can act on its 'owners' (really authorized address) behalf.\n     *\n     * All you need is to be able to sign requests using the signer (with the address == the authorized address).\n     *\n     * Then you can combine multiple transactions into atomic transactions, and perform other delegating actions through the agent.\n     */\n    export interface IAgent {\n        readonly type: Type;\n        readonly contractAddress: string;\n        readonly authorizedAddress: string;\n\n        // // An API LIKE this would probably be Safe, and reasonable, and perhaps useful, but not a priority at this Time; included merely as a comment\n        // // To make the structure of this code/design more clear\n        // // The Function of the API would be to unregister the associated contract and free-up and resources used by it, and allow the signer to be\n        // // used in a new style argent (e.g switch fron Unchecked agent to armor agent).\n        // removeAgent({ provider,   authorizedSigner }: { provider: Eulith.Provider | Eulith.Web3;  authorizedSigner: Eulith.Signing.SigningService | Eulith.Signing.ICryptographicSigner; }): Promise<void>;\n    }\n\n    /**\n     *  @typedef Eulith.OnChainAgents.IArmorAgent\n     */\n    export interface IArmorAgent extends IAgent {\n        /**\n         *  An armor agent is associated with a (gnosis) safe on the ethereum blockchain network. This is the safeAddress (ethereum address)\n         *  of the safe.\n         */\n        readonly safeAddress: string;\n\n        /**\n         *  authorizingOwner (owner of the safe) authorizes this armorAgent to utilize its associated safe. The authorizingOwner\n         *  signer will be asked to sign a structure which permits the authorizedSigner associated with this agent\n         *  to utilize the safe as it sees fit.\n         *\n         *      @todo: SUGGESTED CHANGE TO EXISTING SEMANTICS:\n         *          authorizingOwner.address must already be listed as an owner of the safe.\n         *\n         *  NOTE - authorizingOwner must support signTypedData (i.e. have a non-null typedDataSigner property of SigningService or be a ICryptographicSigner)\n         */\n        authorizeForOwner({\n            provider,\n            authorizingOwner\n        }: {\n            provider: Eulith.Provider | Eulith.Web3;\n            authorizingOwner: Eulith.Signing.ICryptographicSigner | Eulith.Signing.SigningService;\n        }): Promise<void>;\n\n        /**\n         *  perform the various transactions required to enable the armor for the argument safe.\n         *\n         *  This requires signerForThisTx, to actuate this operation, and pay the gas for the transaction. But\n         *  signerForThisTx may be any signer, not connected to the safe.\n         *\n         *  @todo some future version of this API may move the 'forSafe' object to the createArmor call\n         */\n        enableArmor({\n            provider,\n            signerForThisTx,\n            forSafe\n        }: {\n            provider: Eulith.Provider | Eulith.Web3;\n            signerForThisTx: Eulith.Signing.ICryptographicSigner | Eulith.Signing.SigningService;\n            forSafe: { safeAddress?: string; newSafe?: { owners: string[]; approvalThreshold: number } };\n        }): Promise<void>;\n    }\n\n    /**\n     *  Eulith.OnChainAgents.getAgent\n     *\n     *  Fetch the current agent refernece for the argument authorized address (or authoriziedSigner).\n     *  provider (maybe Eulith.Provider | Eulith.Web3) used to communicate with the Ethereum network.\n     *  createUncheckedAgentIfNoneExists - defaults to true if not specified.\n     *\n     *   Note - there can never be more than one IAgent associated with a given authorizedAddress.\n     *\n     *  See also Eulith.OnChainAgents.createUncheckedAgent\n     *  See also Eulith.OnChainAgents.createArmorAgent\n     */\n    export async function getAgent({\n        provider,\n        authorizedAddress,\n        authoriziedSigner,\n        createUncheckedAgentIfNoneExists\n    }: {\n        provider: Eulith.Provider | Eulith.Web3;\n        authorizedAddress?: string;\n        authoriziedSigner?: Eulith.Signing.SigningService | Eulith.Signing.ICryptographicSigner;\n        createUncheckedAgentIfNoneExists?: boolean;\n    }): Promise<IAgent> {\n        const useProvider = Eulith.Provider.ProviderOrWeb3(provider);\n        const useAuthorizedAddress = authorizedAddress ?? authoriziedSigner.address;\n        try {\n            const r = await fetchContractDetailsForAuthorizedAddress_(useProvider, useAuthorizedAddress);\n            switch (r.contract_type) {\n                case \"call\":\n                    return new UncheckedAgent_(r.contract_address, useAuthorizedAddress);\n                case \"armor\":\n                    return new ArmorAgent_(r.contract_address, useAuthorizedAddress, r.safe_address);\n                default:\n                    throw new Error(\"getAgent: unrecognized contract-type\");\n            }\n        } catch (e) {\n            if (createUncheckedAgentIfNoneExists ?? true) {\n                return await createUncheckedAgent({ provider: useProvider, authorizedAddress: useAuthorizedAddress });\n            }\n        }\n        return null;\n    }\n\n    /**\n     *  Eulith.OnChainAgents.createUncheckedAgent is provided for logical consistency, but typically won't be used directly - instead - just use Eulith.OnChainAgents.getAgent();\n     *\n     *   Note this routine will fail if the agent already exists (another reason to just call Eulith.OnChainAgents.getAgent ())\n     */\n    export async function createUncheckedAgent({\n        provider,\n        authorizedAddress\n    }: {\n        provider: Eulith.Provider | Eulith.Web3;\n        authorizedAddress: string;\n    }): Promise<IAgent> {\n        const useProvider = Eulith.Provider.ProviderOrWeb3(provider);\n        const constractAddress = await createUnchecked_(useProvider, authorizedAddress);\n        return new UncheckedAgent_(constractAddress, authorizedAddress);\n    }\n\n    /**\n     *  Eulith.OnChainAgents.createArmorAgent\n     *\n     *  A Eulith 'armor' agent, is like any Eulith agent, allowing you to automate a sequence of operations on the\n     *  Ethereum network, but in this case, much of that automation is actually performed by a 'safe' <https://safe.global/>\n     *\n     *  This creation process may optionally either create your safe, or re-use an existing safe. But either way, it registers\n     *  a Eulith armor agent as a module on that safe, allowing it to direct the safe to perform transactions on it's behalf\n     *  (transitively on your behalf, triggered by your use of an 'authorizedSigner').\n     *\n     *  You own/control that authorizedSigner. This allows the safe to operated by a SINGLE signer, instead of the requiring the N (safe threshold)\n     *  signers.\n     *\n     *  The basic process is:\n     *\n     *      -   construct an armor contract with this API (passing in a safe, or the data needed to create a safe).\n     *      -   get the owners of the safe to 'sign' the request to enable the Eulith Armor agent.\n     *      -   enableArmor () - which completes the setup - activating your safe and your authorized signers ability to use it\n     *      -   then start using your authorized signer - its now allowed to use the contents of this safe.\n     *\n     *  provider is the Eulith provider Ethereum network provider (or a Eulith.Web from which a provider can be extracted)\n     *\n     *  authorizedAddress is the address of some user-controlled signer (typically KMS-based, for example),\n     *      which will be used to OPERATE and make requests on some associated safe (via the armor agent).\n     *\n     *  safeAddress is the address of the existing safe to associate with the new armor, and if null or omitted\n     *      a new safe will be automatically created.\n     *\n     *  NOTE, if safeAddress is not specified, the safe will be automatically created by the Eulith server\n     *  and owners etc calculated automatically.\n     *\n     *  setupSigner: a signer is needed to send any ethereum transaction message, but which one is used here does not matter, except that it pays the\n     *  gas for this setup transaction.\n     *\n     *  Note - this will FAIL if any Eulith Agent already exists for this authorizedAddress.\n     *\n     *  Exactly one of safeAddress (case of existing safe), or safeCreationParamters, must be provided (NOTE KRISTIAN - THIS IS A DEPARTURE FROM YOUR CURRENT API - A SUGGESTION).\n     */\n    export async function createArmorAgent({\n        provider,\n        authorizedAddress,\n        safeAddress,\n        setupSigner\n    }: {\n        provider: Eulith.Provider | Eulith.Web3;\n        authorizedAddress: string;\n        safeAddress?: string;\n        setupSigner: Eulith.Signing.ICryptographicSigner | Eulith.Signing.SigningService;\n    }): Promise<IAgent> {\n        const useProvider = Eulith.Provider.ProviderOrWeb3(provider);\n\n        assert.notEqual(provider, null, \"provider is required for Eulith.OnChainAgents.createArmorAgent\");\n        assert.notEqual(\n            authorizedAddress,\n            null,\n            \"authorizedAddress is required for Eulith.OnChainAgents.createArmorAgent\"\n        );\n        assert.notEqual(setupSigner, null, \"setupSigner is required for Eulith.OnChainAgents.createArmorAgent\");\n\n        async function createArmorContractInEulith(\n            provider: Eulith.Provider,\n            authorizedAddress: string,\n            preexistingSafeAddress?: string\n        ): Promise<Eulith.Signing.UnsignedTransaction> {\n            // @Kristian/Moh/Ian: I suggest replacing the safe_already_exists parameter with a preexisting_save_address parameter, which can be null\n            const result = await provider.request({\n                method: \"eulith_new_contract\",\n                params: [\n 