@defisaver/sdk 1.0.0 → 1.0.1

package/esm/src/Action.js

@@ -0,0 +1,193 @@
+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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Action_instances, _Action__getArgumentMappingWithSlots, _Action__getPlaceholderForType;
+import AbiCoder from 'web3-eth-abi';
+import { keccak256, padLeft, toHex } from 'web3-utils';
+import { CONFIG } from './config';
+import ActionAbi from './abis/Action.json';
+import { AccessLists } from '../AccessLists';
+/**
+ * Single action that can be executed directly, or combined into a set (ie. supply a vault)
+ *
+ * @category Base Classes
+ */
+export class Action {
+    /**
+     * @param name
+     * @param contractAddress
+     * @param paramTypes
+     * @param args
+     */
+    constructor(name, contractAddress, paramTypes, args) {
+        // if (new.target === Action) throw new TypeError("Actions are instantiated using derived classes");
+        _Action_instances.add(this);
+        if (paramTypes.length !== args.length)
+            throw new Error('Parameters/arguments length mismatch');
+        this.contractAddress = contractAddress;
+        this.paramTypes = paramTypes;
+        this.name = name;
+        this.args = args;
+        this.mappableArgs = args; // TODO change to class method
+    }
+    /**
+     *
+     */
+    getId() {
+        return keccak256(this.name).substr(0, 10);
+    }
+    /**
+    *
+    */
+    _getArgumentMapping() {
+        return this.mappableArgs.map(arg => {
+            if (new RegExp(/\$\d+/).test(arg)) {
+                if (Array.isArray(arg))
+                    throw TypeError('Input can\'t be mapped to arrays (tuples/structs). Specify `mappableArgs` array in constructor.');
+                return parseInt(arg.substr(1));
+            }
+            return 0;
+        });
+    }
+    /**
+     *
+     */
+    _replaceWithPlaceholders(arg, paramType) {
+        if (Array.isArray(arg))
+            return arg.map((_arg, i) => this._replaceWithPlaceholders(_arg, paramType[i]));
+        if (typeof (paramType) === 'string') {
+            if (new RegExp(/\$\d+/).test(arg))
+                return __classPrivateFieldGet(this, _Action_instances, "m", _Action__getPlaceholderForType).call(this, paramType);
+            if (new RegExp(/&\w+/).test(arg))
+                return __classPrivateFieldGet(this, _Action_instances, "m", _Action__getPlaceholderForType).call(this, paramType);
+        }
+        return arg;
+    }
+    /**
+     *
+     */
+    _formatType(paramType) {
+        if (Array.isArray(paramType))
+            return `(${paramType.map((_paramType) => this._formatType(_paramType))})`;
+        return paramType;
+    }
+    /**
+     * Encode arguments for calling the action directly
+     * @returns bytes-encoded args
+     *
+     */
+    _encodeForCall() {
+        const _arg = this._replaceWithPlaceholders(this.args, this.paramTypes);
+        const _paramType = this._formatType(this.paramTypes);
+        return [AbiCoder.encodeParameter(_paramType, _arg)];
+    }
+    encodeForL2DsProxyCall() {
+        return this._encodeForCall()[0];
+    }
+    encodeForL2Recipe() {
+        return this._encodeForCall()[0];
+    }
+    /**
+     * Encode arguments for calling the action via DsProxy
+     * @returns `address` & `data` to be passed on to DSProxy's `execute(address _target, bytes memory _data)`
+     */
+    encodeForDsProxyCall() {
+        if (CONFIG.chainId === 1) {
+            const executeActionDirectAbi = (ActionAbi.find(({ name }) => name === 'executeActionDirect'));
+            return [
+                this.contractAddress,
+                AbiCoder.encodeFunctionCall(executeActionDirectAbi, this._encodeForCall()),
+            ];
+        }
+        else {
+            return [this.contractAddress, this.encodeForL2DsProxyCall()];
+        }
+    }
+    /**
+     * Encodes action for Recipe call
+     */
+    encodeForRecipe() {
+        return [
+            this._encodeForCall()[0],
+            "0x0000000000000000000000000000000000000000000000000000000000000000",
+            this.getId(),
+            this._getArgumentMapping(), // paramMappings
+        ];
+    }
+    encodeForStrategy(subSlots) {
+        return [
+            this.getId(),
+            __classPrivateFieldGet(this, _Action_instances, "m", _Action__getArgumentMappingWithSlots).call(this, subSlots), // paramMappings
+        ];
+    }
+    /**
+     * Assets requiring approval to be used by DsProxy
+     * Approval is done from owner to DsProxy
+     */
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    /**
+     * ETH value to be sent with transaction
+     * @returns ETH value in wei
+     */
+    getEthValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return '0';
+        });
+    }
+    /**
+     * Access list for single action
+     */
+    getAccessList(chainId) {
+        if (chainId != 1)
+            return [];
+        return [
+            [this.contractAddress, []],
+            ...(AccessLists[this.name] || []),
+        ].map(([address, storageKeys]) => ({
+            address: address,
+            storageKeys: storageKeys.map((num) => padLeft(toHex(num), 64)),
+        }));
+    }
+}
+_Action_instances = new WeakSet(), _Action__getArgumentMappingWithSlots = function _Action__getArgumentMappingWithSlots(subSlots) {
+    return this.mappableArgs.map(arg => {
+        if (new RegExp(/\$\d+/).test(arg)) {
+            if (Array.isArray(arg))
+                throw TypeError('Input can\'t be mapped to arrays (tuples/structs). Specify `mappableArgs` array in constructor.');
+            return parseInt(arg.substr(1));
+        }
+        // Handle SubSlots placeholder values in strategies
+        if (new RegExp(/&\w+/).test(arg)) {
+            if (arg === '&proxy')
+                return 254;
+            if (arg === '&eoa')
+                return 255;
+            return parseInt(subSlots[arg].index);
+        }
+        return 0;
+    });
+}, _Action__getPlaceholderForType = function _Action__getPlaceholderForType(type) {
+    // TODO handle arrays?
+    if (type.startsWith('bytes'))
+        return `0x${'0'.repeat(parseInt(type.substr(5)))}`;
+    if (type === 'address')
+        return `0x${'0'.repeat(40)}`;
+    if (type === 'string')
+        return '';
+    return '0';
+};

package/esm/src/ActionWithL2.d.ts

@@ -0,0 +1,20 @@
+import { Action } from './Action';
+/**
+ * Single L2 action that can be executed directly, or combined into a set (ie. supply a vault)
+ *
+ * @category Base Classes
+ */
+export declare class ActionWithL2 extends Action {
+    /**
+     * Encode arguments for calling the action via DsProxy
+     */
+    encodeForL2DsProxyCall(): string;
+    encodeForL2Recipe(): string;
+    encodeInputs(): string;
+    addressToBytes20(address: string): string;
+    boolToBytes1(bool: boolean): "01" | "00";
+    getEthValue(): Promise<string>;
+    numberToBytes2(number: number): string;
+    numberToBytes1(number: number): string;
+    numberToBytes32(number: number): string;
+}

package/esm/src/ActionWithL2.js

@@ -0,0 +1,49 @@
+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());
+    });
+};
+import { Action } from './Action';
+import Dec from 'decimal.js';
+import AbiCoder from 'web3-eth-abi';
+import ActionAbi from './abis/Action.json';
+/**
+ * Single L2 action that can be executed directly, or combined into a set (ie. supply a vault)
+ *
+ * @category Base Classes
+ */
+export class ActionWithL2 extends Action {
+    /**
+     * Encode arguments for calling the action via DsProxy
+     */
+    encodeForL2DsProxyCall() { return this.encodeInputs(); }
+    encodeForL2Recipe() { return `0x${this.encodeInputs().slice(10)}`; } // cut the method id
+    encodeInputs() {
+        const _arg = this._replaceWithPlaceholders(this.args, this.paramTypes);
+        const _paramType = this._formatType(this.paramTypes);
+        const executeActionDirectAbi = ActionAbi.find(({ name }) => name === 'executeActionDirect');
+        return AbiCoder.encodeFunctionCall(executeActionDirectAbi, [AbiCoder.encodeParameter(_paramType, _arg)]);
+    }
+    addressToBytes20(address) { return address.slice(2); }
+    boolToBytes1(bool) { return bool ? '01' : '00'; }
+    getEthValue() {
+        return __awaiter(this, void 0, void 0, function* () { return '0'; });
+    }
+    numberToBytes2(number) {
+        const hexNumber = number.toString(16);
+        return hexNumber.padStart(4, '0');
+    }
+    numberToBytes1(number) {
+        const hexNumber = number.toString(16);
+        return hexNumber.padStart(2, '0');
+    }
+    numberToBytes32(number) {
+        let hexNumber = new Dec(number).toHex();
+        hexNumber = hexNumber.slice(2);
+        return hexNumber.padStart(64, '0');
+    }
+}

package/esm/src/DfsWeb3.d.ts

@@ -0,0 +1,31 @@
+import { Action } from "./Action";
+import { Recipe } from "./Recipe";
+import { EthAddress } from './types';
+import Web3 from 'web3';
+/**
+ *
+ * @category Base Classes
+ */
+export declare class DfsWeb3 {
+    web3: Web3;
+    accountReady: boolean;
+    account?: EthAddress;
+    proxy?: EthAddress;
+    constructor(web3: Web3);
+    onAccountsChanged(_arg0: string, _onAccountsChanged: any): void;
+    prepareAccount(): Promise<void>;
+    createSmartWallet(): Promise<any>;
+    /**
+     * @param action
+     */
+    prepareBeforeExecute(action: Action): Promise<any>;
+    execute(address: EthAddress, params: Array<any>): Promise<any>;
+    /**
+     * @param action
+     */
+    executeAction(action: Action): Promise<Action>;
+    /**
+     * @param recipe
+     */
+    executeRecipe(recipe: Recipe): Promise<Recipe>;
+}

package/esm/src/DfsWeb3.js

@@ -0,0 +1,124 @@
+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());
+    });
+};
+import DFSPRoxyRegistyAbi from './abis/DFSProxyRegistry.json';
+import ProxyRegistryAbi from './abis/ProxyRegistry.json';
+import DsProxyAbi from './abis/DsProxy.json';
+import Erc20Abi from './abis/Erc20.json';
+import { getAddr } from './addresses';
+import { CONFIG } from './config';
+/**
+ *
+ * @category Base Classes
+ */
+export class DfsWeb3 {
+    constructor(web3) {
+        // const networkId = await web3.eth.net.getId();
+        // if (networkId !== 1) throw new Error('Supplied web3 is not on Mainnet');
+        this.web3 = web3;
+        this.accountReady = false;
+        this.prepareAccount();
+        /* if (this.web3.currentProvider!.on) {
+          this.web3.currentProvider!.on('accountsChanged', this.onAccountsChanged);
+        } */
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onAccountsChanged(_arg0, _onAccountsChanged) {
+        throw new Error('Method not implemented.');
+    }
+    prepareAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accounts = yield this.web3.eth.getAccounts();
+            if (!accounts || !accounts.length)
+                throw new Error('Supplied web3 has no account');
+            this.account = accounts[0];
+            const DFSPRoxyRegistyAbiItems = DFSPRoxyRegistyAbi.map(item => {
+                return Object.assign(Object.assign({}, item), { stateMutability: item.stateMutability, type: item.type });
+            });
+            const dfsRegistry = new this.web3.eth.Contract(DFSPRoxyRegistyAbiItems, getAddr('DFSProxyRegistry', CONFIG.chainId));
+            const proxies = yield dfsRegistry.methods.getAllProxies(this.account).call();
+            if (proxies[0] !== '0x0000000000000000000000000000000000000000') {
+                this.proxy = proxies[0];
+            }
+            this.accountReady = true;
+        });
+    }
+    createSmartWallet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accountReady)
+                yield this.prepareAccount();
+            if (!this.account)
+                throw new Error('DfsWeb3 has not been instantiated properly');
+            if (this.proxy)
+                throw new Error('Account already has DsProxy');
+            const ProxyRegistryAbiItems = ProxyRegistryAbi.map(item => {
+                return Object.assign(Object.assign({}, item), { stateMutability: item.stateMutability, type: item.type });
+            });
+            const makerRegistry = new this.web3.eth.Contract(ProxyRegistryAbiItems, getAddr('ProxyRegistry', CONFIG.chainId));
+            return makerRegistry.methods.build();
+        });
+    }
+    /**
+     * @param action
+     */
+    prepareBeforeExecute(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accountReady)
+                yield this.prepareAccount();
+            if (!this.proxy)
+                throw new Error('Account does not have a Smart Wallet');
+            const transactions = [];
+            const approvals = yield action.getAssetsToApprove();
+            yield Promise.all(approvals.map((a) => __awaiter(this, void 0, void 0, function* () {
+                if (a.owner.toLowerCase() === this.proxy.toLowerCase()) {
+                    const Erc20AbiItems = Erc20Abi.map(item => {
+                        return Object.assign(Object.assign({}, item), { stateMutability: item.stateMutability, type: item.type });
+                    });
+                    const tokenContract = new this.web3.eth.Contract(Erc20AbiItems, a.asset);
+                    const allowance = yield tokenContract.methods.allowance(this.account, this.proxy).call();
+                    if (parseFloat(allowance.toString()) === 0) {
+                        transactions.push(tokenContract.methods.approve(this.proxy, '-1'));
+                    }
+                }
+            })));
+            return transactions;
+        });
+    }
+    execute(address, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accountReady)
+                yield this.prepareAccount();
+            if (!this.proxy)
+                throw new Error('Account does not have a Smart Wallet. Run createSmartWallet first');
+            const DsProxyAbiItems = DsProxyAbi.map(item => {
+                return Object.assign(Object.assign({}, item), { stateMutability: item.stateMutability, type: item.type });
+            });
+            const proxyContract = new this.web3.eth.Contract(DsProxyAbiItems, this.proxy);
+            return proxyContract.methods['execute(address,bytes)'](address, params);
+        });
+    }
+    /**
+     * @param action
+     */
+    executeAction(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const encoded = action.encodeForDsProxyCall();
+            return this.execute(encoded[0], encoded[1]);
+        });
+    }
+    /**
+     * @param recipe
+     */
+    executeRecipe(recipe) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const encoded = recipe.encodeForDsProxyCall();
+            return this.execute(encoded[0], encoded[1]);
+        });
+    }
+}

package/esm/src/Recipe.d.ts

@@ -0,0 +1,49 @@
+import { Action } from './Action';
+import { AccessListItem } from './types';
+/**
+ * Set of Actions to be performed sequentially in a single transaction
+ *
+ * @category Base Classes
+ */
+export declare class Recipe {
+    #private;
+    name: string;
+    actions: Array<Action>;
+    recipeExecutorAddress: string;
+    extraGas: number;
+    /**
+     * @param name
+     * @param actions
+     */
+    constructor(name: string, actions?: Array<Action>);
+    /**
+     * @param action
+     */
+    addAction(action: Action): Recipe;
+    /**
+     * Encode arguments for calling the action set via DsProxy
+     * @returns `address` & `data` to be passed on to DSProxy's `execute(address _target, bytes memory _data)`
+     */
+    encodeForDsProxyCall(): Array<string>;
+    /**
+     * Logs parameter mapping in verbose format for validation. Used for testing in development.
+     */
+    _validateParamMappings(): void;
+    /**
+     * Assets requiring approval to be used by DsProxy
+     * Approval is done from owner to DsProxy
+     */
+    getAssetsToApprove(): Promise<Array<{
+        owner: string;
+        asset: string;
+    }>>;
+    /**
+     * ETH value to be sent with transaction
+     * @returns ETH value in wei
+     */
+    getEthValue(): Promise<string>;
+    /**
+     * Generates an access list for the recipe
+     */
+    getAccessList(): Array<AccessListItem>;
+}

package/esm/src/Recipe.js

@@ -0,0 +1,135 @@
+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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Recipe_instances, _Recipe__encodeForCall;
+import AbiCoder from 'web3-eth-abi';
+import { toBN } from 'web3-utils';
+import { getAssetInfo, utils } from "@defisaver/tokens";
+import { Action } from './Action';
+import { getAddr } from './addresses';
+import RecipeAbi from './abis/Recipe.json';
+import { CONFIG } from './config';
+/**
+ * Set of Actions to be performed sequentially in a single transaction
+ *
+ * @category Base Classes
+ */
+export class Recipe {
+    /**
+     * @param name
+     * @param actions
+     */
+    constructor(name, actions = []) {
+        _Recipe_instances.add(this);
+        actions.forEach((action) => {
+            if (!(action instanceof Action))
+                throw new TypeError('Supplied action does not inherit Action');
+        });
+        this.name = name;
+        this.actions = actions;
+        this.extraGas = 0;
+        this.recipeExecutorAddress = getAddr('RecipeExecutor', CONFIG.chainId);
+    }
+    /**
+     * @param action
+     */
+    addAction(action) {
+        if (!(action instanceof Action))
+            throw new TypeError('Supplied action does not inherit Action');
+        this.actions.push(action);
+        return this;
+    }
+    /**
+     * Encode arguments for calling the action set via DsProxy
+     * @returns `address` & `data` to be passed on to DSProxy's `execute(address _target, bytes memory _data)`
+     */
+    encodeForDsProxyCall() {
+        const executeTaskAbi = RecipeAbi.find(({ name }) => name === 'executeRecipe');
+        const encoded = __classPrivateFieldGet(this, _Recipe_instances, "m", _Recipe__encodeForCall).call(this);
+        return [
+            this.recipeExecutorAddress,
+            // @ts-expect-error Interface of AbiCoder is wrong :(
+            AbiCoder.encodeFunctionCall(executeTaskAbi, encoded),
+        ];
+    }
+    /**
+     * Logs parameter mapping in verbose format for validation. Used for testing in development.
+     */
+    _validateParamMappings() {
+        this.actions.forEach((action, i) => {
+            action._getArgumentMapping().forEach((source, j) => {
+                if (source)
+                    console.log(`${this.actions[i].name} takes argument #${j + 1} from ${this.actions[source - 1].name} (action #${source})`);
+            });
+        });
+    }
+    /**
+     * Assets requiring approval to be used by DsProxy
+     * Approval is done from owner to DsProxy
+     */
+    getAssetsToApprove() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uniqueAssetOwnerPairs = [];
+            const assetOwnerPairs = yield Promise.all(this.actions.map(a => a.getAssetsToApprove()));
+            for (const pairsPerAction of assetOwnerPairs) {
+                for (const pair of pairsPerAction) {
+                    const isNft = !pair.asset;
+                    if (!uniqueAssetOwnerPairs.find(_pair => _pair.owner === pair.owner && (isNft ? _pair.tokenId === pair.tokenId : _pair.asset === pair.asset))) {
+                        uniqueAssetOwnerPairs.push({ owner: pair.owner, asset: pair.asset });
+                    }
+                }
+            }
+            return uniqueAssetOwnerPairs.filter(({ address }) => !utils.compare(address, getAssetInfo('ETH').address));
+        });
+    }
+    /**
+     * ETH value to be sent with transaction
+     * @returns ETH value in wei
+     */
+    getEthValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield Promise.all(this.actions.map(a => a.getEthValue())))
+                .reduce((acc, val) => acc.add(toBN(val)), toBN(0))
+                .toString();
+        });
+    }
+    /**
+     * Generates an access list for the recipe
+     */
+    getAccessList() {
+        const addressMapping = {
+            [getAddr('RecipeExecutor', CONFIG.chainId)]: [],
+            [getAddr('DFSRegistry', CONFIG.chainId)]: [],
+        };
+        this.actions.forEach((action) => {
+            const accessList = action.getAccessList(CONFIG.chainId);
+            accessList.forEach(({ address, storageKeys }) => {
+                addressMapping[address] = new Set([...storageKeys, ...(addressMapping[address] || [])]);
+            });
+        });
+        return Object.keys(addressMapping).map((address) => ({
+            address,
+            storageKeys: [...addressMapping[address]],
+        }));
+    }
+}
+_Recipe_instances = new WeakSet(), _Recipe__encodeForCall = function _Recipe__encodeForCall() {
+    const encoded = this.actions.map(action => action.encodeForRecipe());
+    const transposed = encoded[0].map((_, colIndex) => encoded.map(row => row[colIndex]));
+    const taskStruct = [
+        this.name,
+        ...transposed,
+    ];
+    return [taskStruct];
+};

package/esm/src/Strategy.d.ts

@@ -0,0 +1,19 @@
+import { Action } from './Action';
+/**
+ *
+ * @category Base Classes
+ */
+export declare class Strategy {
+    name: string;
+    subSlots: any;
+    actions: Array<Action>;
+    triggers: Array<Action>;
+    numSubSlots: number;
+    constructor(name: string);
+    addSubSlot(name: string, type: string): void;
+    addTrigger(newTrigger: Action): void;
+    addAction(newAction: Action): void;
+    print(): void;
+    getSubSlots(): any;
+    encodeForDsProxyCall(): (string | string[] | number[][])[];
+}

package/esm/src/Strategy.js

@@ -0,0 +1,47 @@
+/**
+ *
+ * @category Base Classes
+ */
+export class Strategy {
+    constructor(name) {
+        this.name = name;
+        this.subSlots = {};
+        this.actions = [];
+        this.triggers = [];
+        this.numSubSlots = 0;
+    }
+    addSubSlot(name, type) {
+        this.subSlots[name] = { type, index: this.numSubSlots + 128 };
+        this.numSubSlots++;
+    }
+    addTrigger(newTrigger) {
+        this.triggers.push(newTrigger);
+    }
+    addAction(newAction) {
+        this.actions.push(newAction);
+    }
+    print() {
+        console.log(`Name: ${this.name}`);
+        console.log(`Slots: ${this.subSlots}`);
+        console.log(`Action: ${this.actions[0]}`);
+    }
+    getSubSlots() {
+        return this.subSlots;
+    }
+    encodeForDsProxyCall() {
+        const triggerIds = this.triggers.map((trigger) => trigger.getId());
+        const paramMappings = [];
+        const actionIds = [];
+        this.actions.forEach(action => {
+            const actionEncoded = action.encodeForStrategy(this.subSlots);
+            actionIds.push(actionEncoded[0]);
+            paramMappings.push(actionEncoded[1]);
+        });
+        return [
+            this.name,
+            triggerIds,
+            actionIds,
+            paramMappings
+        ];
+    }
+}