@tari-project/tarijs 0.1.21 → 0.1.23

package/dist/providers/wallet_daemon/webrtc.js

@@ -0,0 +1,201 @@
+class SignaligServer {
+    _token;
+    _server_url;
+    constructor(server_url) {
+        console.log(server_url);
+        if (server_url !== undefined) {
+            this._server_url = server_url;
+        }
+        else {
+            this._server_url = "http://localhost:9100";
+        }
+    }
+    async initToken(permissions) {
+        this._token = await this.authLogin(permissions);
+    }
+    get token() {
+        return this._token;
+    }
+    async jsonRpc(method, token, params) {
+        console.log('jsonRpc', method, token, params);
+        let id = 0;
+        id += 1;
+        let address = this._server_url;
+        let headers = { 'Content-Type': 'application/json' };
+        if (token) {
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+        let response = await fetch(address, {
+            method: 'POST',
+            body: JSON.stringify({
+                method: method,
+                jsonrpc: '2.0',
+                id: id,
+                params: params || {},
+            }),
+            headers: headers
+        });
+        let json = await response.json();
+        if (json.error) {
+            throw json.error;
+        }
+        return json.result;
+    }
+    async authLogin(permissions) {
+        return await this.jsonRpc("auth.login", undefined, permissions);
+    }
+    async storeIceCandidate(ice_candidate) {
+        return await this.jsonRpc("add.offer_ice_candidate", this._token, ice_candidate);
+    }
+    async storeOffer(offer) {
+        return await this.jsonRpc("add.offer", this._token, offer.sdp);
+    }
+    async getAnswer() {
+        return await this.jsonRpc("get.answer", this._token);
+    }
+    async getIceCandidates() {
+        return await this.jsonRpc("get.answer_ice_candidates", this._token);
+    }
+}
+export class TariConnection {
+    _peerConnection;
+    _dataChannel;
+    _signalingServer;
+    _callbacks;
+    _offer;
+    _walletToken;
+    // This is public so that user can directly set the onopen callback that will be called once the data channel is open.
+    onopen;
+    onConnection;
+    constructor(signalig_server_url, config) {
+        this._peerConnection = new RTCPeerConnection(config || this.config());
+        this._dataChannel = this._peerConnection.createDataChannel("tari-data");
+        this._signalingServer = new SignaligServer(signalig_server_url);
+        this._callbacks = {};
+    }
+    get token() {
+        if (this._walletToken) {
+            return this._walletToken;
+        }
+        return this._signalingServer.token;
+    }
+    async init(permissions, onConnection) {
+        this.onConnection = onConnection;
+        await this._signalingServer.initToken(permissions);
+        // Setup our receiving end
+        this._dataChannel.onmessage = (message) => {
+            let response = JSON.parse(message.data);
+            console.log('response', response);
+            if (!this._callbacks[response.id]) {
+                console.error("No callback found for id", response.id);
+                return;
+            }
+            // The response should contain id, to identify the Promise.resolve, that is waiting for this result
+            let [resolve, reject] = this._callbacks[response.id];
+            delete this._callbacks[response.id];
+            if (response.payload?.error) {
+                reject(new Error(response.payload.error));
+            }
+            else {
+                resolve(response.payload);
+            }
+        };
+        this._dataChannel.onopen = () => {
+            // This should be removed before the release, but it's good for debugging.
+            console.log("Data channel is open!");
+            this.sendMessage({ id: 0, jsonrpc: "2.0", method: "get.token", params: {} }, this._signalingServer.token)
+                .then((walletToken) => {
+                if (typeof walletToken !== 'string') {
+                    throw Error('Received invalid JWT from wallet daemon');
+                }
+                console.log("Wallet JWT received: ", walletToken);
+                this._walletToken = walletToken;
+                if (this.onConnection) {
+                    this.onConnection(this);
+                }
+            });
+        };
+        this._peerConnection.onicecandidate = (event) => {
+            console.log('event', event);
+            if (event?.candidate) {
+                console.log("ICE ", event.candidate);
+                console.log("ICE ", typeof event.candidate);
+                // Store the ice candidates, so the other end can add them
+                this._signalingServer.storeIceCandidate(event.candidate).then((resp) => {
+                    // This should be removed before the release, but it's good for debugging.
+                    console.log("Candidate stored", resp);
+                });
+            }
+        };
+        // Create offer
+        this._offer = await this._peerConnection.createOffer();
+        // Set the offer as our local sdp, at this point it will start getting the ice candidates
+        this._peerConnection.setLocalDescription(this._offer);
+        // Store the offer so the other end can set it as a remote sdp
+        this._signalingServer.storeOffer(this._offer).then((resp) => {
+            // This should be removed before the release, but it's good for debugging.
+            console.log("Offer stored", resp);
+        });
+        await this.signalingServerPolling();
+    }
+    async setAnswer() {
+        // This is called once the other end got the offer and ices and created and store an answer and its ice candidates
+        // We get its answer sdp
+        let sdp = await this._signalingServer.getAnswer();
+        // And its ice candidates
+        let iceCandidates = await this._signalingServer.getIceCandidates();
+        // For us the answer is remote sdp
+        let answer = new RTCSessionDescription({ sdp, type: "answer" });
+        this._peerConnection.setRemoteDescription(answer);
+        // We add all the ice candidates to connect, the other end is doing the same with our ice candidates
+        for (const iceCandidate of iceCandidates) {
+            this._peerConnection.addIceCandidate(iceCandidate);
+        }
+    }
+    async signalingServerPolling() {
+        // no need to keep retrying if we are already connected to the wallet
+        if (this._peerConnection.connectionState === "connected") {
+            return;
+        }
+        try {
+            await this.setAnswer();
+        }
+        catch (error) {
+            // we don't need to do anything on error, as the execution will be retried later
+            console.error(error);
+        }
+        // try again later
+        setTimeout(async () => {
+            await this.signalingServerPolling();
+        }, 2000);
+    }
+    isConnected() {
+        return this._dataChannel.readyState === "open";
+    }
+    // If the last parameter has timeout property e.g. {timeout:1000}, it set the timeout for this call.
+    async sendMessage(request, token, timeout_secs = null) {
+        if (!this.isConnected) {
+            throw new Error("WALLET_DAEMON_NOT_CONNECTED");
+        }
+        // This should be removed before the release, but it's good for debugging.
+        console.log(request, 'timeout', timeout_secs);
+        return new Promise((resolve, reject) => {
+            // We store the resolve callback for this request,
+            // so once the data channel receives a response we know where to return the data
+            this._callbacks[request.id] = [resolve, reject];
+            if (timeout_secs) {
+                // If the user set a timeout which set it here so the promise will be rejected if not fulfilled in time.
+                setTimeout(() => {
+                    delete this._callbacks[request.id];
+                    reject(new Error("Timeout"));
+                }, timeout_secs * 1000);
+            }
+            // Make the actual call to the wallet daemon
+            this._dataChannel.send(JSON.stringify({ token, ...request }));
+        });
+    }
+    // This is our default config, use can set their own stun/turn server in the constructor.
+    config() {
+        return { iceServers: [{ urls: "stun:stun.l.google.com:19302" }] };
+    }
+}

package/dist/providers/wallet_daemon/webrtc_transport.d.ts

@@ -0,0 +1,10 @@
+import { transports } from "@tari-project/wallet_jrpc_client";
+import { TariConnection } from "./webrtc";
+export declare class WebRtcRpcTransport implements transports.RpcTransport {
+    connection: TariConnection;
+    constructor(connection: TariConnection);
+    static new(connection: TariConnection): WebRtcRpcTransport;
+    token(): string | undefined;
+    isConnected(): boolean;
+    sendRequest<T>(data: transports.RpcRequest, options: transports.RpcTransportOptions): Promise<T>;
+}

package/dist/providers/wallet_daemon/webrtc_transport.js

@@ -0,0 +1,18 @@
+export class WebRtcRpcTransport {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    static new(connection) {
+        return new WebRtcRpcTransport(connection);
+    }
+    token() {
+        return this.connection.token;
+    }
+    isConnected() {
+        return this.connection.isConnected();
+    }
+    sendRequest(data, options) {
+        return this.connection.sendMessage(data, options.token);
+    }
+}

package/dist/providers/walletconnect/index.d.ts

@@ -0,0 +1,23 @@
+import { TariProvider } from "../index";
+import { SubmitTransactionRequest, TransactionResult, SubmitTransactionResponse, VaultBalances, TemplateDefinition, Substate, Account, ListSubstatesResponse } from "../types";
+import UniversalProvider from '@walletconnect/universal-provider';
+import { SubstateType } from "@tari-project/wallet_jrpc_client";
+export declare class WalletConnectTariProvider implements TariProvider {
+    providerName: string;
+    projectId: string;
+    wcProvider: UniversalProvider | null;
+    wcSession: any | null;
+    constructor(projectId: string);
+    connect(): Promise<void>;
+    private sendRequest;
+    isConnected(): boolean;
+    getAccount(): Promise<Account>;
+    getSubstate(substate_address: string): Promise<Substate>;
+    listSubstates(filter_by_template: string | null, filter_by_type: SubstateType | null, limit: number | null, offset: number | null): Promise<ListSubstatesResponse>;
+    createFreeTestCoins(): Promise<Account>;
+    submitTransaction(req: SubmitTransactionRequest): Promise<SubmitTransactionResponse>;
+    getTransactionResult(transactionId: string): Promise<TransactionResult>;
+    getTemplateDefinition(template_address: string): Promise<TemplateDefinition>;
+    getPublicKey(branch: string, index: number): Promise<string>;
+    getConfidentialVaultBalances(viewKeyId: number, vaultId: string, min: number | null, max: number | null): Promise<VaultBalances>;
+}

package/dist/providers/walletconnect/index.js

@@ -0,0 +1,217 @@
+import { TransactionStatus, } from "../types";
+import UniversalProvider from '@walletconnect/universal-provider';
+import { WalletConnectModal } from '@walletconnect/modal';
+import { stringToSubstateId, substateIdToString } from "@tari-project/wallet_jrpc_client";
+const walletConnectParams = {
+    requiredNamespaces: {
+        tari: {
+            methods: [
+                'tari_getSubstate',
+                'tari_getDefaultAccount',
+                'tari_getAccountBalances',
+                'tari_submitTransaction',
+                'tari_getTransactionResult',
+                'tari_getTemplate',
+                'tari_createKey',
+                'tari_viewConfidentialVaultBalance',
+                'tari_createFreeTestCoins',
+                'tari_listSubstates'
+            ],
+            chains: [
+                'tari:devnet',
+            ],
+            events: ['chainChanged", "accountsChanged']
+        }
+    }
+};
+export class WalletConnectTariProvider {
+    providerName = "WalletConnect";
+    projectId;
+    wcProvider;
+    wcSession;
+    constructor(projectId) {
+        this.projectId = projectId;
+        this.wcProvider = null;
+        this.wcSession = null;
+    }
+    async connect() {
+        if (this.wcProvider && this.wcSession)
+            return;
+        // initialize WalletConnect
+        const projectId = this.projectId;
+        this.wcProvider = await UniversalProvider.init({
+            projectId,
+            // TODO: parameterize the relay URL
+            relayUrl: 'wss://relay.walletconnect.com'
+        });
+        // open UI modal with the connection URI
+        const { uri, approval } = await this.wcProvider.client.connect(walletConnectParams);
+        const walletConnectModal = new WalletConnectModal({
+            projectId
+        });
+        if (uri) {
+            walletConnectModal.openModal({ uri });
+        }
+        // wait for the wallet to approve the connection
+        console.log("waiting for session approval from the wallet app");
+        const session = await approval();
+        // at this point session is open
+        console.log("session approved by the wallet");
+        this.wcSession = session;
+    }
+    async sendRequest(method, params) {
+        if (!this.wcProvider) {
+            throw "WalletConnect provider not initialized";
+        }
+        if (!this.wcSession) {
+            throw "WalletConnect session not initialized";
+        }
+        const requestResult = await this.wcProvider.client.request({
+            topic: this.wcSession.topic,
+            chainId: 'tari:devnet',
+            request: {
+                method,
+                params
+            }
+        });
+        console.log({ requestResult });
+        return requestResult;
+    }
+    isConnected() {
+        // TODO: check status in the session
+        return this.wcSession !== null;
+    }
+    async getAccount() {
+        const { account, public_key } = await this.sendRequest('tari_getDefaultAccount', {});
+        const { balances } = await this.sendRequest('tari_getAccountBalances', { account: { ComponentAddress: account.address.Component }, refresh: false
+        });
+        return {
+            account_id: account.key_index,
+            address: account.address.Component,
+            public_key,
+            // TODO: should be vaults not resources
+            resources: balances.map((b) => ({
+                type: b.resource_type,
+                resource_address: b.resource_address,
+                balance: b.balance + b.confidential_balance,
+                vault_id: ('Vault' in b.vault_address) ? b.vault_address.Vault : b.vault_address,
+                token_symbol: b.token_symbol,
+            }))
+        };
+    }
+    async getSubstate(substate_address) {
+        const substateId = stringToSubstateId(substate_address);
+        const method = 'tari_getSubstate';
+        const params = { substate_id: substateId };
+        const { value, record } = await this.sendRequest(method, params);
+        return {
+            value,
+            address: {
+                substate_id: substateIdToString(record.substate_id),
+                version: record.version
+            }
+        };
+    }
+    async listSubstates(filter_by_template, filter_by_type, limit, offset) {
+        const method = 'tari_listSubstates';
+        const params = {
+            filter_by_template,
+            filter_by_type,
+            limit,
+            offset
+        };
+        const res = await this.sendRequest(method, params);
+        const substates = res.substates.map((s) => ({
+            substate_id: substateIdToString(s.substate_id),
+            module_name: s.module_name,
+            version: s.version,
+            template_address: s.template_address
+        }));
+        return { substates };
+    }
+    async createFreeTestCoins() {
+        const method = 'tari_createFreeTestCoins';
+        const params = {
+            account: { Name: "template_web" },
+            amount: 1000000,
+            max_fee: null,
+            key_id: 0
+        };
+        const res = await this.sendRequest(method, params);
+        return {
+            account_id: res.account.key_index,
+            address: res.account.address.Component,
+            public_key: res.public_key,
+            resources: []
+        };
+    }
+    async submitTransaction(req) {
+        const method = 'tari_submitTransaction';
+        const params = {
+            transaction: null,
+            signing_key_index: req.account_id,
+            fee_instructions: req.fee_instructions,
+            instructions: req.instructions,
+            inputs: req.required_substates.map((s) => ({
+                // TODO: Hmm The bindings want a SubstateId object, but the wallet only wants a string. Any is used to skip type checking here
+                substate_id: s.substate_id,
+                version: s.version
+            })),
+            input_refs: [],
+            override_inputs: false,
+            is_dry_run: req.is_dry_run,
+            proof_ids: [],
+            min_epoch: null,
+            max_epoch: null,
+        };
+        const res = await this.sendRequest(method, params);
+        return { transaction_id: res.transaction_id };
+    }
+    async getTransactionResult(transactionId) {
+        const res = await this.sendRequest('tari_getTransactionResult', { transaction_id: transactionId });
+        return {
+            transaction_id: transactionId,
+            status: convertStringToTransactionStatus(res.status),
+            result: res.result,
+        };
+    }
+    async getTemplateDefinition(template_address) {
+        let resp = await this.sendRequest('tari_getTemplate', { template_address });
+        return resp.template_definition;
+    }
+    async getPublicKey(branch, index) {
+        const res = await this.sendRequest('tari_createKey', { branch: branch, specific_index: index });
+        return res.public_key;
+    }
+    async getConfidentialVaultBalances(viewKeyId, vaultId, min, max) {
+        const method = 'tari_viewConfidentialVaultBalance';
+        const params = {
+            view_key_id: viewKeyId,
+            vault_id: vaultId,
+            minimum_expected_value: min,
+            maximum_expected_value: max,
+        };
+        const res = await this.sendRequest(method, params);
+        return { balances: res.balances };
+    }
+}
+function convertStringToTransactionStatus(status) {
+    switch (status) {
+        case "New":
+            return TransactionStatus.New;
+        case "DryRun":
+            return TransactionStatus.DryRun;
+        case "Pending":
+            return TransactionStatus.Pending;
+        case "Accepted":
+            return TransactionStatus.Accepted;
+        case "Rejected":
+            return TransactionStatus.Rejected;
+        case "InvalidTransaction":
+            return TransactionStatus.InvalidTransaction;
+        case "OnlyFeeAccepted":
+            return TransactionStatus.OnlyFeeAccepted;
+        default:
+            throw new Error(`Unknown status: ${status}`);
+    }
+}

package/dist/templates/Account.d.ts

@@ -0,0 +1,65 @@
+import { ConfidentialWithdrawProof, NonFungibleId, ResourceAddress } from "@tari-project/typescript-bindings";
+import { Amount } from "../builders/types/Amount";
+import { TariMethodDefinition, WorkspaceArg } from "../builders/types";
+import { TemplateFactory } from "./TemplateFactory";
+/**
+ * Adds a fee instruction that calls the "take_fee" method on a component.
+ * This method must exist and return a Bucket with containing revealed confidential XTR resource.
+ * This allows the fee to originate from sources other than the transaction sender's account.
+ * The fee instruction will lock up the "max_fee" amount for the duration of the transaction.
+ * @param componentAddress
+ * @param maxFee
+ * @returns
+ */
+interface PayFeeMethod extends TariMethodDefinition {
+    methodName: "pay_fee";
+    args?: [Amount];
+}
+interface PayFeeConfidentialMethod extends TariMethodDefinition {
+    methodName: "pay_fee_confidential";
+    args?: [ConfidentialWithdrawProof];
+}
+interface WithdrawMethod extends TariMethodDefinition {
+    methodName: "withdraw";
+    args?: [string, Amount];
+}
+interface DepositMethod extends TariMethodDefinition {
+    methodName: "deposit";
+    args?: WorkspaceArg[];
+}
+interface CreateProofForResourceMethod extends TariMethodDefinition {
+    methodName: "create_proof_for_resource";
+    args?: [ResourceAddress];
+}
+interface CreateProofByAmountMethod extends TariMethodDefinition {
+    methodName: "create_proof_by_amount";
+    args?: [ResourceAddress, Amount];
+}
+interface CreateProofByNonFungibleIdsMethod extends TariMethodDefinition {
+    methodName: "create_proof_by_non_fungible_ids";
+    args?: [ResourceAddress, NonFungibleId[]];
+}
+interface BalanceMethod extends TariMethodDefinition {
+    methodName: "balance";
+    args?: [ResourceAddress];
+}
+interface GetBalancesMethod extends TariMethodDefinition {
+    methodName: "get_balances";
+    args?: [];
+}
+export declare class AccountTemplate extends TemplateFactory {
+    templateAddress: string;
+    deposit: DepositMethod;
+    withdraw: WithdrawMethod;
+    createProofByAmount: CreateProofByAmountMethod;
+    createProofByNonFungibleIds: CreateProofByNonFungibleIdsMethod;
+    createProofForResource: CreateProofForResourceMethod;
+    balance: BalanceMethod;
+    getBalances: GetBalancesMethod;
+    payFee: PayFeeMethod;
+    payFeeConfidential: PayFeeConfidentialMethod;
+    constructor(templateAddress: string);
+    protected _initFunctions(): void;
+    protected _initMethods(): void;
+}
+export {};

package/dist/templates/Account.js

@@ -0,0 +1,31 @@
+import { TemplateFactory } from "./TemplateFactory";
+export class AccountTemplate extends TemplateFactory {
+    templateAddress;
+    deposit;
+    withdraw;
+    createProofByAmount;
+    createProofByNonFungibleIds;
+    createProofForResource;
+    balance;
+    getBalances;
+    payFee;
+    payFeeConfidential;
+    constructor(templateAddress) {
+        super(templateAddress);
+        this.templateAddress = templateAddress;
+        this._initFunctions();
+        this._initMethods();
+    }
+    _initFunctions() { }
+    _initMethods() {
+        this.deposit = this._defineMethod("deposit");
+        this.withdraw = this._defineMethod("withdraw");
+        this.createProofByAmount = this._defineMethod("create_proof_by_amount");
+        this.createProofByNonFungibleIds = this._defineMethod("create_proof_by_non_fungible_ids");
+        this.createProofForResource = this._defineMethod("create_proof_for_resource");
+        this.balance = this._defineMethod("balance");
+        this.getBalances = this._defineMethod("get_balances");
+        this.payFee = this._defineMethod("pay_fee");
+        this.payFeeConfidential = this._defineMethod("pay_fee_confidential");
+    }
+}

package/dist/templates/Pool.d.ts

@@ -0,0 +1,30 @@
+import { TariMethodDefinition } from "../builders/types/Builder";
+import { WorkspaceArg } from "../builders/types/Workspace";
+import { TemplateFactory } from "./TemplateFactory";
+interface CreatePool extends TariMethodDefinition {
+    methodName: "create_pool";
+    args?: [string, string];
+}
+interface AddLiquidityMethod extends TariMethodDefinition {
+    methodName: "add_liquidity";
+    args?: WorkspaceArg[];
+}
+interface RemoveLiquidityMethod extends TariMethodDefinition {
+    methodName: "remove_liquidity";
+    args?: WorkspaceArg[];
+}
+interface SwapMethod extends TariMethodDefinition {
+    methodName: "swap";
+    args?: (WorkspaceArg | string)[];
+}
+export declare class PoolTemplate extends TemplateFactory {
+    templateAddress: string;
+    createPool: CreatePool;
+    addLiquidity: AddLiquidityMethod;
+    removeLiquidity: RemoveLiquidityMethod;
+    swap: SwapMethod;
+    constructor(templateAddress: string);
+    protected _initFunctions(): void;
+    protected _initMethods(): void;
+}
+export {};

package/dist/templates/Pool.js

@@ -0,0 +1,20 @@
+import { TemplateFactory } from "./TemplateFactory";
+export class PoolTemplate extends TemplateFactory {
+    templateAddress;
+    createPool;
+    addLiquidity;
+    removeLiquidity;
+    swap;
+    constructor(templateAddress) {
+        super(templateAddress);
+        this.templateAddress = templateAddress;
+        this._initFunctions();
+        this._initMethods();
+    }
+    _initFunctions() { }
+    _initMethods() {
+        this.addLiquidity = this._defineMethod("add_liquidity");
+        this.removeLiquidity = this._defineMethod("remove_liquidity");
+        this.swap = this._defineMethod("swap");
+    }
+}

package/dist/templates/Tariswap.d.ts

@@ -0,0 +1,65 @@
+import { Amount, ConfidentialWithdrawProof, ResourceAddress } from "../builders/types";
+import { TariFunctionDefinition, TariMethodDefinition, WorkspaceArg } from "../builders/types";
+import { TemplateFactory } from "./TemplateFactory";
+interface NewPoolFunction extends TariFunctionDefinition {
+    functionName: "new";
+    args?: [ResourceAddress, ResourceAddress, Amount];
+}
+interface MintFunction extends TariFunctionDefinition {
+    functionName: "mint";
+    args?: [Amount];
+}
+interface MintWithSymbolFunction extends TariFunctionDefinition {
+    functionName: "mint_with_symbol";
+    args?: [Amount, string];
+}
+interface PayFeeMethod extends TariMethodDefinition {
+    methodName: "pay_fee";
+    args?: [string];
+}
+interface PayFeeConfidentialMethod extends TariMethodDefinition {
+    methodName: "pay_fee_confidential";
+    args?: [ConfidentialWithdrawProof];
+}
+interface TotalSupplyMethod extends TariMethodDefinition {
+    methodName: "total_supply";
+    args?: [];
+}
+interface WithdrawMethod extends TariMethodDefinition {
+    methodName: "withdraw";
+    args?: [string, string];
+}
+interface AddLiquidityMethod extends TariMethodDefinition {
+    methodName: "add_liquidity";
+    args?: WorkspaceArg[];
+}
+interface RemoveLiquidityMethod extends TariMethodDefinition {
+    methodName: "remove_liquidity";
+    args?: WorkspaceArg[];
+}
+interface DepositMethod extends TariMethodDefinition {
+    methodName: "deposit";
+    args?: WorkspaceArg[];
+}
+interface SwapMethod extends TariMethodDefinition {
+    methodName: "swap";
+    args?: (WorkspaceArg | string)[];
+}
+export declare class TariswapTemplate extends TemplateFactory {
+    templateAddress: string;
+    newPool: NewPoolFunction;
+    mint: MintFunction;
+    mintWithSymbol: MintWithSymbolFunction;
+    totalSupply: TotalSupplyMethod;
+    payFee: PayFeeMethod;
+    payFeeConfidential: PayFeeConfidentialMethod;
+    withdraw: WithdrawMethod;
+    addLiquidity: AddLiquidityMethod;
+    removeLiquidity: RemoveLiquidityMethod;
+    deposit: DepositMethod;
+    swap: SwapMethod;
+    constructor(templateAddress: string);
+    protected _initFunctions(): void;
+    protected _initMethods(): void;
+}
+export {};