Quick-fix

2026-04-08 16:44:41 +02:00 · 2026-04-08 16:37:32 +02:00 · 2026-04-08 14:22:58 +02:00 · 2026-04-08 13:59:00 +02:00 · 2026-04-08 13:55:29 +02:00 · 2026-04-08 13:53:45 +02:00
62 changed files with 3554 additions and 71 deletions
--- a/.env.example
+++ b/.env.example
@@ -0,0 +1,2 @@
+API_URL=https://api.chatenium.hu
+CDN_URL=https://cdn.chatenium.hu
--- a/.gitea/workflows/publish.yml
+++ b/.gitea/workflows/publish.yml
@@ -0,0 +1,30 @@
+name: Publish to NPM
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+    build-and-publish:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+            
+            - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                node-version: "24"
+
+            - name: Install dependencies
+              run: npm ci
+
+            - name: Build TypeScript
+              run: npm run build
+            
+            - name: Add NPM token
+              run: echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc
+
+            - name: Publish to NPM
+              run: npm publish --access public
--- a/.gitea/workflows/test.yml
+++ b/.gitea/workflows/test.yml
@@ -0,0 +1,57 @@
+name: Setup testing environment and test the code
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    services:
+      mongodb:
+        image: mongo:6.0
+
+      redis:
+        image: redis:7-alpine
+
+      api:
+        image: git.chatenium.hu/chatenium/api:latest
+        credentials:
+          username: ${{ secrets.REPO_USER }}
+          password: ${{ secrets.REPO_TOKEN }}
+        env:
+          ENVIRONMENT_TYPE: "testing"
+          MONGODB_URL: mongodb://mongodb:27017
+          REDIS_SERVER_ADDR: redis:6379
+
+      cdn:
+        image: git.chatenium.hu/chatenium/cdn:latest
+        credentials:
+          username: ${{ secrets.REPO_USER }}
+          password: ${{ secrets.REPO_TOKEN }}
+        env:
+          ENVIRONMENT: "testing"
+          REDIS_SERVER_ADDR: redis:6379
+          MAIN_API_URL: http://api:3000
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Create .env file
+        run: |
+          echo "API_URL=http://api:3000" >> .env
+          echo "CDN_URL=http://cdn:4000" >> .env
+          echo "WS_URL=ws://api:3000" >> .env
+
+      - name: Run Vitest
+        run: |
+          npm install
+          npm test --experimental-websocket
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,9 @@ yarn-error.log*
 .pnp.js

 .vscode/*
-.idea/*
+.idea/*
+.DS_Store
+.env
+.env.*
+!.env.example
+/dist
--- a/655
+++ b/655
@@ -0,0 +1,655 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    Chatenium SDK TypeScript
+    Copyright (C) 2026  Chatenium
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
--- a/README.md
+++ b/README.md
@@ -0,0 +1,6 @@
+# Chatenium SDK For TypeScript
+A library for interacting with the Chatenium API.
+## Quick Start
+```aiignore
+npm install @chatenium/chatenium-sdk
+```
--- a/package-lock.json
+++ b/package-lock.json
@@ -10,9 +10,12 @@
      "dependencies": {
        "@faker-js/faker": "^10.4.0",
        "axios": "^1.14.0",
-        "msw": "^2.12.14"
+        "dotenv": "^17.4.0",
+        "msw": "^2.12.14",
+        "uuid": "^13.0.0"
      },
      "devDependencies": {
+        "@types/node": "^25.5.2",
        "typescript": "^5.5.3",
        "vitest": "^4.1.2"
      }
@@ -533,6 +536,16 @@
      "dev": true,
      "license": "MIT"
    },
+    "node_modules/@types/node": {
+      "version": "25.5.2",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.5.2.tgz",
+      "integrity": "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.18.0"
+      }
+    },
    "node_modules/@types/statuses": {
      "version": "2.0.6",
      "resolved": "https://registry.npmjs.org/@types/statuses/-/statuses-2.0.6.tgz",
@@ -835,6 +848,18 @@
        "node": ">=8"
      }
    },
+    "node_modules/dotenv": {
+      "version": "17.4.0",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.4.0.tgz",
+      "integrity": "sha512-kCKF62fwtzwYm0IGBNjRUjtJgMfGapII+FslMHIjMR5KTnwEmBmWLDRSnc3XSNP8bNy34tekgQyDT0hr7pERRQ==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
    "node_modules/dunder-proto": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
@@ -1857,6 +1882,13 @@
        "node": ">=14.17"
      }
    },
+    "node_modules/undici-types": {
+      "version": "7.18.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+      "devOptional": true,
+      "license": "MIT"
+    },
    "node_modules/until-async": {
      "version": "3.0.2",
      "resolved": "https://registry.npmjs.org/until-async/-/until-async-3.0.2.tgz",
@@ -1866,6 +1898,19 @@
        "url": "https://github.com/sponsors/kettanaito"
      }
    },
+    "node_modules/uuid": {
+      "version": "13.0.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-13.0.0.tgz",
+      "integrity": "sha512-XQegIaBTVUjSHliKqcnFqYypAd4S+WCYt5NIeRs6w/UAry7z8Y9j5ZwRRL4kzq9U3sD6v+85er9FvkEaBpji2w==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist-node/bin/uuid"
+      }
+    },
    "node_modules/vite": {
      "version": "8.0.3",
      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.3.tgz",
--- a/package.json
+++ b/package.json
@@ -1,22 +1,46 @@
 {
-  "name": "chatenium-sdk",
-  "version": "1.0.0",
-  "description": "",
+  "name": "@chatenium/chatenium-sdk",
+  "version": "1.0.3",
+  "description": "A library for interacting with the Chatenium API",
+  "type": "module",
  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./core/*": "./dist/core/*.js",
+    "./services/*": "./dist/services/*.js",
+    "./domain/*": "./dist/domain/*.js",
+    "./mocks/*": "./dist/mocks/*.js",
+    "./storage/*": "./dist/storage/*.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
  "scripts": {
    "build": "tsc",
-    "test": "vitest run --project unit",
+    "test": "vitest run",
+    "test-unit": "vitest run --project unit",
    "test-integration": "vitest run --project integration",
    "test:watch": "vitest"
  },
  "devDependencies": {
+    "@types/node": "^25.5.2",
    "typescript": "^5.5.3",
    "vitest": "^4.1.2"
  },
-  "private": true,
+  "private": false,
  "dependencies": {
    "@faker-js/faker": "^10.4.0",
    "axios": "^1.14.0",
-    "msw": "^2.12.14"
+    "dotenv": "^17.4.0",
+    "msw": "^2.12.14",
+    "uuid": "^13.0.0"
  }
 }
--- a/src/core/environment.ts
+++ b/src/core/environment.ts
@@ -1,21 +1,47 @@
 export interface SDKConfig {
    apiUrl: string;
    cdnUrl: string;
+    wsUrl: string;
 }

+declare const process: any;
+declare const require: any;
+
+const isNode =
+    typeof process !== 'undefined' &&
+    typeof process.versions !== 'undefined' &&
+    typeof process.versions.node !== 'undefined';
+
+if (isNode) {
+    try {
+        require('dotenv').config();
+    } catch { }
+}
+
+const getEnv = (key: string): string | undefined => {
+    if (!isNode) return undefined;
+    return process.env?.[key];
+};
+
 const DefaultEnvironment: SDKConfig = {
-    apiUrl: "https://api.chatenium.hu",
-    cdnUrl: "https://cdn.chatenium.hu",
-}
+    apiUrl: getEnv('API_URL') ?? "https://api.chatenium.hu",
+    cdnUrl: getEnv('CDN_URL') ?? "https://cdn.chatenium.hu",
+    wsUrl: getEnv('WS_URL') ?? "wss://api.chatenium.hu",
+};

-let currentConfig = {...DefaultEnvironment}
+let currentConfig: SDKConfig = { ...DefaultEnvironment };

 export const environment = {
-    get: () => currentConfig,
-    overwrite: (newConfig: Partial<SDKConfig>) => {
+    get(): SDKConfig {
+        return { ...currentConfig };
+    },
+    overwrite(newConfig: Partial<SDKConfig>): void {
        currentConfig = {
            ...currentConfig,
            ...newConfig,
        };
    },
-}
+    reset(): void {
+        currentConfig = { ...DefaultEnvironment };
+    }
+};
--- a/src/core/webSocketHandler.ts
+++ b/src/core/webSocketHandler.ts
@@ -0,0 +1,87 @@
+import {
+    WSListenerPipe,
+    WSConnIdPayload,
+    WSMakeTokenReq,
+    WSMakeTokenResp,
+    WSMessagePayload
+} from "../domain/websocket.schema";
+import {getClient} from "./http";
+import {CreateNetworkReq, Network} from "../domain/networkService.schema";
+import {isAxiosError} from "axios";
+import {GenericErrorBody} from "../domain/http.schema";
+import {environment} from "./environment";
+
+export class WebSocketHandler {
+    private static instance: WebSocketHandler;
+    private listeners: Set<WSListenerPipe> = new Set();
+    private connection: WebSocket | null = null;
+    private connectionId: string | null = null;
+
+    public static getInstance(): WebSocketHandler {
+        if (!WebSocketHandler.instance) {
+            WebSocketHandler.instance = new WebSocketHandler();
+        }
+        return WebSocketHandler.instance;
+    }
+
+    /**
+     * Connects to Chatenium WS. The ConnectionId is applied automatically in every service. The onMessage pipe is accessible in every service where needed
+     * @param userid
+     * @param token Session token
+     */
+    public async connect(userid: string, token: string): Promise<void> {
+        const client = getClient(false).create({
+            headers: {
+                "Authorization": token
+            }
+        })
+
+        try {
+            const resp = await client.post<WSMakeTokenResp>("v2/ws/makeToken", <WSMakeTokenReq>{
+                userid: userid,
+            });
+            this.connection = new WebSocket(`${environment.get().wsUrl}/v2/ws?userid=${userid}&access_token=${resp.data.token}`)
+            console.log("Connected to websocket successfully")
+            this.startListening()
+            return
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    public get connId(): string | null {
+        return this.connectionId;
+    }
+
+    private startListening() {
+        if (this.connection) {
+            this.connection.onmessage = (event) => {
+                const payl: WSMessagePayload = JSON.parse(event.data);
+                if (payl.action == "connectionId") {
+                    console.log("ConnectionID received")
+                    const data: WSConnIdPayload = JSON.parse(payl.data);
+                    this.listeners.forEach(listener => {
+                        listener.onNewConnId(data.connId)
+                        this.connectionId = data.connId;
+                    })
+                } else {
+                    this.listeners.forEach(listener => {
+                        listener.onNewMessage(payl.action, payl.data)
+                    })
+                }
+            }
+        }
+    }
+
+    public registerService(service: WSListenerPipe) {
+        this.listeners.add(service);
+    }
+
+    public unregisterService(service: WSListenerPipe) {
+        this.listeners.delete(service);
+    }
+}
--- a/src/domain/broadcastChannelService.schema.ts
+++ b/src/domain/broadcastChannelService.schema.ts
@@ -0,0 +1,28 @@
+export interface CreateServerReq {
+    type: "rtmp",
+    channelId: string
+    categoryId: string
+    networkId: string
+}
+
+export interface GetRTMPDataReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface JoinWebsocketRoomReq {
+    userid: string
+    connId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface StreamRegistry {
+    streamKey: string
+    status: "idling" | "broadcasting" | "broadcasting_starting"
+    type: "rtmp"
+    streamURL: string
+    channelId: string
+}
--- a/src/domain/chatService.schema.ts
+++ b/src/domain/chatService.schema.ts
@@ -0,0 +1,43 @@
+// Request schemas
+export interface GetChatsReq {
+    userid: string
+}
+
+export interface StartNewReq {
+    userid: string
+    peerUsername: string
+}
+
+export interface ToggleChatMuteReq {
+    userid: string
+    chatid: string
+}
+
+export interface GetAvailabilityReq {
+    targetId: string
+    connId: string
+}
+
+export interface GetAvailabilityResp {
+    available: boolean
+}
+
+// Types
+export interface Chat {
+    userid: string
+    chatid: string
+    username: string
+    displayName: string
+    pfp: string
+    status: 0 | 1
+    type: "outgoing" | "incoming"
+    notifications: number
+    muted: boolean
+    latestMessage: LatestMessage
+}
+
+export interface LatestMessage {
+    message: string
+    isAuthor: boolean
+    msgid: string
+}
--- a/src/domain/common.schema.ts
+++ b/src/domain/common.schema.ts
@@ -14,4 +14,14 @@ export interface PublicUserData {
    displayName: string
    username: string
    userid: string
+}
+
+export interface Attachment {
+    fileId: string
+    fileName: string
+    format: string
+    type: string
+    path: string
+    height: number
+    width: number
 }
--- a/src/domain/dmService.schema.ts
+++ b/src/domain/dmService.schema.ts
@@ -0,0 +1,112 @@
+import {Attachment, TimeStamp} from "./common.schema";
+
+export interface GetMessageReq {
+    from: number
+    chatid: string
+}
+
+export interface GetMessagePosReq {
+    messageId: string
+    chatid: string
+}
+
+export interface GetPinnedMessagesReq {
+    chatid: string
+}
+
+export interface EditMessageReq {
+    message: string
+    messageId: string
+    chatid: string
+    userid: string
+}
+
+export interface FinishMessageReq {
+    uploadId: string | null
+    message: string
+    replyTo: string
+    replyToMessage: string
+    chatid: string
+    userid: string
+}
+
+export interface ReadMessagesReq {
+    chatid: string
+    userid: string
+}
+
+export interface PinMessageReq {
+    chatid: string
+    messageId: string
+    userid: string
+    message: string
+}
+
+export interface UnpinMessageReq {
+    chatid: string,
+    messageId: string,
+    userid: string
+}
+
+export interface DeleteMessagesReq {
+    messageIds: string[]
+    chatid: string
+    userid: string
+}
+
+export interface JoinWsRoomReq {
+    connId: string
+    chatid: string
+    userid: string
+}
+
+// Response schemas
+export interface GetMessagePosResp {
+    messagePos: number
+}
+
+// Types
+export interface Message {
+    msgid: string
+    author: string
+    message: string
+    sent_at: TimeStamp
+    isEdited: boolean
+    chatid: string
+    files: Attachment[]
+    seen: boolean
+    replyTo: string
+    replyToId: string
+    forwardedFrom: string
+    forwardedFromName: string
+}
+
+export interface PinnedMessage {
+    message: string
+    messageId: string
+}
+
+// WebSocket payloads
+export interface WSMessageDeletedPayload {
+    messageId: string
+}
+
+export interface WSMessageEditedPayload {
+    messageId: string
+    message: string
+}
+
+export interface WSMessagePinnedPayload {
+    chatid: string
+    messageId: string
+    message: string
+}
+
+export interface WSMessagesReadPayload {
+    userid: string
+}
+
+export interface WSMessageUnpinnedPayload {
+    chatid: string
+    messageId: string
+}
--- a/src/domain/fileTransferService.schema.ts
+++ b/src/domain/fileTransferService.schema.ts
@@ -0,0 +1,95 @@
+export interface StartNewFileTransferReq {
+    userid: string
+    targetUserId: string
+    metadata: TransferableFileMetadata[]
+}
+
+export interface AcceptFileTransferReq {
+    userid: string
+    senderId: string
+    transferId: string
+}
+
+export interface DeclineFileTransferReq {
+    userid: string
+    senderId: string
+    transferId: string
+}
+
+export interface FileTransferSendOfferRTCReq {
+    userid: string
+    peerId: string
+    transferId: string
+    offer: string
+}
+
+export interface FileTransferSendAnswerRTCReq {
+    userid: string
+    peerId: string
+    transferId: string
+    answer: string
+}
+
+export interface FileTransferSendICERTCReq {
+    userid: string
+    peerId: string
+    transferId: string
+    candidate: string
+}
+
+// Response schemas
+export interface StartNewFileTransferResp {
+    transferId: string
+}
+
+// WebSocket payloads
+export interface WSNewFileTransferPayload {
+    from: string
+    transferId: string
+    metadata: TransferableFileMetadata[]
+}
+
+export interface WSFileTransferAcceptedPayload {
+    transferId: string
+    rtcConfig: RTCConfiguration
+}
+
+export interface WSFileTransferDeclinedPayload {
+    transferId: string
+}
+
+export interface WSFileTransferRTCOfferPayload {
+    transferId: string
+    offer: string
+}
+
+export interface WSFileTransferRTCAnswerPayload {
+    transferId: string
+    answer: string
+}
+
+export interface WSFileTransferRTCIcePayload {
+    transferId: string
+    candidate: string
+}
+
+// DataChannel payloads
+export interface DCStartNewFilePayload {
+    fileId: string
+    fileIndex: number
+    fileName: string
+    totalChunks: number
+}
+
+export interface DCTransferFilePayload {
+    fileId: string
+    fileIndex: string
+    chunk: string
+}
+
+// Types
+export interface TransferableFileMetadata {
+    fileId: string
+    name: string
+    size: number
+}
--- a/src/domain/fileUploadService.schema.ts
+++ b/src/domain/fileUploadService.schema.ts
@@ -0,0 +1,45 @@
+// Request schemas
+export interface RegisterUploadReq {
+    roomId: string
+    userid: string
+    files: FileUploadRegistration[]
+}
+
+export interface ChunkUploadReq {
+    uploadId: string
+    fileId: string
+    chunk: string
+    roomId: string
+    userid: string
+}
+
+export interface FinishUploadReq {
+    uploadId: string
+    roomId: string
+    userid: string
+}
+
+// Response schemas
+export interface RegisterUploadResp {
+    uploadId: string
+}
+
+// Types
+export interface FileUploadRegistration {
+    size: number
+    type: string
+    name: string
+    fileId: string
+}
+
+export interface FileData {
+    fileId: string
+    name: string
+    extension: string
+    type: string
+    data: File
+}
+
+export interface FileUploadProgressListener {
+    fileProgressUpdate: (fileId: string, allChunks: number, chunksDone: number) => void
+}
--- a/src/domain/sessionManager.schema.ts
+++ b/src/domain/sessionManager.schema.ts
@@ -0,0 +1,19 @@
+import {PublicUserData} from "./common.schema";
+import {GIF, PersonalUserData} from "./userService.schema";
+
+export interface Session {
+    userData: PersonalUserData
+    token: string
+}
+
+export interface ValidateSessionReq {
+    token: string
+}
+
+export interface ValidateSessionResp {
+    validationOk: boolean
+}
+
+export interface UpdateUserDataReq {
+    userid: string
+}
--- a/src/domain/textChannelService.schema.ts
+++ b/src/domain/textChannelService.schema.ts
@@ -0,0 +1,138 @@
+import {Attachment, PublicUserData, TimeStamp} from "./common.schema";
+
+export interface GetMessageReq {
+    from: number
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface GetMessagePosReq {
+    messageId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface GetPinnedMessagesReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface EditMessageReq {
+    message: string
+    messageId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface FinishMessageReq {
+    uploadId: string | null
+    message: string
+    replyTo: string
+    replyToMessage: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface ReadMessagesReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface PinMessageReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+    userid: string
+    message: string
+}
+
+export interface UnpinMessageReq {
+    channelId: string
+    networkId: string
+    categoryId: string,
+    messageId: string,
+    userid: string
+}
+
+export interface DeleteMessagesReq {
+    messageIds: string[]
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface JoinWsRoomReq {
+    connId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+// Response schemas
+export interface GetMessagePosResp {
+    messagePos: number
+}
+
+// Types
+export interface Message {
+    msgid: string
+    author: PublicUserData
+    message: string
+    sent_at: TimeStamp
+    isEdited: boolean
+    channelId: string
+    networkId: string
+    categoryId: string
+    files: Attachment[]
+    seen: boolean
+    replyTo: string
+    replyToId: string
+    forwardedFrom: string
+    forwardedFromName: string
+}
+
+export interface PinnedMessage {
+    message: string
+    messageId: string
+}
+
+// WebSocket payloads
+export interface WSMessageDeletedPayload {
+    messageId: string
+}
+
+export interface WSMessageEditedPayload {
+    messageId: string
+    message: string
+}
+
+export interface WSMessagePinnedPayload {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+    message: string
+}
+
+export interface WSMessagesReadPayload {
+    userid: string
+}
+
+export interface WSMessageUnpinnedPayload {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+}
--- a/src/domain/userService.schema.ts
+++ b/src/domain/userService.schema.ts
@@ -0,0 +1,114 @@
+import {TimeStamp} from "./common.schema";
+
+export interface ChangeUsernameReq {
+    newUsername: string;
+    userid: string;
+}
+
+export interface ChangeDisplayNameReq {
+    newDisplayName: string;
+    userid: string;
+}
+
+export interface ChangePasswordReq {
+    newPassword: string;
+    currentPassword: string;
+    userid: string;
+}
+
+export interface ChangeEmailReq {
+    currentPassword: string;
+    newMail: string;
+    userid: string;
+}
+
+export interface VerifyMailChangeReq {
+    userid: string;
+    vCodeCurrent: number;
+    vCodeNew: number;
+    newAddress: string;
+}
+
+export interface ChangePhoneReq {
+    currentPassword: string;
+    newPhone: string;
+    userid: string;
+}
+
+export interface VerifyPhoneChange {
+    userid: string;
+    vCodeCurrent: number;
+    vCodeNew: number;
+    newPhone: string;
+}
+
+export interface UploadNewPfpReq {
+    userid: string;
+    pfpId: string;
+}
+
+export interface UploadNewPfpCdnReq {
+    userid: string;
+    data: string | null;
+    isImage: boolean;
+    monogramLetter: string | null;
+    monogramColors: string | null;
+}
+
+export interface DeleteReq {
+    userid: string;
+    password: string;
+}
+
+export interface RegisterFCMTokenReq {
+    userid: string;
+    token: string;
+    language: string;
+}
+
+export interface GetSessionsReq {
+    userid: string;
+}
+
+export interface UpdateUserDataReq {
+    userid: string;
+}
+
+export interface ToggleGifSaveReq {
+    userid: string;
+    url: string;
+}
+
+export interface UploadNewPfpCdnResp {
+    pfpId: string;
+}
+
+export interface Session {
+    token: string;
+    os: string;
+    language: string;
+    login_at: TimeStamp | string;
+}
+
+export interface GIF {
+    gifId: string;
+    url: string;
+    path: string;
+}
+
+export interface CurrNewCodeTestingResp {
+    codeCurr: number|null;
+    codeNew: number|null;
+}
+
+export interface PersonalUserData {
+    userid: string;
+    username: string;
+    displayName: string;
+    pfp: string;
+    pictureDiscovery: boolean;
+    gifs: GIF[];
+    passwordSet: boolean;
+    emailSet: boolean;
+    phoneSet: boolean;
+}
--- a/src/domain/websocket.schema.ts
+++ b/src/domain/websocket.schema.ts
@@ -0,0 +1,28 @@
+export interface WSListenerPipe {
+    identifier: string; // Any identifier that is unique to the service (chatid, networkId, etc...)
+    onNewConnId: (newConnId: string) => void;
+    onNewMessage: MessageListener;
+}
+
+export type MessageListener = (action: string, data: string) => void
+
+export interface WSMakeTokenReq {
+    userid: string
+}
+
+export interface WSMakeTokenResp {
+    token: string
+}
+
+export interface WSConnIdPayload {
+    connId: string
+}
+
+export interface WSConnIdPayload {
+    connId: string
+}
+
+export interface WSMessagePayload {
+    action: string,
+    data: string
+}
--- a/src/index.test.ts
+++ b/src/index.test.ts
@@ -1,13 +0,0 @@
-import {beforeAll, describe, expect, it} from "vitest";
-import {jezus} from "./index";
-import {KeyringAPI} from "./storage/keyring";
-import {KeyringMock} from "./mocks/storage/keyring";
-
-describe("Testing", () => {
-    it("should be defined", () => {
-        let keyringMock = new KeyringMock();
-        jezus(keyringMock)
-
-        expect(keyringMock.get("keyring")).toBe("apad");
-    })
-})
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,5 +0,0 @@
-import {KeyringAPI} from "./storage/keyring";
-
-export function jezus(keyring: KeyringAPI) {
-    keyring.set("keyring", "apad");
-}
--- a/src/mocks/handlers/brcChan.http.ts
+++ b/src/mocks/handlers/brcChan.http.ts
@@ -0,0 +1,11 @@
+import {http, HttpResponse} from "msw";
+import {GetRTCAccessResp} from "../../domain/callService.schema";
+import {StreamRegistry} from "../../domain/broadcastChannelService.schema";
+
+export const brcChanHandlers = [
+    http.get('*/network/channel/rtmpData', () => {
+        return HttpResponse.json(<StreamRegistry>{
+            status: "broadcasting_starting"
+        })
+    }),
+]
--- a/src/mocks/handlers/chat.http.ts
+++ b/src/mocks/handlers/chat.http.ts
@@ -0,0 +1,23 @@
+import {http, HttpResponse} from "msw";
+import {Chat, GetAvailabilityResp, StartNewReq} from "../../domain/chatService.schema";
+
+export const chatHandlers = [
+    http.get('*/chat/get', () => {
+        return HttpResponse.json(<Chat[]>[{
+            userid: "chatPartnerId"
+        }])
+    }),
+
+    http.get('*/chat/availability', () => {
+        return HttpResponse.json(<GetAvailabilityResp>{
+            available: true
+        })
+    }),
+
+    http.post('*/chat/startNew', async ({request}) => {
+        const body = await request.json() as StartNewReq
+        return HttpResponse.json(<Chat>{
+            username: body.peerUsername
+        })
+    }),
+]
--- a/src/mocks/handlers/dm.http.ts
+++ b/src/mocks/handlers/dm.http.ts
@@ -0,0 +1,31 @@
+import {http, HttpResponse} from "msw";
+import {Chat} from "../../domain/chatService.schema";
+import {FinishMessageReq, GetMessagePosResp, Message, PinnedMessage} from "../../domain/dmService.schema";
+import {CreateNetworkReq, Network} from "../../domain/networkService.schema";
+
+export const dmHandlers = [
+    http.get('*/chat/dm/messages', () => {
+        return HttpResponse.json(<Message[]>[{
+            message: "This is a message",
+        }])
+    }),
+
+    http.get('*/chat/dm/getMessagePosition', () => {
+        return HttpResponse.json(<GetMessagePosResp>{
+            messagePos: 5000
+        })
+    }),
+
+    http.get('*/chat/dm/pinnedMessages', () => {
+        return HttpResponse.json(<PinnedMessage[]>[{
+            message: "This is a pinned message",
+        }])
+    }),
+
+    http.post('*/chat/dm/finishMessage', async ({request}) => {
+        const body = await request.json() as FinishMessageReq
+        return HttpResponse.json(<Message>{
+            message: body.message,
+        })
+    }),
+]
--- a/src/mocks/handlers/fUpl.http.ts
+++ b/src/mocks/handlers/fUpl.http.ts
@@ -0,0 +1,19 @@
+import {http, HttpResponse} from "msw";
+import {GetRTCAccessResp} from "../../domain/callService.schema";
+import {RegisterUploadResp} from "../../domain/fileUploadService.schema";
+
+export const fileUploadHandlers = [
+    http.post('*/chat/cdnRegisterUpload', () => {
+        return HttpResponse.json(<RegisterUploadResp>{
+            uploadId: "MockUploadId"
+        })
+    }),
+
+    http.post('*/chat/uploadChunk', () => {
+        return HttpResponse.json()
+    }),
+
+    http.post('*/chat/finishUpload', () => {
+        return HttpResponse.json()
+    }),
+]
--- a/src/mocks/handlers/user.http.ts
+++ b/src/mocks/handlers/user.http.ts
@@ -0,0 +1,11 @@
+import {http, HttpResponse} from "msw";
+import {GetResp} from "../../domain/pictureService.schema";
+import {Session} from "../../domain/userService.schema";
+
+export const userHandler = [
+    http.post('*/user/getSessions', () => {
+        return HttpResponse.json(<Session[]>[{
+            token: "sessionToken"
+        }])
+    }),
+]
--- a/src/mocks/index.ts
+++ b/src/mocks/index.ts
@@ -2,10 +2,20 @@ import {networkHandlers} from "./handlers/auth.http";
 import {authHandlers} from "./handlers/network.http";
 import {pictureHandlers} from "./handlers/picture.http";
 import {callHandlers} from "./handlers/call.http";
+import {fileUploadHandlers} from "./handlers/fUpl.http";
+import {chatHandlers} from "./handlers/chat.http";
+import {dmHandlers} from "./handlers/dm.http";
+import {userHandler} from "./handlers/user.http";
+import {brcChanHandlers} from "./handlers/brcChan.http";

 export const allHandlers = [
    ...authHandlers,
    ...networkHandlers,
    ...pictureHandlers,
-    ...callHandlers
+    ...callHandlers,
+    ...fileUploadHandlers,
+    ...chatHandlers,
+    ...dmHandlers,
+    ...userHandler,
+    ...brcChanHandlers
 ]
--- a/src/mocks/storage/database.ts
+++ b/src/mocks/storage/database.ts
@@ -4,6 +4,9 @@ export class DatabaseMock implements DatabaseAPI {
    database: { [collection: string]: { [key: string]: string } } = {};

    set(collection: string, key: string, value: any) {
+        if (!this.database[collection]) {
+            this.database[collection] = {};
+        }
        this.database[collection][key] = JSON.stringify(value);
    }

--- a/src/mocks/storage/keyring.ts
+++ b/src/mocks/storage/keyring.ts
@@ -11,11 +11,11 @@ export class KeyringMock implements KeyringAPI {
        return this.ring[key];
    }

+    getAll(): string[] {
+        return Object.keys(this.ring);
+    }
+
    delete(key: string) {
        delete this.ring[key];
    }
-
-    flush() {
-        this.ring = {};
-    }
 }
--- a/src/services/authService.ts
+++ b/src/services/authService.ts
@@ -164,7 +164,6 @@ export class AuthService {
            });
            return resp.data.authCode
        } catch (e) {
-            console.log(e)
            if (isAxiosError<GenericErrorBody>(e)) {
                throw e;
            }
--- a/src/services/broadcastChannelService.test.ts
+++ b/src/services/broadcastChannelService.test.ts
@@ -0,0 +1,11 @@
+import {describe, expect, it} from "vitest";
+import {BroadcastChannelService} from "./broadcastChannelService";
+
+describe("BroadcastChannelService", () => {
+    const service = new BroadcastChannelService("", "", "", "", "", () => {})
+
+    it("should get stream registry data", async () => {
+        const data = await service.getData()
+        expect(data.status).toBe("broadcasting_starting")
+    })
+})
--- a/src/services/broadcastChannelService.ts
+++ b/src/services/broadcastChannelService.ts
@@ -0,0 +1,93 @@
+import {AxiosInstance, isAxiosError} from "axios";
+import {getClient} from "../core/http";
+import {MessageListener} from "../domain/websocket.schema";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {AcceptInviteReq} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {
+    CreateServerReq,
+    GetRTMPDataReq,
+    JoinWebsocketRoomReq,
+    StreamRegistry
+} from "../domain/broadcastChannelService.schema";
+
+export class BroadcastChannelService {
+    userid: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    client: AxiosInstance;
+
+    constructor(token: string, userid: string, networkId: string, categoryId: string, channelId: string, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.channelId = channelId;
+        this.categoryId = categoryId;
+        this.networkId = networkId;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: channelId,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("NetworkService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+    }
+
+    async getData(): Promise<StreamRegistry> {
+        try {
+            const resp = await this.client.get<StreamRegistry>(`network/channel/rtmpData?userid=${this.userid}&channelId=${this.channelId}&networkId=${this.networkId}&categoryId=${this.categoryId}`);
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async createServer(): Promise<StreamRegistry> {
+        try {
+            const resp = await this.client.post<StreamRegistry>("network/channel/createServer", <CreateServerReq>{
+                userid: this.userid,
+                channelId: this.channelId,
+                networkId: this.networkId,
+                type: "rtmp",
+                categoryId: this.categoryId,
+            });
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async joinWebSocketRoom(): Promise<void> {
+        try {
+            await this.client.post("v2/network/channel/joinWebSocketRoom", <JoinWebsocketRoomReq>{
+                userid: this.userid,
+                channelId: this.channelId,
+                networkId: this.networkId,
+                connId: WebSocketHandler.getInstance().connId,
+                categoryId: this.categoryId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/chatService.test.ts
+++ b/src/services/chatService.test.ts
@@ -0,0 +1,24 @@
+import {describe, expect, it} from "vitest";
+import {ChatService} from "./chatService";
+import {DatabaseMock} from "../mocks/storage/database";
+import {faker} from "@faker-js/faker/locale/en";
+
+describe("ChatService", () => {
+    const service = new ChatService("", "", new DatabaseMock(), (action, data) => {})
+
+    it('should get chats', async () => {
+        const chats = await service.get()
+        expect(chats[0].userid).toBe("chatPartnerId")
+    })
+
+    it('should get availability', async () => {
+        const available = await service.getUserAvailability("")
+        expect(available).toBeTruthy()
+    });
+
+    it('should create a new chat', async () => {
+        const chatPartnerName = faker.internet.displayName()
+        const newChat = await service.startNew(chatPartnerName)
+        expect(newChat.username).toBe(chatPartnerName)
+    });
+})
--- a/src/services/chatService.ts
+++ b/src/services/chatService.ts
@@ -0,0 +1,126 @@
+import {DatabaseAPI} from "../storage/database";
+import {MessageListener} from "../domain/websocket.schema";
+import {getClient} from "../core/http";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {AxiosInstance, isAxiosError} from "axios";
+import {NetworkInvite} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {
+    Chat,
+    GetAvailabilityReq,
+    GetAvailabilityResp,
+    StartNewReq,
+    ToggleChatMuteReq
+} from "../domain/chatService.schema";
+import {Message} from "../domain/dmService.schema";
+
+/**
+ * ChatService is an exception because it's one instance for all chats because it's unnecessary to create a new instance for each chat
+ */
+export class ChatService {
+    userid: string;
+    database: DatabaseAPI;
+    client: AxiosInstance;
+
+    constructor(userid: string, token: string, database: DatabaseAPI, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.database = database;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: userid,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("ChatService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+    }
+
+    /**
+     * Fetches all chat partners
+     */
+    async get(): Promise<Chat[]> {
+        try {
+            const resp = await this.client.get<Chat[]>(`chat/get?userid=${this.userid}`);
+            this.database.set("chats", this.userid, JSON.stringify(resp.data))
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    getQuick(): Message[] {
+        const chats = this.database.get("chats", this.userid)
+        if (chats) {
+            return JSON.parse(chats)
+        } else {
+            throw new Error("No chats in database")
+        }
+    }
+
+    /**
+     * Gets the availability of the specified user
+     * @param userid
+     */
+    async getUserAvailability(userid: string): Promise<boolean> {
+        try {
+            const resp = await this.client.get<GetAvailabilityResp>(`chat/availability?target=${this.userid}&connId=${WebSocketHandler.getInstance().connId}`);
+            return resp.data.available
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * (un)mutes the specified chat
+     * @param chatid
+     */
+    async toggleMute(chatid: string): Promise<void> {
+        try {
+            const resp = await this.client.post("v2/chat/toggleMute", <ToggleChatMuteReq>{
+                userid: this.userid,
+                chatid: chatid,
+            });
+            return
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Starts a new chat with the specified user
+     * @param peerUsername
+     */
+    async startNew(peerUsername: string): Promise<Chat> {
+        try {
+            const resp = await this.client.post("chat/startNew", <StartNewReq>{
+                userid: this.userid,
+                peerUsername: peerUsername,
+            });
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/dmService.test.ts
+++ b/src/services/dmService.test.ts
@@ -0,0 +1,29 @@
+import {describe, expect, it} from "vitest";
+import {DMService} from "./dmService";
+import {DatabaseMock} from "../mocks/storage/database";
+import {faker} from "@faker-js/faker/locale/en";
+
+describe("DmService", () => {
+    const service = new DMService("", "", "", new DatabaseMock(), () => {})
+
+    it("should get messages", async () => {
+        const messages = await service.get()
+        expect(messages[0].message).toBe("This is a message")
+    })
+
+    it('should get message position', async () => {
+        const pos = await service.getMessagePos("")
+        expect(pos).toBe(5000)
+    });
+
+    it('should get pinned messages', async () => {
+        const pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages[0].message).toBe("This is a pinned message")
+    });
+
+    it('should send a new message', async () => {
+        const message = faker.internet.displayName()
+        const newMessage = await service.sendMessage(message)
+        expect(newMessage.message).toBe(message)
+    });
+})
--- a/src/services/dmService.ts
+++ b/src/services/dmService.ts
@@ -0,0 +1,260 @@
+import {DatabaseAPI} from "../storage/database";
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from "../domain/websocket.schema";
+import {getClient} from "../core/http";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {
+    DeleteMessagesReq,
+    EditMessageReq,
+    FinishMessageReq,
+    GetMessagePosResp, JoinWsRoomReq,
+    Message, PinMessageReq,
+    PinnedMessage, ReadMessagesReq, UnpinMessageReq
+} from "../domain/dmService.schema";
+import {NetworkInvite} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {FileData, FileUploadProgressListener} from "../domain/fileUploadService.schema";
+import {FileUploadService} from "./fileUploadService";
+
+export class DMService {
+    userid: string;
+    chatid: string;
+    token: string;
+    database: DatabaseAPI;
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, chatid: string, database: DatabaseAPI, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.chatid = chatid;
+        this.database = database;
+        this.token = token;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: chatid,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("NetworkService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+    }
+
+    /**
+     * Fetches all messages in the chat
+     * @param from
+     */
+    async get(from: number = 0): Promise<Message[]> {
+        try {
+            const resp = await this.client.get<Message[]>(`chat/dm/messages?chatid=${this.chatid}&userid=${this.userid}&from=${from}`);
+            if (from == 0) {
+                this.database.set("messages", this.chatid, JSON.stringify(resp.data))
+            }
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    getQuick(): Message[] {
+        const messages = this.database.get("messages", this.chatid)
+        if (messages) {
+            return JSON.parse(messages)
+        } else {
+            throw new Error("No messages in database")
+        }
+    }
+
+    /**
+     * Fetches the position of the specified message which can be used in get() to fetch an old message with it's surrounding messages
+     * @param messageId
+     */
+    async getMessagePos(messageId: string): Promise<number> {
+        try {
+            const resp = await this.client.get<GetMessagePosResp>(`chat/dm/getMessagePosition?chatid=${this.chatid}&userid=${this.userid}&messageId=${messageId}`);
+            return resp.data.messagePos
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Gets all messages pinned in the chat
+     */
+    async getPinnedMessages(): Promise<PinnedMessage[]> {
+        try {
+            const resp = await this.client.get<PinnedMessage[]>(`chat/dm/pinnedMessages?chatid=${this.chatid}&userid=${this.userid}`);
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Edits the specified message
+     * @param messageId
+     * @param newMessage
+     */
+    async editMessage(messageId: string, newMessage: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("chat/dm/editMessage", <EditMessageReq>{
+                messageId: messageId,
+                chatid: this.chatid,
+                userid: this.userid,
+                message: newMessage
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Sends a new message to the chat
+     * @param message
+     * @param replyTo
+     * @param replyToMessage
+     * @param attachments
+     * @param progressListener
+     */
+    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null, progressListener: FileUploadProgressListener | null = null): Promise<Message> {
+        let uploadId = ""
+        if (attachments) {
+            const uploader = new FileUploadService(this.token)
+            uploadId = await uploader.uploadFiles(this.chatid, this.userid, attachments, progressListener!)
+        }
+        try {
+            const resp = await this.client.post<Message>("chat/dm/finishMessage", <FinishMessageReq>{
+                message: message,
+                chatid: this.chatid,
+                replyTo: replyTo,
+                replyToMessage: replyToMessage,
+                userid: this.userid,
+                uploadId: uploadId,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Reads all messages sent to you in the chat
+     */
+    async readMessages(): Promise<void> {
+        try {
+            await this.client.patch("chat/dm/readMessages", <ReadMessagesReq>{
+                chatid: this.chatid,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Pins the specified message
+     * @param messageId
+     * @param message
+     */
+    async pinMessage(messageId: string, message: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("chat/dm/pinMessage", <PinMessageReq>{
+                messageId: messageId,
+                chatid: this.chatid,
+                userid: this.userid,
+                message: message
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Unpins the specified message
+     * @param messageId
+     */
+    async unpinMessage(messageId: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("chat/dm/unpinMessage", <UnpinMessageReq>{
+                messageId: messageId,
+                chatid: this.chatid,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes the message(s)
+     * @param messageIds
+     */
+    async deleteMessages(messageIds: string[]): Promise<void> {
+        try {
+            const resp = await this.client.patch("chat/dm/deleteMessages", <DeleteMessagesReq>{
+                chatid: this.chatid,
+                userid: this.userid,
+                messageIds: messageIds
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Joins the WebSocket room to start receiving realtime messages
+     */
+    async joinWebSocketRoom(): Promise<void> {
+        try {
+            const resp = await this.client.patch("chat/dm/joinWebSocketRoom", <JoinWsRoomReq>{
+                chatid: this.chatid,
+                userid: this.userid,
+                connId: WebSocketHandler.getInstance().connId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/fileTransferService.ts
+++ b/src/services/fileTransferService.ts
@@ -0,0 +1,156 @@
+import {DatabaseAPI} from "../storage/database";
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from "../domain/websocket.schema";
+import {getClient} from "../core/http";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {CreateNetworkReq, Network} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {
+    AcceptFileTransferReq, DeclineFileTransferReq, FileTransferSendAnswerRTCReq,
+    FileTransferSendICERTCReq, FileTransferSendOfferRTCReq,
+    StartNewFileTransferReq,
+    StartNewFileTransferResp,
+    TransferableFileMetadata
+} from "../domain/fileTransferService.schema";
+
+export class FileTransferService {
+    userid: string;
+    peerId: string;
+    transferId: string = "";
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, peerId: string) {
+        this.userid = userid;
+        this.peerId = peerId;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+            }
+        })
+    }
+
+    /**
+     * Starts a new file transfer with the specified user. The new transferId will be saved automatically and not required to be provided later.
+     * @param transferableFiles
+     */
+    async startNew(transferableFiles: TransferableFileMetadata[]): Promise<string> {
+        try {
+            const resp = await this.client.post<StartNewFileTransferResp>("v2/chat/dm/startNewFileTransfer", <StartNewFileTransferReq>{
+                userid: this.userid,
+                targetUserId: this.peerId,
+                metadata: transferableFiles
+            });
+            this.transferId = resp.data.transferId
+            return resp.data.transferId
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Accepts the file transfer with the specified transferId. The transferId will be saved automatically and not required to be provided later.
+     * @param transferId
+     */
+    async accept(transferId: string): Promise<RTCConfiguration> {
+        try {
+            const resp = await this.client.post<RTCConfiguration>("v2/chat/dm/acceptFileTransfer", <AcceptFileTransferReq>{
+                userid: this.userid,
+                senderId: this.peerId,
+                transferId: transferId
+            });
+            this.transferId = transferId
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Declines the file transfer with the specified transferId.
+     * @param transferId
+     */
+    async decline(transferId: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/declineFileTransfer", <DeclineFileTransferReq>{
+                userid: this.userid,
+                senderId: this.peerId,
+                transferId: transferId
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Forwards your RTC offer to the specified user.
+     * @param offer
+     */
+    async sendRtcOffer(offer: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/sendRtcOfferFileTransfer", <FileTransferSendOfferRTCReq>{
+                userid: this.userid,
+                peerId: this.peerId,
+                transferId: this.transferId,
+                offer: offer,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Forwards your RTC answer to the specified user.
+     * @param answer
+     */
+    async sendRtcAnswer(answer: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/sendRtcAnswerFileTransfer", <FileTransferSendAnswerRTCReq>{
+                userid: this.userid,
+                peerId: this.peerId,
+                transferId: this.transferId,
+                answer: answer,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Forwards your RTC ICE candidate to the specified user.
+     * @param candidate
+     */
+    async sendRtcICE(candidate: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/sendRtcICEFileTransfer", <FileTransferSendICERTCReq>{
+                userid: this.userid,
+                peerId: this.peerId,
+                transferId: this.transferId,
+                candidate: candidate,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/fileUploadService.test.ts
+++ b/src/services/fileUploadService.test.ts
@@ -0,0 +1,12 @@
+import {describe, expect, it} from "vitest";
+import {FileUploadService} from "./fileUploadService";
+
+describe("fileUploadService", () => {
+    it('should upload files', async () => {
+        const service = new FileUploadService("");
+        const uploadId = await service.uploadFiles("", "", [], {
+            fileProgressUpdate: () => {}
+        })
+        expect(uploadId).toBe("MockUploadId")
+    });
+})
--- a/src/services/fileUploadService.ts
+++ b/src/services/fileUploadService.ts
@@ -0,0 +1,137 @@
+import {
+    ChunkUploadReq,
+    FileData, FileUploadProgressListener,
+    FileUploadRegistration, FinishUploadReq,
+    RegisterUploadReq,
+    RegisterUploadResp
+} from "../domain/fileUploadService.schema";
+import {AxiosInstance, isAxiosError} from "axios";
+import {getClient} from "../core/http";
+import {InviteToCallReq} from "../domain/callService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {v4 as uuidv4} from 'uuid';
+
+export class FileUploadService {
+    client: AxiosInstance;
+    cdnClient: AxiosInstance;
+
+    constructor(token: string) {
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token
+            }
+        })
+        this.cdnClient = getClient(true).create({
+            headers: {
+                "Authorization": token
+            }
+        })
+    }
+
+    private MIN_CHUNK_SIZE = 25000000
+
+    private calculateChunkSize(totalSize: number) {
+        let chunks = Math.floor(totalSize / this.MIN_CHUNK_SIZE);
+        if (chunks === 0) return totalSize;
+        const chunkSize = Math.ceil(totalSize / chunks);
+        return Math.max(chunkSize, this.MIN_CHUNK_SIZE);
+    }
+
+    /**
+     * Automatically registers the upload, calculates chunksize and uploads each chunk and returns with an uploadId that must be provided when sending the message
+     * @param roomId chatid or channelId
+     * @param userid
+     * @param files
+     * @param listener
+     */
+    async uploadFiles(roomId: string, userid: string, files: FileData[], listener: FileUploadProgressListener): Promise<string> {
+        let registrations: FileUploadRegistration[] = [];
+
+        files.forEach(file => {
+            registrations.push({
+                fileId: file.fileId,
+                name: file.name,
+                type: file.type,
+                size: file.data.size,
+            })
+        })
+
+        try {
+            const resp = await this.client.post<RegisterUploadResp>("chat/cdnRegisterUpload", <RegisterUploadReq>{
+                roomId: roomId,
+                userid: userid,
+                files: registrations,
+            });
+            for (let filesUploaded = 0; filesUploaded < files.length; filesUploaded++) {
+                await this.uploadFile(resp.data.uploadId, roomId, userid, files[filesUploaded], registrations[filesUploaded], listener)
+            }
+            await this.finishUpload(roomId, userid, resp.data.uploadId)
+            return resp.data.uploadId
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    private async finishUpload(roomId: string, userid: string, uploadId: string): Promise<void> {
+        try {
+            await this.cdnClient.post("chat/finishUpload", <FinishUploadReq>{
+                roomId: roomId,
+                userid: userid,
+                uploadId: uploadId
+            });
+            return
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    private async uploadFile(uploadId: string, roomId: string, userid: string, file: FileData, registration: FileUploadRegistration, listener: FileUploadProgressListener): Promise<void> {
+        const chunkSize = this.calculateChunkSize(file.data.size);
+        const totalChunks = Math.ceil(file.data.size / chunkSize);
+
+        const arrayBuffer = await file.data.arrayBuffer();
+
+        for (let i = 0; i < totalChunks; i++) {
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, file.data.size);
+            const chunk = new Uint8Array(arrayBuffer.slice(start, end));
+            const base64 = this.uint8ToBase64(chunk);
+            await this.uploadChunk(uploadId, roomId, userid, registration.fileId, base64);
+            listener.fileProgressUpdate(file.fileId, totalChunks, i)
+        }
+    }
+
+    private uint8ToBase64(uint8: Uint8Array): string {
+        let binString = "";
+        for (let i = 0; i < uint8.length; i++) {
+            binString += String.fromCharCode(uint8[i]);
+        }
+        return btoa(binString);
+    }
+
+    private async uploadChunk(uploadId: string, roomId: string, userid: string, fileId: string, chunk: string): Promise<void> {
+        try {
+            await this.cdnClient.post<RegisterUploadResp>("chat/uploadChunk", <ChunkUploadReq>{
+                roomId: roomId,
+                userid: userid,
+                fileId: fileId,
+                chunk: chunk,
+                uploadId: uploadId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/networkService.test.ts
+++ b/src/services/networkService.test.ts
@@ -6,7 +6,7 @@ import {getClient} from "../core/http";
 import {environment, SDKConfig} from "../core/environment";

 describe("NetworkService", () => {
-    const service = new NetworkService("", "", "", new DatabaseMock(), getClient(false))
+    const service = new NetworkService("", "", "", new DatabaseMock(), (action, data) => {})

    it('should get invites', async () => {
        const invites = await service.getInvites();
--- a/src/services/networkService.ts
+++ b/src/services/networkService.ts
@@ -1,5 +1,4 @@
 import {DatabaseAPI} from "../storage/database";
-import {AuthMethods} from "../domain/authService.schema";
 import {getClient} from "../core/http";
 import {AxiosInstance, isAxiosError} from "axios";
 import {GenericErrorBody} from "../domain/http.schema";
@@ -18,7 +17,9 @@ import {
    UnbanMemberReq, UploadNewPictureReq
 } from "../domain/networkService.schema";
 import {PublicUserData, RGB} from "../domain/common.schema";
-import {http} from "msw";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {MessageListener} from "../domain/websocket.schema";
+import {Message} from "../domain/dmService.schema";

 export class NetworkService {
    userid: string;
@@ -26,15 +27,26 @@ export class NetworkService {
    database: DatabaseAPI;
    client: AxiosInstance

-    constructor(userid: string, token: string, networkId: string, database: DatabaseAPI, httpClientOverwrite: AxiosInstance | null) {
+    constructor(userid: string, token: string, networkId: string, database: DatabaseAPI, wsMessageListener: MessageListener) {
        this.userid = userid;
        this.networkId = networkId;
        this.database = database;
-        this.client = (httpClientOverwrite ?? getClient(false)).create({
+        this.client = getClient(false).create({
            headers: {
-                "Authorization": token
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
            }
        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: networkId,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("NetworkService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
    }

    /**
@@ -86,6 +98,7 @@ export class NetworkService {
            const resp = await this.client.post<Network[]>("network/get", <GetNetworksReq>{
                userid: this.userid,
            });
+            this.database.set("networks", this.userid, JSON.stringify(resp.data))
            return resp.data
        } catch (e) {
            if (isAxiosError<GenericErrorBody>(e)) {
@@ -95,13 +108,22 @@ export class NetworkService {
        }
    }

+    getQuick(): Message[] {
+        const networks = this.database.get("networks", this.userid)
+        if (networks) {
+            return JSON.parse(networks)
+        } else {
+            throw new Error("No networks in database")
+        }
+    }
+
    /**
     * Accepts the invite and joins the network
     * @param inviteId
     */
    async acceptInvite(inviteId: string): Promise<void> {
        try {
-            const resp = await this.client.post("network/acceptInvite", <AcceptInviteReq>{
+            await this.client.post("network/acceptInvite", <AcceptInviteReq>{
                userid: this.userid,
                inviteId: inviteId,
            });
@@ -852,7 +874,7 @@ export class NetworkService {
    }

    /**
-     * Fetches network data from an invite
+     * Fetches network data from an invitation
     * @param inviteId
     */
    async getFromInvite(inviteId: string): Promise<Network> {
--- a/src/services/pictureService.test.ts
+++ b/src/services/pictureService.test.ts
@@ -4,7 +4,7 @@ import {DatabaseMock} from "../mocks/storage/database";
 import {faker} from "@faker-js/faker/locale/en";

 describe("PictureService", () => {
-    const service = new PictureService("", "", "", new DatabaseMock(), null, null)
+    const service = new PictureService("", "", "", new DatabaseMock())

    it('should get pictures', async () => {
        const uploads = await service.get()
--- a/src/services/pictureService.ts
+++ b/src/services/pictureService.ts
@@ -12,6 +12,7 @@ import {
    GetResp, PostCommentReq, ToggleFollowReq, TogglePictureLikeReq, UploadImageReq
 } from "../domain/pictureService.schema";
 import {environment} from "../core/environment";
+import {Message} from "../domain/dmService.schema";

 export class PictureService {
    userid: string;
@@ -20,16 +21,16 @@ export class PictureService {
    client: AxiosInstance
    cdnClient: AxiosInstance

-    constructor(token: string, uploaderId: string, userid: string, database: DatabaseAPI, httpClientOverwrite: AxiosInstance | null, cdnClientOverwrite: AxiosInstance | null) {
+    constructor(token: string, uploaderId: string, userid: string, database: DatabaseAPI) {
        this.userid = userid;
        this.uploaderId = uploaderId;
        this.database = database;
-        this.client = (httpClientOverwrite ?? getClient(false)).create({
+        this.client = getClient(false).create({
            headers: {
                "Authorization": token
            }
        })
-        this.cdnClient = (cdnClientOverwrite ?? getClient(true)).create({
+        this.cdnClient = getClient(true).create({
            headers: {
                "Authorization": token
            }
@@ -42,6 +43,7 @@ export class PictureService {
    async get(): Promise<GetResp> {
        try {
            const resp = await this.client.get<GetResp>(`picture/pictures?userid=${this.userid}&target=${this.uploaderId}`);
+            this.database.set("pictures", this.uploaderId, JSON.stringify(resp.data))
            return resp.data
        } catch (e) {
            console.log(e)
@@ -52,6 +54,15 @@ export class PictureService {
        }
    }

+    getQuick(): Message[] {
+        const pictures = this.database.get("pictures", this.uploaderId)
+        if (pictures) {
+            return JSON.parse(pictures)
+        } else {
+            throw new Error("No pictures in database")
+        }
+    }
+
    /**
     * Fetches the top 10 most liked and newest pictures
     */
--- a/src/services/sessionManager.ts
+++ b/src/services/sessionManager.ts
@@ -0,0 +1,133 @@
+import {PublicUserData} from "../domain/common.schema";
+import {DatabaseAPI} from "../storage/database";
+import {KeyringAPI} from "../storage/keyring";
+import {KeyValueAPI} from "../storage/keyvalue";
+import {Session, ValidateSessionReq, ValidateSessionResp} from "../domain/sessionManager.schema";
+import {AxiosInstance} from "axios";
+import {getClient} from "../core/http";
+import {PersonalUserData} from "../domain/userService.schema";
+
+export class SessionManager {
+    client: AxiosInstance;
+    database: DatabaseAPI;
+    keyring: KeyringAPI;
+    KeyValue: KeyValueAPI;
+
+    constructor(database: DatabaseAPI, keyring: KeyringAPI, KeyValue: KeyValueAPI) {
+        this.database = database;
+        this.keyring = keyring;
+        this.KeyValue = KeyValue;
+        this.client = getClient(false)
+    }
+
+    /**
+     * Saves the new session to the database and the keyring
+     * @param userData
+     * @param token
+     */
+    addSession(userData: PublicUserData, token: string): void {
+        this.database.set("sessions", userData.userid, JSON.stringify(userData))
+        this.keyring.set(userData.userid, token)
+    }
+
+    /**
+     * Loads all saved sessions
+     */
+    loadSessions(): Session[] {
+        const tokens = this.keyring.getAll()
+        const sessions: Session[] = []
+        tokens.forEach(token => {
+            const userData = this.database.get("sessions", token.split(".")[0])
+            if (userData) {
+                sessions.push({
+                    token: token,
+                    userData: JSON.parse(userData)
+                })
+            }
+        })
+
+        return sessions
+    }
+
+    /**
+     * Gets the preferred user set by the client
+     */
+    getPreferredUser(): string {
+        return this.KeyValue.get("preferredUser") ?? ""
+    }
+
+    /**
+     * Sets a new preferred user
+     * @param userid
+     */
+    setPreferredUser(userid: string): void {
+        this.KeyValue.set("preferredUser", userid)
+    }
+
+    /**
+     * Loads the preferred session by the client
+     */
+    loadPreferredSession() {
+        const sessions = this.loadSessions()
+        let preferredUser = this.getPreferredUser()
+        if (preferredUser == "") {
+            preferredUser = sessions[0].userData.userid
+            this.setPreferredUser(sessions[0].userData.userid)
+        }
+
+        const preferredSession = sessions.find(s => s.userData.userid == preferredUser)
+        if (preferredSession) {
+            return preferredSession
+        } else {
+            return sessions[0]
+        }
+    }
+
+    /**
+     * Validates and updates all sessions and returns with a new session list
+     * @param sessions
+     */
+    updateSessions(sessions: Session[]): Session[] {
+        sessions.forEach(async session => {
+            const index = sessions.indexOf(session)
+            if (!await this.validateSession(session.token)) {
+                this.database.delete("sessions", session.userData.userid)
+                this.keyring.delete(session.userData.userid)
+                sessions.splice(index, 1)
+            }
+
+            const updatedUserData = await this.updateUserData(session)
+            this.database.set("sessions", session.userData.userid, updatedUserData)
+            sessions[index] = updatedUserData
+        })
+
+        return sessions
+    }
+
+    private async validateSession(token: string): Promise<boolean> {
+        try {
+            const resp = await this.client.post<ValidateSessionResp>("v2/user/validateSession", <ValidateSessionReq>{
+                token: token,
+            })
+            return resp.data.validationOk
+        } catch (e) {
+            return true
+        }
+    }
+
+    private async updateUserData(session: Session): Promise<Session> {
+        const authenticatedClient = this.client.create({
+            headers: {
+                "Authorization": session.token,
+            }
+        })
+
+        try {
+            const resp = await authenticatedClient.get<PersonalUserData>(`user/byUseridPersonal?userid=${session.userData.userid}`)
+            session.userData = resp.data
+            return session
+        } catch (e) {
+            throw new Error("Session update error")
+        }
+    }
+}
--- a/src/services/textChannelService.ts
+++ b/src/services/textChannelService.ts
@@ -0,0 +1,280 @@
+import {DatabaseAPI} from "../storage/database";
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from "../domain/websocket.schema";
+import {getClient} from "../core/http";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {
+    DeleteMessagesReq,
+    EditMessageReq,
+    FinishMessageReq,
+    GetMessagePosResp, JoinWsRoomReq,
+    Message, PinMessageReq,
+    PinnedMessage, ReadMessagesReq, UnpinMessageReq
+} from "../domain/textChannelService.schema";
+import {NetworkInvite} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {FileData, FileUploadProgressListener} from "../domain/fileUploadService.schema";
+import {FileUploadService} from "./fileUploadService";
+
+export class TextChannelServiceService {
+    userid: string;
+    networkId: string;
+    categoryId: string;
+    channelId: string;
+    token: string;
+    database: DatabaseAPI;
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, networkId: string, categoryId: string, channelId: string, database: DatabaseAPI, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.networkId = networkId;
+        this.categoryId = categoryId;
+        this.channelId = channelId;
+        this.database = database;
+        this.token = token;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: channelId,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("NetworkService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+    }
+
+    /**
+     * Fetches all messages in the chat
+     * @param from
+     */
+    async get(from: number = 0): Promise<Message[]> {
+        try {
+            const resp = await this.client.get<Message[]>(`network/channel/messages?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}&from=${from}`);
+            if (from == 0) {
+                this.database.set("networkmessages", this.channelId, JSON.stringify(resp.data))
+            }
+            console.log(resp.data, "ASD")
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    getQuick(): Message[] {
+        const messages = this.database.get("networkmessages", this.channelId)
+        if (messages) {
+            return JSON.parse(messages)
+        } else {
+            throw new Error("No messages in database")
+        }
+    }
+
+    /**
+     * Fetches the position of the specified message which can be used in get() to fetch an old message with it's surrounding messages
+     * @param messageId
+     */
+    async getMessagePos(messageId: string): Promise<number> {
+        try {
+            const resp = await this.client.get<GetMessagePosResp>(`network/channel/getMessagePosition?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}&messageId=${messageId}`);
+            return resp.data.messagePos
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Gets all messages pinned in the chat
+     */
+    async getPinnedMessages(): Promise<PinnedMessage[]> {
+        try {
+            const resp = await this.client.get<PinnedMessage[]>(`network/channel/pinnedMessages?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}`);
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Edits the specified message
+     * @param messageId
+     * @param newMessage
+     */
+    async editMessage(messageId: string, newMessage: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/editMessage", <EditMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                message: newMessage
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Sends a new message to the chat
+     * @param message
+     * @param replyTo
+     * @param replyToMessage
+     * @param attachments
+     * @param progressListener
+     */
+    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null, progressListener: FileUploadProgressListener | null = null): Promise<Message> {
+        let uploadId = ""
+        if (attachments) {
+            const uploader = new FileUploadService(this.token)
+            uploadId = await uploader.uploadFiles(this.channelId, this.userid, attachments, progressListener!)
+        }
+        try {
+            const resp = await this.client.post<Message>("network/channel/finishMessage", <FinishMessageReq>{
+                message: message,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                replyTo: replyTo,
+                replyToMessage: replyToMessage,
+                userid: this.userid,
+                uploadId: uploadId,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Reads all messages sent to you in the chat
+     */
+    async readMessages(): Promise<void> {
+        try {
+            await this.client.patch("network/channel/readMessages", <ReadMessagesReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Pins the specified message
+     * @param messageId
+     * @param message
+     */
+    async pinMessage(messageId: string, message: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/pinMessage", <PinMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                message: message
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Unpins the specified message
+     * @param messageId
+     */
+    async unpinMessage(messageId: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/unpinMessage", <UnpinMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes the message(s)
+     * @param messageIds
+     */
+    async deleteMessages(messageIds: string[]): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/deleteMessages", <DeleteMessagesReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                messageIds: messageIds
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Joins the WebSocket room to start receiving realtime messages
+     */
+    async joinWebSocketRoom(): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/joinWebSocketRoom", <JoinWsRoomReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                connId: WebSocketHandler.getInstance().connId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/userService.test.ts
+++ b/src/services/userService.test.ts
@@ -0,0 +1,12 @@
+import {describe, expect, it} from "vitest";
+import {UserService} from "./userService";
+import {DatabaseMock} from "../mocks/storage/database";
+
+describe("UserService", () => {
+    const service = new UserService("", "", new DatabaseMock())
+
+    it('should get all sessions', async () => {
+        const sessions = await service.getSessions()
+        expect(sessions[0].token).toBe("sessionToken")
+    });
+})
--- a/src/services/userService.ts
+++ b/src/services/userService.ts
@@ -0,0 +1,253 @@
+import {DatabaseAPI} from "../storage/database";
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from "../domain/websocket.schema";
+import {getClient} from "../core/http";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {DeleteCategoryReq} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {
+    ChangeDisplayNameReq,
+    ChangeEmailReq,
+    ChangePasswordReq, ChangePhoneReq,
+    ChangeUsernameReq, CurrNewCodeTestingResp, DeleteReq, GetSessionsReq, GIF, RegisterFCMTokenReq, Session,
+    ToggleGifSaveReq, UploadNewPfpCdnReq, UploadNewPfpCdnResp,
+    UploadNewPfpReq, VerifyMailChangeReq, VerifyPhoneChange
+} from "../domain/userService.schema";
+import {RGB} from "../domain/common.schema";
+import {OtpPleCodeSendTestingResp} from "../domain/authService.schema";
+
+export class UserService {
+    userid: string;
+    database: DatabaseAPI;
+    client: AxiosInstance
+    cdnClient: AxiosInstance
+
+    constructor(userid: string, token: string, database: DatabaseAPI) {
+        this.userid = userid;
+        this.database = database;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+            }
+        })
+        this.cdnClient = getClient(true).create({
+            headers: {
+                "Authorization": token,
+            }
+        })
+    }
+
+    async changeUsername(username: string): Promise<void> {
+        try {
+            await this.client.patch("user/changeUsername", <ChangeUsernameReq>{
+                userid: this.userid,
+                newUsername: username,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async changeDisplayName(displayName: string): Promise<void> {
+        try {
+            await this.client.patch("user/changeDisplayName", <ChangeDisplayNameReq>{
+                userid: this.userid,
+                newDisplayName: displayName
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async changePassword(newPassword: string, currentPassword: string): Promise<void> {
+        try {
+            await this.client.patch("user/changePassword", <ChangePasswordReq>{
+                userid: this.userid,
+                currentPassword: currentPassword,
+                newPassword: newPassword,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async changeEmail(newMail: string, currentPassword: string): Promise<void|CurrNewCodeTestingResp> {
+        try {
+            const resp = await this.client.patch<CurrNewCodeTestingResp>("user/changeEmail", <ChangeEmailReq>{
+                userid: this.userid,
+                currentPassword: currentPassword,
+                newMail: newMail,
+            });
+            if (resp.data.codeCurr != null) {
+                return resp.data
+            } else {
+                return
+            }
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async uploadNewPfp(pfpId: string): Promise<void> {
+        try {
+            await this.client.patch("user/uploadNewPfp", <UploadNewPfpReq>{
+                userid: this.userid,
+                pfpId: pfpId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async uploadNewPfpCdn(image: string | null, monogramLetter: string | null, monogramColors: RGB): Promise<string> {
+        try {
+            const resp = await this.cdnClient.post<UploadNewPfpCdnResp>("pfp", <UploadNewPfpCdnReq>{
+                userid: this.userid,
+                data: image,
+                monogramColors: JSON.stringify(monogramColors),
+                isImage: image !== null,
+                monogramLetter: monogramLetter,
+            });
+            console.log(resp.data.pfpId, "PFPID")
+            return resp.data.pfpId
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async verifyEmailChange(vCodeCurrent: number, vCodeNew: number, newAddress: string): Promise<void> {
+        try {
+            await this.client.patch("user/verifyMailChange", <VerifyMailChangeReq>{
+                userid: this.userid,
+                newAddress: newAddress,
+                vCodeCurrent: vCodeCurrent,
+                vCodeNew: vCodeNew,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async delete(password: string): Promise<void> {
+        try {
+            await this.client.post("user/deleteAccount", <DeleteReq>{
+                userid: this.userid,
+                password: password
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async registerFirebaseToken(fcmToken: string): Promise<void> {
+        try {
+            await this.client.post("user/registerFcmToken", <RegisterFCMTokenReq>{
+                userid: this.userid,
+                token: fcmToken,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async getSessions(): Promise<Session[]> {
+        try {
+            const resp = await this.client.post<Session[]>("user/getSessions", <GetSessionsReq>{
+                userid: this.userid,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async toggleGIFSave(url: string): Promise<GIF> {
+        try {
+            const resp = await this.client.patch<GIF>("user/toggleGIFSave", <ToggleGifSaveReq>{
+                userid: this.userid,
+                url: url
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async changePhoneNumber(currentPassword: string, newPhone: string): Promise<CurrNewCodeTestingResp|void> {
+        try {
+            const resp = await this.client.patch<CurrNewCodeTestingResp>("user/changePhone", <ChangePhoneReq>{
+                userid: this.userid,
+                newPhone: newPhone,
+                currentPassword: currentPassword,
+            });
+            if (resp.data.codeCurr != null) {
+                return resp.data
+            } else {
+                return
+            }
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async verifyPhoneNumberChange(newPhone: string, vCodeCurrent: number, vCodeNew: number): Promise<void> {
+        try {
+            const resp = await this.client.patch("user/verifyPhoneChange", <VerifyPhoneChange>{
+                userid: this.userid,
+                newPhone: newPhone,
+                vCodeCurrent: vCodeCurrent,
+                vCodeNew: vCodeNew,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/storage/keyring.ts
+++ b/src/storage/keyring.ts
@@ -1,6 +1,6 @@
 export interface KeyringAPI {
    set(key: string, value: any): void;
    get(key: string): string;
+    getAll(): string[];
    delete(key: string): void;
-    flush(): void;
 }
--- a/src/storage/keyvalue.ts
+++ b/src/storage/keyvalue.ts
@@ -0,0 +1,6 @@
+export interface KeyValueAPI {
+    set(key: string, value: any): void;
+    get(key: string): string;
+    delete(key: string): void;
+    flush(): void;
+}
--- a/tests/broadcastChannelService.test.ts
+++ b/tests/broadcastChannelService.test.ts
@@ -0,0 +1,29 @@
+import {describe, expect, it} from "vitest";
+import {BroadcastChannelService} from "../src/services/broadcastChannelService";
+
+const BRC_CHAN_SERVICE_TESTING_NETWORK_ID = "000000000000000000000000"
+const BRC_CHAN_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+const BRC_CHAN_SERVICE_TESTING_CHANNEL_ID = "333333333333333333333333"
+const BRC_CHAN_SERVICE_TESTING_TOKEN = "testingToken"
+const BRC_CHAN_SERVICE_TESTING_CATEGORY_ID = "111111111111111111111111"
+
+describe("BroadcastChannelService Integration Testing", () => {
+    const service = new BroadcastChannelService(
+        BRC_CHAN_SERVICE_TESTING_TOKEN,
+        BRC_CHAN_SERVICE_TESTING_USER_ID,
+        BRC_CHAN_SERVICE_TESTING_NETWORK_ID,
+        BRC_CHAN_SERVICE_TESTING_CATEGORY_ID,
+        BRC_CHAN_SERVICE_TESTING_CHANNEL_ID,
+        (action, data) => {}
+    )
+
+    it('should create a new server and fetch it', async () => {
+        await service.createServer()
+        const registry = await service.getData()
+        expect(registry.status).toBe("idling")
+    });
+
+    it('should join ws room', async () => {
+        await service.joinWebSocketRoom()
+    });
+})
--- a/tests/chatsService.test.ts
+++ b/tests/chatsService.test.ts
@@ -0,0 +1,14 @@
+import {describe, expect, it} from "vitest";
+import {DatabaseMock} from "../src/mocks/storage/database";
+import {ChatService} from "../src/services/chatService";
+
+describe("ChatService Integration Testing", () => {
+    const CHAT_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+    const CHAT_SERVICE_TESTING_TOKEN = "testingToken"
+    const service = new ChatService(CHAT_SERVICE_TESTING_USER_ID, CHAT_SERVICE_TESTING_TOKEN, new DatabaseMock(), () => {})
+
+    it('should get chats', async () => {
+        const chats = await service.get()
+        expect(chats[0].username).toBe("bob")
+    })
+})
--- a/tests/dmService.test.ts
+++ b/tests/dmService.test.ts
@@ -0,0 +1,61 @@
+import {describe, expect, it} from "vitest";
+import {DMService} from "../src/services/dmService";
+import {ChatService} from "../src/services/chatService";
+import {DatabaseMock} from "../src/mocks/storage/database";
+import {faker} from "@faker-js/faker/locale/en";
+
+describe("DmService Integration Testing", () => {
+    const DM_SERVICE_TESTING_CHAT_ID = "000000000000000000000000"
+    const DM_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+    const DM_SERVICE_TESTING_MESSAGE_ID = "111111111111111111111111"
+    const DM_SERVICE_TESTING_TOKEN = "testingToken"
+
+    const service = new DMService(
+        DM_SERVICE_TESTING_USER_ID,
+        DM_SERVICE_TESTING_TOKEN,
+        DM_SERVICE_TESTING_CHAT_ID,
+        new DatabaseMock(),
+        () => {}
+    )
+
+    it('should get messages', async () => {
+        const messages = await service.get()
+        expect(messages[0].message).toBe("This is a message")
+        expect(messages[0].isEdited).toBeTruthy()
+    });
+
+    it('should get message position', async () => {
+        const pos = await service.getMessagePos(DM_SERVICE_TESTING_MESSAGE_ID)
+        expect(pos).toBe(0)
+    });
+
+    it('should edit message', async () => {
+        const newMessage = faker.lorem.paragraph()
+        await service.editMessage(DM_SERVICE_TESTING_MESSAGE_ID, newMessage)
+        const messages = await service.get()
+        expect(messages[0].message).toBe(newMessage)
+    });
+
+    it('should send a message', async () => {
+        const message = faker.lorem.paragraph()
+        const newMessage = await service.sendMessage(message)
+        expect(newMessage.message).toBe(message)
+    });
+
+    it('should read messages', async () => {
+        await service.readMessages()
+    });
+
+    it('should pin and unpin messages', async () => {
+        let pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+
+        await service.pinMessage(DM_SERVICE_TESTING_MESSAGE_ID, "message")
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(1)
+
+        await service.unpinMessage(DM_SERVICE_TESTING_MESSAGE_ID)
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+    });
+})
--- a/tests/fileUploadService.test.ts
+++ b/tests/fileUploadService.test.ts
@@ -0,0 +1,37 @@
+import {describe, it} from "vitest";
+import {FileUploadService} from "../src/services/fileUploadService";
+import {environment, SDKConfig} from "../src/core/environment";
+import {getClient} from "../src/core/http";
+import {FileData} from "../src/domain/fileUploadService.schema";
+import axios from "axios";
+import {v4 as uuidv4} from 'uuid';
+
+describe("FileUploadService Integration Testing", () => {
+    const FILE_UPL_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+    const FILE_UPL_SERVICE_TESTING_CHAT_ID = "000000000000000000000000"
+    const FILE_UPL_SERVICE_TESTING_TOKEN = "testingToken"
+
+    it('should upload all files', async () => {
+        const response = await axios.get("https://picsum.photos/500", {
+            responseType: 'blob'
+        });
+
+        const service = new FileUploadService(FILE_UPL_SERVICE_TESTING_TOKEN);
+        await service.uploadFiles(
+            FILE_UPL_SERVICE_TESTING_CHAT_ID,
+            FILE_UPL_SERVICE_TESTING_USER_ID,
+            [
+                {
+                    fileId: uuidv4(),
+                    name: "filename",
+                    type: "image",
+                    extension: "jpeg",
+                    data: new File([response.data], "filename", { type: "image/jpeg" })
+                }
+            ],
+            {
+                fileProgressUpdate: () => {},
+            }
+        )
+    });
+})
--- a/tests/networkService.test.ts
+++ b/tests/networkService.test.ts
@@ -18,13 +18,12 @@ const NETWORK_SERVICE_TESTING_INVITE_ID = "444444444444444444444444"
 const NETWORK_SERVICE_TESTING_TOKEN = "testingToken"

 describe("NetworkService Integration Testing", () => {
-    environment.overwrite(<SDKConfig>{apiUrl: "http://localhost:3000"})
    const service = new NetworkService(
        NETWORK_SERVICE_TESTING_USER_ID,
        NETWORK_SERVICE_TESTING_TOKEN,
        NETWORK_SERVICE_TESTING_NETWORK_ID,
        new DatabaseMock(),
-        getClient(false),
+        (action, data) => {}
    )

    it("should get invites", async () => {
@@ -57,12 +56,6 @@ describe("NetworkService Integration Testing", () => {
        expect(category.name).toBe(catName)
    });

-    it('should delete category', async () => {
-        await service.deleteCategory(NETWORK_SERVICE_TESTING_CATEGORY_ID)
-        const networks = await service.get()
-        expect(networks[0].categories.length).toBe(0)
-    });
-
    it('should move category', async () => {
        await service.createCategory("Test name", "Test desc")
        await service.moveCategory(0, 1)
@@ -75,7 +68,7 @@ describe("NetworkService Integration Testing", () => {
    });

    it('should create rank', async () => {
-        const rankName = faker.internet.displayName()
+        const rankName = faker.internet.displayName().substring(0, 10)
        const rank = await service.createRank(rankName, <RGB>{r: 0, g: 0, b: 0}, null)
        expect(rank.name).toBe(rankName)
    });
--- a/tests/pictureService.test.ts
+++ b/tests/pictureService.test.ts
@@ -11,14 +11,11 @@ const PICTURE_SERVICE_TESTING_USER_ID = "000000000000000000000000"
 const PICTURE_SERVICE_TESTING_IMAGE_ID = "111111111111111111111111"

 describe("PictureService Integration Test", () => {
-    environment.overwrite(<SDKConfig>{apiUrl: "http://localhost:3000", cdnUrl: "http://localhost:4000"})
    const service = new PictureService(
        PICTURE_SERVICE_TESTING_TOKEN,
        PICTURE_SERVICE_TESTING_USER_ID,
        PICTURE_SERVICE_TESTING_USER_ID,
-        new DatabaseMock(),
-        getClient(false),
-        getClient(true),
+        new DatabaseMock()
    )

    it('should get uploads', async () => {
@@ -27,7 +24,7 @@ describe("PictureService Integration Test", () => {
    });

    it('should create an album', async () => {
-        const albumName = faker.internet.displayName()
+        const albumName = faker.internet.displayName().substring(0, 10)
        await service.createAlbum(albumName)
        const uploads = await service.get()
        expect(uploads.pictures[1].name).toBe(albumName)
--- a/tests/textChannelService.test.ts
+++ b/tests/textChannelService.test.ts
@@ -0,0 +1,66 @@
+import {describe, expect, it} from "vitest";
+import {DMService} from "../src/services/dmService";
+import {ChatService} from "../src/services/chatService";
+import {DatabaseMock} from "../src/mocks/storage/database";
+import {faker} from "@faker-js/faker/locale/en";
+import {TextChannelServiceService} from "../src/services/textChannelService";
+
+describe("DmService Integration Testing", () => {
+    const TXT_CHAN_SERVICE_TESTING_CHANNEL_ID = "222222222222222222222222"
+    const TXT_CHAN_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+    const TXT_CHAN_SERVICE_TESTING_MESSAGE_ID = "111111111111111111111111"
+    const TXT_CHAN_SERVICE_TESTING_TOKEN = "testingToken"
+    const NETWORK_SERVICE_TESTING_NETWORK_ID = "000000000000000000000000"
+    const NETWORK_SERVICE_TESTING_CATEGORY_ID = "111111111111111111111111"
+
+    const service = new TextChannelServiceService(
+        TXT_CHAN_SERVICE_TESTING_USER_ID,
+        TXT_CHAN_SERVICE_TESTING_TOKEN,
+        NETWORK_SERVICE_TESTING_NETWORK_ID,
+        NETWORK_SERVICE_TESTING_CATEGORY_ID,
+        TXT_CHAN_SERVICE_TESTING_CHANNEL_ID,
+        new DatabaseMock(),
+        () => {}
+    )
+
+    it('should get messages', async () => {
+        const messages = await service.get()
+        expect(messages[0].message).toBe("This is a message")
+        expect(messages[0].isEdited).toBeTruthy()
+    });
+
+    it('should get message position', async () => {
+        const pos = await service.getMessagePos(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID)
+        expect(pos).toBe(0)
+    });
+
+    it('should edit message', async () => {
+        const newMessage = faker.lorem.paragraph()
+        await service.editMessage(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID, newMessage)
+        const messages = await service.get()
+        expect(messages[0].message).toBe(newMessage)
+    });
+
+    it('should send a message', async () => {
+        const message = faker.lorem.paragraph()
+        const newMessage = await service.sendMessage(message)
+        expect(newMessage.message).toBe(message)
+    });
+
+    it('should read messages', async () => {
+        await service.readMessages()
+    });
+
+    it('should pin and unpin messages', async () => {
+        let pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+
+        await service.pinMessage(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID, "message")
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(1)
+
+        await service.unpinMessage(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID)
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+    });
+})
--- a/tests/userService.test.ts
+++ b/tests/userService.test.ts
@@ -0,0 +1,50 @@
+import {describe, expect, it} from "vitest";
+import {UserService} from "../src/services/userService";
+import {DatabaseMock} from "../src/mocks/storage/database";
+import {RGB} from "../src/domain/common.schema"
+
+const USER_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+const USER_SERVICE_TESTING_TOKEN = "testingToken"
+
+
+describe("UserService Integration Testing", () => {
+    const service = new UserService(USER_SERVICE_TESTING_USER_ID, USER_SERVICE_TESTING_TOKEN, new DatabaseMock())
+    
+    it('should not throw on username change', async () => {
+        await service.changeUsername("bob2")
+    });
+
+    it('should not throw on displayName change', async () => {
+        await service.changeDisplayName("New Display Name")
+    });
+
+    it('should set new password', async () => {
+        await service.changePassword("newPasswd", "") // The filler user doesn't have a password set yet
+    });
+
+    it('should set new e-mail', async () => {
+        const code = await service.changeEmail("bob2@example.com", "")
+        expect(code).not.toBeNull()
+        if (code != null) {
+            await service.verifyEmailChange(code.codeCurr??0, code.codeNew??0, "bob2@example.com")
+        }
+    });
+
+    it('should upload a new pfp', async () => {
+        const pfpId = await service.uploadNewPfpCdn(null, "A", <RGB>{r: 255, g: 255, b: 255})
+        await service.uploadNewPfp(pfpId)
+    });
+
+    it('should get sessions', async () => {
+        const sessions = await service.getSessions()
+        expect(sessions[0].token).toBe(USER_SERVICE_TESTING_TOKEN)
+    });
+
+    it('should set new phone', async () => {
+        const code = await service.changePhoneNumber("", "+36201234567")
+        expect(code).not.toBeNull()
+        if (code != null) {
+            await service.verifyPhoneNumberChange("+36201234567", code.codeCurr??0, code.codeNew??0)
+        }
+    });
+})
--- a/tests/vitest.setup.integration.ts
+++ b/tests/vitest.setup.integration.ts
@@ -3,9 +3,5 @@ import {environment, SDKConfig} from "../src/core/environment";
 import {getClient} from "../src/core/http";

 beforeEach(async () => {
-    environment.overwrite(<SDKConfig>{
-        apiUrl: "http://localhost:3000"
-    })
-
-    await getClient().post("v2/reset")
+    await getClient(false).post("v2/reset")
 })
--- a/tests/webSocketHandler.test.ts
+++ b/tests/webSocketHandler.test.ts
@@ -0,0 +1,14 @@
+import {describe, it} from "vitest";
+import {WebSocketHandler} from "../src/core/webSocketHandler";
+
+const WEBSOCKET_HANDLER_TESTING_USER_ID = "000000000000000000000000"
+const WEBSOCKET_HANDLER_TESTING_USER_TOKEN = "testingToken"
+
+describe("WebSocketHandler", () => {
+    it("should connect", async () => {
+        await WebSocketHandler.getInstance().connect(
+            WEBSOCKET_HANDLER_TESTING_USER_ID,
+            WEBSOCKET_HANDLER_TESTING_USER_TOKEN
+        )
+    })
+})
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -4,6 +4,7 @@
    "module": "commonjs",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
    "strict": true,
    "skipLibCheck": true,
    "outDir": "dist"
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -2,6 +2,8 @@ import { defineConfig } from 'vitest/config';

 export default defineConfig({
    test: {
+        maxWorkers: 1,
+        minWorkers: 1,
        // Top-level configuration (global only)
        coverage: { provider: 'v8' },
Author	SHA1	Message	Date
chatenium	7ba341203d	Quick-fix All checks were successful Setup testing environment and test the code / build (push) Successful in 1m6s Details Publish to NPM / build-and-publish (release) Successful in 36s Details	2026-04-08 16:44:41 +02:00
chatenium	54d466fb27	Quick-fix All checks were successful Publish to NPM / build-and-publish (release) Successful in 34s Details Setup testing environment and test the code / build (push) Successful in 1m30s Details	2026-04-08 16:37:32 +02:00
chatenium	07d30f7e83	Quick-fix All checks were successful Setup testing environment and test the code / build (push) Successful in 1m28s Details	2026-04-08 14:22:58 +02:00
Almsss	cd806b7d17	Update package.json Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:59:00 +02:00
Almsss	7daf542961	Update .gitea/workflows/publish.yml Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:55:29 +02:00
Almsss	f911224847	Update .gitea/workflows/publish.yml Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:53:45 +02:00
chatenium	c8d2de9f9d	Merge remote-tracking branch 'origin/main' Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:51:47 +02:00
chatenium	f8de78f3ab	Type fixes	2026-04-08 13:51:43 +02:00
Almsss	e07114b1c0	Update .gitea/workflows/publish.yml Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:50:17 +02:00
Almsss	e8c6b9c920	Update .gitea/workflows/publish.yml Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:47:51 +02:00
Almsss	0a97a2cc48	Add .gitea/workflows/publish Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:47:38 +02:00
chatenium	0b38b002df	Implemented SessionManager and TextChannelService + several improvements and fixes All checks were successful Setup testing environment and test the code / build (push) Successful in 1m13s Details	2026-04-08 13:21:11 +02:00
chatenium	a9322e3454	Implemented BroadcastChannelService and FileTransferService All checks were successful Setup testing environment and test the code / build (push) Successful in 1m17s Details	2026-04-08 08:46:16 +02:00
chatenium	e6798b4be8	Mock database hotfix All checks were successful Setup testing environment and test the code / build (push) Successful in 1m6s Details	2026-04-07 11:37:29 +02:00
chatenium	55e4aad0a9	Merge remote-tracking branch 'origin/main' Some checks failed Setup testing environment and test the code / build (push) Failing after 1m24s Details	2026-04-07 11:19:42 +02:00
chatenium	4f96b1d687	Added caching and implemented UserService	2026-04-07 11:19:38 +02:00
chatenium	aa451e4786	Fix grammar	2026-04-07 10:15:05 +02:00
Almsss	e9eb95e9b7	Add LICENSE All checks were successful Setup testing environment and test the code / build (push) Successful in 1m29s Details	2026-04-07 10:13:30 +02:00
chatenium	f787ec56a8	Merge remote-tracking branch 'origin/main' All checks were successful Setup testing environment and test the code / build (push) Successful in 1m17s Details	2026-04-06 08:00:21 +02:00
chatenium	91bb2a5d9c	Implemented DMService	2026-04-06 08:00:16 +02:00
Almsss	13708bcee8	Update .gitea/workflows/test.yml All checks were successful Setup testing environment and test the code / build (push) Successful in 1m24s Details	2026-04-05 16:04:53 +02:00
Almsss	7069cc0b0f	Update .gitea/workflows/test.yml Some checks failed Setup testing environment and test the code / build (push) Failing after 53s Details	2026-04-05 16:02:20 +02:00
chatenium	0abd377f81	Add debug Some checks failed Setup testing environment and test the code / build (push) Failing after 58s Details	2026-04-05 15:59:31 +02:00
chatenium	f4bb1d91c2	WebSocket update Some checks failed Setup testing environment and test the code / build (push) Failing after 1m6s Details	2026-04-05 15:57:22 +02:00
chatenium	f6b5d12914	WebSocket update Some checks failed Setup testing environment and test the code / build (push) Failing after 1m4s Details	2026-04-05 15:52:39 +02:00
Almsss	52eb73374b	Update .gitea/workflows/test.yml Some checks failed Setup testing environment and test the code / build (push) Failing after 1m11s Details	2026-04-05 15:49:38 +02:00
chatenium	4a34d73c2f	Code quality improvements and cleanup + Implemented ChatService Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-05 15:19:55 +02:00
chatenium	ec418ca7c9	Remove env overwrites (Not needed anymore) Some checks failed Setup testing environment and test the code / build (push) Failing after 1m3s Details	2026-04-05 12:33:01 +02:00
Almsss	71788140c0	Update .gitea/workflows/test.yml Some checks failed Setup testing environment and test the code / build (push) Failing after 1m19s Details	2026-04-05 12:31:02 +02:00
chatenium	afedc9debc	Remove env overwrites (Not needed anymore) Some checks failed Setup testing environment and test the code / build (push) Failing after 54s Details	2026-04-05 12:25:54 +02:00
chatenium	431b33a2b9	Updated environment.ts and workflow Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-05 12:21:38 +02:00
Almsss	6c1161b827	Update .gitea/workflows/test.yml Some checks failed Setup testing environment and test the code / build (push) Failing after 2m26s Details	2026-04-05 12:10:01 +02:00
Almsss	49e0d856d5	Update .gitea/workflows/test.yml Some checks failed Setup testing environment and test the code / build (push) Failing after 22s Details	2026-04-05 11:58:59 +02:00
Almsss	ebe95f6e30	Update .gitea/workflows/test.yml Some checks failed Setup testing environment and test the code / build (push) Failing after 1s Details	2026-04-05 11:57:27 +02:00
chatenium	e00de3dd0f	Finished implementing FileUploadService + added test workflow Some checks failed Setup testing environment and test the code / build (push) Failing after 0s Details	2026-04-05 11:53:44 +02:00
chatenium	e390012b1f	Finished implementing FileUploadService + added test workflow	2026-04-05 11:50:44 +02:00