@tari-project/tarijs 0.3.0 → 0.4.0

package/dist/providers/wallet_daemon/webrtc.js

@@ -1,201 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,217 +0,0 @@
-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: {
-                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
-                })),
-                min_epoch: null,
-                max_epoch: null,
-            },
-            signing_key_index: req.account_id,
-            autofill_inputs: [],
-            detect_inputs: true,
-            proof_ids: [],
-        };
-        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}`);
-    }
-}