Portal-iQ A HubSpot Audit from Portal-iQ is a quick and easy way to maximise your use of HubSpot. By scanning your HubSpot set up, it can quickly identify any issues or opportunities.

Portal-iQ provides key recommendations combined with up to date data to help you maximise HubSpot for your marketing, sales, and customer support. Powered by Webalite, a certified HubSpot Partner Agency based in Wellington, New Zealand. Portal-iQ is a quick and easy way to maximise your use of HubSpot. By scanning your HubSpot set up, it can quickly identify any issues or opportunities, and provide a prioritised actionable summary of recommendations. Portal-iQ helps: - Marketers convert more leads. - Sales teams close more deals. - Customer success people help more customers. - HubSpot teams become more effective. Used effectively, HubSpot can help you to improve your business performance, increase leads, maximise your sales opportunities, and help you deliver excellent customer service. With Portal-iQ, you can ensure your HubSpot portal is set-up to support the long-term success of your business and continues to deliver all the benefits of your HubSpot investment. Please note: Portal-iQ doesn’t specifically read your data/information, so data privacy is maintained throughout the analysis. It takes a higher-level approach of scanning for ‘field completion’ and feature use to ensure you are maximising your HubSpot investment. We never use artificial intelligence (A.I.) to analyse data.

Portal-iQ

portaliq

Part One: SOAP-based APIs Simple Object Access Protocol (SOAP) is a messaging protocol based on requests and responses using an XML format. Although some legacy systems still use SOAP over SMTP, the transport method typically used for SOAP requests is HTTP. As an API protocol, SOAP is platform- and language-agnostic, allowing for two applications running on completely different systems to communicate with one another. This post is part of a two-part series covering how to create custom API endpoints in Salesforce with APEX. In Part One, we’ll walk through how to create a SOAP-based API endpoint for other applications to use when communicating with your Salesforce org. A Brief Introduction to SOAP Each SOAP message is contained in an “envelope,” which has a header and a body. The header contains application-related information, such as the date when the message was generated or ids related to the message context. The body contains the actual message. Here is an example SOAP message with a format that would be used for authenticating to Salesforce: <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:urn="urn:enterprise.soap.sforce.com">
   <soapenv:Header>
      <urn:LoginScopeHeader>
         <urn:organizationId>12345</urn:organizationId>
         <urn:portalId>abcde</urn:portalId>
      </urn:LoginScopeHeader>
   </soapenv:Header>
   <soapenv:Body>
      <urn:login>
         <urn:username>johndoe</urn:username>
         <urn:password>mypassword</urn:password>
      </urn:login>
   </soapenv:Body>
</soapenv:Envelope> Since each message has the same structure, SOAP is system agnostic. For example, an application running on a Windows 11 machine can send a message to another application running on a Unix-based web server. Though the message can be sent using SMTP or HTTP, SOAP messages should ideally be sent with HTTPS, with either simple or mutual authentication. SOAP is mostly used to create an or to exchange server-to-server information. Therefore, it is very important for the two systems to establish trust. Salesforce provides multiple ways to accomplish authentication. API web service The relationship between SOAP and WSDL Although all SOAP messages have the same structure, the SOAP specification doesn’t define other aspects, such as message format or transport protocol. The Web Services Description Language (WSDL) describes the message formats, transport details, and operations of the web service. The WSDL file can be considered a contract between the client and the service. How to Create a SOAP-based API in Salesforce Now that we have covered the fundamentals let’s begin implementing our SOAP API. Set up a Salesforce org First, you need a Salesforce org. Salesforce provides free Developer edition orgs, and signing up for one is straightforward. Go to the and provide your details. You should receive an invite link within a few minutes. sign-up page Creating a global class with Apex To create a SOAP web service in Salesforce, we will need to create a globally defined Apex custom class. In our class, we’ll use the keyword and definition modifier for every method we want to expose. Adding the keyword automatically gives global access to the method it is added to. webservice static webservice In order to create this class in our shiny, new org, we go to , and then find . In the table listing existing classes, we click . Setup Custom Code -> Apex Classes New To learn more about Apex and how to create classes, check out this and the . Trailhead page Apex documentation Below, we have a sample class that exposes a method used to create new Contact records in Salesforce. The method accepts a Contact’s details as parameters and inserts a new Contact record. ContactAPI createContact If successful, it returns the ID of the newly created Contact along with a message. In case of a failure, it returns an error message. Please copy the code and paste it into the newly created empty class. global class ContactAPI {
  webservice static String createContact (String firstName, String lastName, String contactEmail, String salutation) { 
    try {
      Contact newContact = new Contact();
      newContact.Salutation = salutation;
      newContact.FirstName = firstName;
      newContact.LastName = lastName;
      newContact.Email = contactEmail;

      insert newContact;
      return 'Successfully inserted new Contact! Id:' + String.valueOf(newContact.Id);
    } catch (Exception e) {
      return 'Error:' + e.getMessage();
    }
  }
} Next, we click . Save That’s it! Our web service is ready for operations. We have successfully created a SOAP API in Salesforce. Generate the WSDL We now need to generate a WSDL file and provide it to the external application or third-party developers who can then consume it to call our method. createContact Salesforce provides two out-of-the-box WSDL files to integrate client applications with Salesforce: The is optimized for a single Salesforce org. It’s strongly typed, meaning it contains objects and field definitions for this particular org. Whenever there is a change in the metadata (object and/or fields) in the Salesforce org, a new WSDL needs to be generated and provided to the client (to consume again). Enterprise WSDL The is optimized for use with many Salesforce orgs. It’s loosely typed, and it doesn’t change based on an org’s specific configuration. Partner WSDL In order to utilize our web service, we’ll use the WSDL for our Apex class (to actually call our web service), and we’ll use the Enterprise WSDL to authenticate to Salesforce. After creating our class, we see it show up in the list of Apex classes. In the row for ContactAPI, we click on the link to generate a WSDL. ContactAPI WSDL This will open a new tab with our WSDL, which will look similar to this: We save this file to our local machine, naming it . contactAPI-wsdl.xml To generate the Enterprise WSDL for our Salesforce org, we go to the Setup page, and then find . Then, we click on . Integrations -> API Generate Enterprise WSDL Your generated WSDL should look similar to this: We save this file to our local machine, naming it . enterprise_wsdl.xml To generate the WSDL for your Apex Class: Go to the Setup page. Type and select Apex Classes. Find your class. In our case, it’s ContactAPI. Click on the name. On the next screen, you will have the class page where you have the button. Generate WSDL Test and validate To ensure that the web service works, we’ll consume it by calling it from our web application and see if it responds correctly. We’ll also cover how to validate our API with unit testing. Consume the API For the purpose of this demo, we’ll use , which is an open-source tool to test SOAP (and other protocols) web services. With SoapUI installed and running, we create a new SOAP Project, providing a name and selecting our file as the initial WSDL. SoapUI enterprise_wsdl.xml We now have all available Salesforce SoapBindings listed on the left. First, we need to authenticate our web application to Salesforce. We do this by using the call and providing our login credentials. login Use a security token For added security, we also need to add a to our password to authenticate. We can get a security token by going to the page and selecting on the left. Then, press the button with the same name. We will then receive our security token by email. Security Token Settings Reset My Security Token Log in with the token and credentials With our token in hand, we select the SoapBinding in SoapUI. Ensure you have the correct URL depending on your org. If you just signed up for a developer account, the URL should be . If you are testing this in a Sandbox, then the URL should be . Ideally, the generated Enterprise WSDL will already have the correct URL. login https://login.salesforce.com https://test.salesforce.com For demo testing, we can comment out all other parameters except username and password. We press the green button on the top left of the window to send the request. We receive a response that looks like this: Play The critical pieces that we are looking for in the response are and . In order to call our web service, we need to provide the together with other parameters in our call. We copy down this , as we will need this later. sessionId serverUrl sessionId sessionId Call our SOAP API Let’s call our class and create a Contact in Salesforce. To do this, we need to add our ContactAPI WSDL file, , to our project. We right-click on the project folder and select . ContactAPI contactAPI-wsdl.xml Add WSDL After adding the WSDL, it also appears in the left menu like below. Double-click on to see the request. For this example, we can remove everything from the SOAP envelope header except for the with node. Request 1 SessionHeader sessionId After removing the unwanted nodes, we provide the that we copied from our login call earlier. Then, in the section of the envelope, we provide the details of the contact to be created. sessionId Body We press the green button on the top left. Vóila! We have successfully created a Contact in Salesforce and received its . Play Id Check Salesforce org for new contact Let’s look inside our Salesforce org to see if everything was created correctly. We go to our Salesforce org, click the waffle icon on the left and then type in the search bar to find and select . App Launcher Contact Contacts By default, we land on the Contacts page with the list view. Click the down arrow and select either or list view. Recently Viewed Contacts All Contacts My Contacts : If you are in a Developer org, you will see a bunch of dummy Contacts (and other records) that Salesforce creates for you to test the platform. Note We type the name of our newly created contact in the list search box on the right, and we see our new contact! When we click on the Contact name, we end up on the Details page for that Contact. Call our SOAP API with invalid data Lastly, in order to ensure that our API is working properly, let’s send a bad request to see what we get as a response. We’ll simply send another request to our SOAP web service, but this time replace the in the email address with a instead. . , This time, we receive an (as we programmed in the API). error message The entire error message reads like this: Error:Insert failed. First exception on row 0; first error: INVALID_EMAIL_ADDRESS, Email: invalid email address: sheila@gmail,com: [Email] This shows that our SOAP-based API is working as designed. With this foundation, we can build other SOAP-based APIs to create records for different objects. Unit Testing Besides consuming our SOAP-based API, another way to validate it works properly is through testing. Test Driven Development (TDD) is at the core of Salesforce development. To ensure the stability and reliability of the platform, Salesforce requires your custom code to have a minimum of 75% code coverage via unit tests in order to deploy it to a production environment. Let’s create some unit tests for our web service. @isTest
private class TestContactWebService {
  static testMethod void testInsertNewContact() {
    // Create test data for positive test
    String salutation = 'Mr.';
    String firstName = 'Max';
    String lastName = 'Bond';
    String emailAddress = 'm.bond@mi5.gov.uk';
  
    Test.startTest();
    //Call the method with parameters
    String result = ContactAPI.createContact(firstName, lastName, emailAddress, salutation);
    Test.stopTest();

    Contact newContact = [SELECT FirstName FROM Contact WHERE LastName = 'Bond'];
    System.assertEquals(newContact.FirstName, 'Max', 'Assert Error: Please check the ContactAPI class');
  }

  static testMethod void testInsertNewContactFail() {
    // Create test data for failing test
    String salutation = 'Mr.';
    String firstName = 'Max';
    String lastName = 'Bond';
    // The email address has , instead of .
    String badEmailAddress = 'm.bond@mi5,gov,uk';
    
    Test.startTest();
  
    //Call the method with parameters
    String result = ContactAPI.createContact(firstName, lastName, badEmailAddress, salutation);
   Test.stopTest();

   // This should contain the Error substring that we added to the catch block above.
   System.assert(result.contains('Error:'), 'Fail Assert Error: Please check the ContactAPI class');
  }
} In our unit test, we created two scenarios: a “happy path” that verifies valid inputs result in a newly created Contact record, and a “sad path” where we expect the API to return an error on invalid inputs. Salesforce also provides a . Trailhead on unit testing in Apex Conclusion In this post, we only scratched the surface in terms of the capabilities that Salesforce provides when it comes to SOAP. As we saw, the generated Enterprise WSDL makes a long list of SoapBindings available. In addition, we can create our own custom classes and SOAP-based web services. If you have a (legacy) application that uses SOAP to communicate with other systems, you now have the tools to connect that application to your Salesforce org. With enterprise-level security baked into the platform, you can be sure that your connection is safe and your data is protected. In Part Two of our series, we’ll cover REST APIs, demonstrating how to use Apex to create a custom REST API endpoint for our Salesforce org.

Creating Custom API Endpoints in Salesforce with Apex

Ishan Pandey: Hi Dirk Lueth, welcome to our series “Behind the Startup.” Please tell us about your journey and the story behind ? Upland Dirk Lueth: Once upon a time- I won't tell you when - I did a PhD in Economics about private and state-controlled currencies. When I heard about Bitcoin for the first time in 2010, I immediately dove deeper into it and its underlying technology- Blockchain. Fast forward to 2018, I had a game night with my two co-founders Mani Honigstein and Idan Zuckerman, who are from the gaming industry. We talked about our kids playing Monopoly and thought: Everyone has played this game! What if we take this board game as an inspiration while utilizing blockchain to create a new type of digital platform; a parallel world where people can play, make money and connect with others, all in the context of the real world. And voila, Upland was born ;-). Uplandme, Inc., the company behind Upland, is the fifth company I am building. I also helped over 30 startups as a mentor or advisor on strategy, execution and fundraising. : Vested Interest Disclosure The author is an independent contributor publishing via our . Be it through direct compensation, media partnerships, or networking. The author has a vested interest in the company/ies mentioned in this story. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR brand-as-author program What does metaverse mean to you? What is your vision of the Metaverse? Dirk Lueth: The Metaverse is the next version of the web. It's important to note, however, that looking at it through the glasses of technology is wrong. Technology is just an enabler. The metaverse is an evolution of social and economic digital interactions: It is the medium where people will spend their time over the next few years, gradually eating away at other channels like social media and TV. The metaverse will become our daily companion -like the smartphone today-  but on a different level. It will be where people open their businesses, where they interact with both friends and virtual communities, and where people go for entertainment. Ishan Pandey: What is Upland and how does Upland’s in-game economy work? Dirk Lueth: Upland is the largest metaverse mapped to the real world. It is a virtual property strategy game with true web3 ownership that evolved into a platform. Some players refer to it as “The next Roblox, but for grownups”. Others refer to it as a “layer1 metaverse” where many applications, experiences and other games are using Upland in a way apps use iOS: discoverability in the app store, tools like payment mechanisms, APIs and web3 mechanics such as the creation of virtual collectibles, in Upland, and integration with the Upland economy and its user community. The idea is that Upland works like a (new) nation or, rather, network state where you have the four classical factors of production that make the economy work: Land, Capital, Labor and Entrepreneurship. Entrepreneurs run businesses in Upland, put their Capital to work via “machines” (there are manufacturing and factories in Upland), buy land to operate and labor (via a resource token called “Spark” which need to be staked to build something like a car or a house). In Upland’s in-game economy value is created very similar to the real world. A currency called UPX (which has a fixed exchange rate of $1=UPX 1,000) enables trading and paying for goods and services. Why did you choose the EOS blockchain to build Upland rather than any other blockchains such as ETH, SOL, AVAX? Dirk Lueth: Our goal was always to put accessibility to the masses as the first priority. We’ve had tremendous success with this, as over 60% of our users never owned an NFT before. To make this work, the experience had to be as quick, cheap and convenient as a web2 app.  Today we’re the only blockchain-based metaverse that is available across devices incl. iOS and Android, and allows for fiat in and out, with proprietary technology that allows for a non-custodial wallet while having a “web2 feel” UX/UI via email and password account creation. Transactions are free of any blockchain-based (gas) fees for our users. Also, when we open up new cities, we mint a little more than 70 NFTs per second. Hence, we need something that scales with our growth. The Upland traffic would have broken any other L1 that was available in 2018. Long story short: Upland would not have been possible on other chains, especially when we started out in 2018. But frankly, Technology (blockchain) does not matter as long as it provides transparency, immutability and security.  What matters is building something users actually want and is easy to use. Using the unique blockchain/web3 value proposition to differentiate from Web2 applications allows us, builders, to create killer apps and platforms with added value to users and co-creators. Ishan Pandey: Tell us about the FIFA partnership and how it may impact the adoption of the metaverse economy. Dirk Lueth: A metaverse platform like Upland is a unique opportunity for traditional brands like FIFA to innovate the way they deliver their assets and in their engagement with fan communities around the world. For the FIFA World Cup Qatar 2022, the Upland/FIFA partnership included two main offerings: First, allowing fans to “own their colors”. Uplanders, old and new, can customize their virtual properties, their game pieces and other items with their favorite country’s colors. We’re seeing entire neighborhoods in Upland showing their support - just like you would in the real world! If you happen to visit Upland’s Rio, you can't miss the Brazilian flags. This also ties into the meta-entrepreneur economy. We’re seeing users manufacturing’ awesome fandom decor and selling it in their Upland shops to other users. The second and more prominent aspect of the partnership is the FIFA bundles in Upland. This offering is built on an existing product Upland has with the NFLPA and other soccer clubs - but taken to the next level! With the first drop on Nov 15th selling out, and the second drop today (Nov 23rd) having bundles sell out in 2.5 minutes (!!!), the FIFA Legit collections are a huge success. Fans can purchase bundles with virtual FIFA items, use the items to complete collections and accumulate a fan score. Their fan score ranking will then determine the rare collectibles and prizes they can win, such as video highlights from the 2022 games (imagine you have the one goal of the final) and owning virtual property in Upland - including the Lusail Stadium itself, where the World Cup Finals will be! We also opened up Qatar, where the players can travel to virtually and visit shops. Activities both in the metaverse and outside of it in the real world are happening throughout the matches organized by Upland’s amazing ambassadors. Do you think Web3 developments will suffer because of the falling value of Bitcoin and the bankruptcy of major cryptocurrency players? Dirk Lueth: No. If anything, the current industry fallout emphasizes the need for things to be built right in the industry. But we do have to make clear to the broader public that not everything can be thrown into one basket here. This will take time and we need some good and successful projects to create credibility. Ishan Pandey: Do you believe that regulations are essential for developing the blockchain industry and promoting trust in good-intentioned blockchain entrepreneurs? Dirk Lueth: Yes, it will help to create trust. However, I wish we could coordinate global efforts better so it becomes more equal across the board, avoiding the case that one jurisdiction is very liberal and another one is more strict. Ishan Pandey: According to you, what new trends can we see in the blockchain industry? Dirk Lueth: An alternative to regulation, or a healthy evolution of regulation, often starts with industry standards. That's why initiatives from within the industry are critical to the future health of web3. I am proud to have co-founded the Open Metaverse Alliance (OMA3) ( ) standards organization alongside industry leaders like Animova, The Sandbox and over 1000 member projects. I was honoured to have been elected Chair of OMA3 this month and I’m optimistic about our ability to move things in the right direction, together.   Focusing on the metaverse industry. one crucial aspect is the need to overcome the walled gardens by collaborating with each other. . OMA3 follows the mission to enable interoperability across the metaverse and has created the initial working groups (legal, portaling & mapping, asset transfer). www.oma3.org Don’t forget to like and share the story!

The Metaverse is The Future of Human Interaction

Linking New York and Dublin via a livestream video portal is actually a stroke of genius. The two cities, separated by an ocean, share elements of history and culture, making them seemingly obvious bedfellows in this artistic endeavor. Created by a Lithuanian artist, and backed by the local councils of both Dublin in Ireland and New York City, the project was designed to foster a unique digital connection and bridge the sea. And while it has done that admirably, the headlines have focused mainly on some of the NSFW behavior exhibited by some of the residents of each city. But while the new livestream portal between the two cities presented a mixed bag of very human behavior, it has also shown another way that technology can be used to bridge gaps. A spokesperson for the Dublin City Council said, “The overwhelming majority of interactions are positive. We have seen families and friends unite, dancing moves being shared as well as new friendships being made. There was even a successful marriage proposal.” And despite the fact that the New York/Dublin link has seen some slightly scandalous headlines, this isn’t actually the first portal. The first cross-city portal link was between Lublin in Poland and Vilnius in Lithuania and has widely been seen as a success. In fact, there are other portals planned soon, with another connection in Brazil, according to the Portals organization website. So far, cool idea - barring some very human issues. But could this be the start of a new way of using digital tools for connecting and communicating? Using Screens to Communicate We’ve all grown used to jumping on a Zoom call, sharing Insta updates, dropping some WhatsApp messages, and even, shock horror, maybe actually calling someone. But the livestream portal suggests that we don’t even need to schedule a call anymore - we could create our own little windows into the world. Mark McDermott, CEO of ScreenCloud, has long been espousing the benefits of connected screens. “We’ve grown used to seeing screens everywhere, often just selling us stuff, reminding us not to leave our luggage lying around or sometimes just blank with an input error message. But portals can be a really good way to use these screens to communicate in a more fluid manner.” As he says, there are a number of ways he sees the potential use cases for this type of technology. “Obviously New York and Dublin are two big global cities. But a portal can be used to connect anything from different business locations, college campuses, events. They could even add a connection for twinned cities - a similar approach to the New York/Dublin Livestream portal, but perhaps with less potential for scandal.” An example of this within a business setting could be using a live stream portal setup in the breakrooms of different branch offices. This then means that distant work colleagues could chat casually over the water cooler, even if they’re in different cities… The same opportunities could be used for school or college campuses, research centers, multi-site events, or government offices. And the opportunity to have an ad-hoc chat over a livestream portal screen could mean less wasted time on meetings that could have been emails. Something that many of us are all too familiar with… If this sounds like it could be tricky to build, create and manage, actually it’s more simple than you might think. Especially when you factor in low-cost hardware and affordable software solutions. Use Cases for Two-Way Live Streaming Live streams are obviously nothing new. Webcams have been around since the internet began, and we’ve seen various platforms adopt live streaming to Q&As and webinars, gaming, and sports events. But two-way live streaming could change elements of the workplace, customer service, how we interact with local government, and even our friends and families! While an open channel to discuss with work colleagues in different locations might seem obvious, another opportunity in customer service could be just as important. Especially in an era where AI is being used to replace human interaction. A two-way livestream could connect shoppers to customer support via a location within a store. Or citizens could attend political rallies, government consultations, or parliamentary sessions from provincial offices, without needing to make a trip to parliament. As Mark McDermott from ScreenCloud points out, “The use cases for creating two way live streaming portals are potentially endless. It could also be an incredible tool for cooperation across different departments or hubs. For example if you have your researchers in one location and product team in another, rather than scheduling daily or weekly meetings, a live portal could facilitate real time collaboration.” What Do You Need to Create a Livestream Portal? The technology linking a livestream portal is actually quite simple and readily available using consumer-grade tech. All you need is a screen on each side with a live streaming connection via a tool such as YouTube Live, Twitch, or Zoom. Those looking for a more solid and permanent stream could also use a tool such as Open Broadcaster Software, which is an open-source live streaming solution. It would then be a case of connecting these dual streams to your display, either via a local hard drive or using a cloud-based digital signage software to stream. Of course, the cloud-based option frees up space, as most modern TVs feature integrated casting. As far as screens go, the choice is as broad as you want it to be. Whether it’s a standard smart TV or an interactive video kiosk. If you’re creating a break room portal, for example, screens connecting two offices, an inexpensive LCD TV would be perfect. For a more public installation, for example in a campus foyer, or at a music festival, you’d need a more hardwearing piece of equipment such as an OLED video wall or freestanding digital signage screen. But the portal has opened up a new way of thinking about how screens communicate. Where will they pop up next? Linking New York and Dublin via a livestream video portal is actually a stroke of genius. The two cities, separated by an ocean, share elements of history and culture, making them seemingly obvious bedfellows in this artistic endeavor. livestream video portal livestream video portal Created by a Lithuanian artist, and backed by the local councils of both Dublin in Ireland and New York City, the project was designed to foster a unique digital connection and bridge the sea. And while it has done that admirably, the headlines have focused mainly on some of the NSFW behavior exhibited by some of the residents of each city. But while the new livestream portal between the two cities presented a mixed bag of very human behavior, it has also shown another way that technology can be used to bridge gaps. A spokesperson for the Dublin City Council said, “The overwhelming majority of interactions are positive. We have seen families and friends unite, dancing moves being shared as well as new friendships being made. There was even a successful marriage proposal.” And despite the fact that the New York/Dublin link has seen some slightly scandalous headlines, this isn’t actually the first portal. The first cross-city portal link was between Lublin in Poland and Vilnius in Lithuania and has widely been seen as a success. Vilnius in Lithuania Vilnius in Lithuania In fact, there are other portals planned soon, with another connection in Brazil, according to the Portals organization website. Portals organization Portals organization So far, cool idea - barring some very human issues. But could this be the start of a new way of using digital tools for connecting and communicating? Using Screens to Communicate We’ve all grown used to jumping on a Zoom call, sharing Insta updates, dropping some WhatsApp messages, and even, shock horror, maybe actually calling someone. But the livestream portal suggests that we don’t even need to schedule a call anymore - we could create our own little windows into the world. Mark McDermott, CEO of ScreenCloud , has long been espousing the benefits of connected screens. ScreenCloud ScreenCloud “We’ve grown used to seeing screens everywhere, often just selling us stuff, reminding us not to leave our luggage lying around or sometimes just blank with an input error message. But portals can be a really good way to use these screens to communicate in a more fluid manner.” As he says, there are a number of ways he sees the potential use cases for this type of technology. “Obviously New York and Dublin are two big global cities. But a portal can be used to connect anything from different business locations, college campuses, events. They could even add a connection for twinned cities - a similar approach to the New York/Dublin Livestream portal, but perhaps with less potential for scandal.” An example of this within a business setting could be using a live stream portal setup in the breakrooms of different branch offices. This then means that distant work colleagues could chat casually over the water cooler, even if they’re in different cities… The same opportunities could be used for school or college campuses, research centers, multi-site events, or government offices. And the opportunity to have an ad-hoc chat over a livestream portal screen could mean less wasted time on meetings that could have been emails. Something that many of us are all too familiar with… If this sounds like it could be tricky to build, create and manage, actually it’s more simple than you might think. Especially when you factor in low-cost hardware and affordable software solutions. Use Cases for Two-Way Live Streaming Live streams are obviously nothing new. Webcams have been around since the internet began, and we’ve seen various platforms adopt live streaming to Q&As and webinars, gaming, and sports events. But two-way live streaming could change elements of the workplace, customer service, how we interact with local government, and even our friends and families! While an open channel to discuss with work colleagues in different locations might seem obvious, another opportunity in customer service could be just as important. Especially in an era where AI is being used to replace human interaction. A two-way livestream could connect shoppers to customer support via a location within a store. Or citizens could attend political rallies, government consultations, or parliamentary sessions from provincial offices, without needing to make a trip to parliament. As Mark McDermott from ScreenCloud points out, “The use cases for creating two way live streaming portals are potentially endless. It could also be an incredible tool for cooperation across different departments or hubs. For example if you have your researchers in one location and product team in another, rather than scheduling daily or weekly meetings, a live portal could facilitate real time collaboration.” What Do You Need to Create a Livestream Portal? The technology linking a livestream portal is actually quite simple and readily available using consumer-grade tech. All you need is a screen on each side with a live streaming connection via a tool such as YouTube Live, Twitch, or Zoom. Those looking for a more solid and permanent stream could also use a tool such as Open Broadcaster Software , which is an open-source live streaming solution. Open Broadcaster Software Open Broadcaster Software It would then be a case of connecting these dual streams to your display, either via a local hard drive or using a cloud-based digital signage software to stream. Of course, the cloud-based option frees up space, as most modern TVs feature integrated casting. As far as screens go, the choice is as broad as you want it to be. Whether it’s a standard smart TV or an interactive video kiosk. If you’re creating a break room portal, for example, screens connecting two offices, an inexpensive LCD TV would be perfect. For a more public installation, for example in a campus foyer, or at a music festival, you’d need a more hardwearing piece of equipment such as an OLED video wall or freestanding digital signage screen. But the portal has opened up a new way of thinking about how screens communicate. Where will they pop up next?

Why the New York-Dublin Portal Marks a New Era in Communication 

Welcome to the final step in creating your Collectibles portal! (for part 1, see ) here In this part, we'll focus on building the frontend—the last piece of the puzzle. Here's what we'll achieve: Connect the Flow Wallet. Initialize your account and mint your NFT. Check the NFT ID in your Collection. View the NFT with the NFT ID you have in your Collection. We will be using to build the frontend. Next.js Let's get started! 1. Installation Setting Up Open your project directory. Then, run in the terminal and press . flow-collectible-portal npx create-next-app@latest frontend enter This will provide you with several options. In this tutorial, we will not use , ESLint, or , and we will use the directory and the App router at the time of this article. Typescript TailwindCSS src Now you have a fresh web app ready. This is how your frontend folder looks: 2. Configuration To interact with the we will use the Flow Client Library (FCL) to manage wallet connections, run scripts, and send transactions in our application. It will allow us to write complete Cadence functions and run them as Javascript functions. Flow blockchain To get started, let's install FCL for our app by running the following command: npm install @onflow/fcl --save After installing FCL, we need to configure it. Here's what you need to do: Inside the folder create a new folder named and add a file named . app flow config.js In this file, set up the configuration for the FCL, such as specifying the Access Node and wallet discovery endpoint. This helps you to choose between using a testnet or a local emulator. You will also want to specify the Collectibles contract address we deployed in Part 1. Add the following code to the file: config.js import { config } from "@onflow/fcl";

config({
 "app.detail.title": "Flow Name Service",
 "app.detail.icon": "https://placekitten.com/g/200/200",
 "accessNode.api": "https://rest-testnet.onflow.org",
 "discovery.wallet": "https://fcl-discovery.onflow.org/testnet/authn",
 "0xCollectibles": "ADD YOUR CONTRACT ACCOUNT ADDRESS",
 "0xNonFungibleToken": "0x631e88ae7f1d7c20",
}); Now you're all set up to use the FCL in your app. 3. Authentication To verify a user's identity in an app, you can use several functions: For logging in, call . fcl.logIn() For signing up, call . fcl.signUp() For logging out, call . fcl.unauthenticate() Let’s learn how we can implement these functions in your frontend. fcl First, we will add the following code to our file inside the app directory. This will import some dependencies, set up some initial for parts of our app, and build a basic UI. page.js useState To make sure it looks nice, delete the file inside the app directory and instead make a file called page.css. Then paste the contents of inside of it. Now we can write out our initial page. page.module.css this file "use client";
import React, { useState, useEffect, useRef } from "react";
import * as fcl from "@onflow/fcl";
import "./page.css";
import "./flow/config";

export default function Page() {
  const [currentUser, setCurrentUser] = useState({
    loggedIn: false,
    addr: undefined,
  });

  const urlInputRef = useRef();
  const nameInputRef = useRef();
  const idInputRef = useRef();
  const [isInitialized, setIsInitialized] = useState();
  const [collectiblesList, setCollectiblesList] = useState([]);
  const [loading, setLoading] = useState(false);
  const [ids, setIds] = useState([]);
  const [nft, setNFT] = useState({});

  useEffect(() => fcl.currentUser.subscribe(setCurrentUser), []);

  function handleInputChange(event) {
    const inputValue = event.target.value;

    if (/^\d+$/.test(inputValue)) {
      idInputRef.current = +inputValue;
    } else {
      console.error("Invalid input. Please enter a valid integer.");
    }
  }

  return (
    <div>
      <div className="navbar">
        <h1>Flow Collectibles Portal</h1>
        <span>Address: {currentUser?.addr ?? "NO Address"}</span>
        <button onClick={currentUser.addr ? fcl.unauthenticate : fcl.logIn}>
          {currentUser.addr ? "Log Out" : "Connect Wallet"}
        </button>
      </div>

      {currentUser.loggedIn ? (
        <div className="main">
          <div className="mutate">
            <h1>Mutate Flow Blockchain</h1>
            <form
              onSubmit={(event) => {
                event.preventDefault();
              }}
            >
              <input
                type="text"
                placeholder="enter name of the NFT"
                ref={nameInputRef}
              />
              <input type="text" placeholder="enter a url" ref={urlInputRef} />
              <button type="submit">Mint</button>
            </form>
            <mark>Your Collection will be initialized while minting NFT.</mark>
          </div>
          <div className="query">
            <h1>Query Flow Blockchain</h1>
            <mark>Click below button to check 👇</mark>
            <button>Check Collection</button>
            <p>
              Is your collection initialized: {isInitialized ? "Yes" : "No"}
            </p>
            <button onClick={viewIds}>
              View NFT IDs you hold in your collection
            </button>
            <p>NFT Id: </p>
          </div>
          <div className="view">
            <h1>View Your NFT</h1>
            <input
              type="text"
              placeholder="enter your NFT ID"
              onChange={handleInputChange}
            />
            <button>View NFT</button>
            <div className="nft-card">
              <p>NFT id: </p>
              <p>NFT name: </p>
              <img src="" alt="" />
            </div>
          </div>
        </div>
      ) : (
        <div className="main-2">
          <h1>Connect Wallet to mint NFT!!</h1>
        </div>
      )}
    </div>
  );
} After adding this code, run to make sure everything loads correctly. npm run dev 4. Querying the Flow blockchain Before getting a deep dive into how we can use to query the Flow blockchain, add these Cadence script codes after the function in the file. fcl handleInput page.js const CHECK_COLLECTION = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

pub fun main(address: Address): Bool? {
    		return Collectibles.checkCollection(_addr: address)
}`

const GET_NFT_ID = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

pub fun main(user: Address): [UInt64] {
    	let collectionCap = 
getAccount(user).capabilities.get
<&{Collectibles.CollectionPublic}>(/public/NFTCollection) 
?? panic("This public capability does not exist.")
    	let collectionRef = collectionCap.borrow()!
    	return collectionRef.getIDs()
}
`

const GET_NFT = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

pub fun main(user: Address, id: UInt64): &NonFungibleToken.NFT? {
  		let collectionCap= 
getAccount(user).capabilities.get<&{Collectibles.CollectionPublic}>(/public/NFTCollection) ?? panic("This public capability does not exist.")

  	let collectionRef = collectionCap.borrow()!
return collectionRef.borrowNFT(id: id)
} With our Cadence scripts ready to go, we can now declare some Javascript functions and pass in the Cadence constants into the queries. `fcl` async function checkCollectionInit() {
    const isInit = await fcl.query({
        cadence: CHECK_COLLECTION,
        args: (arg,t) => [arg(currentUser?.addr, t.Address)],
    });
    console.log(isInit);
}

async function viewNFT() {
    console.log(idInputRef.current);
    const nfts = await fcl.query({
        	cadence: GET_NFT,
        	args: (arg,t) => [arg(currentUser?.addr,t.Address), 
arg(idInputRef.current, t.UInt64)]
    });
    setNFT(nfts);
    console.log(nfts);
}

async function viewIds() {
    const ids = await fcl.query({
        cadence: GET_NFT_ID,
        args: (arg,t) => [arg(currentUser?.addr,t.Address)]
    });
    setIds(ids);
    console.log(ids);
} Now let’s take a look at all the functions we’ve written. There are two things to notice: The fcl.query And the line. args: (arg,t) => [arg(addr,t.Address)], Since scripts are similar to functions in Solidity and don't require any gas fees to run, we are essentially just querying the blockchain. So we use to run scripts on Flow. view fcl.query To query something, we need to pass an argument. For that, we use arg, which is a function that takes a string value representing the argument, and , which is an object that contains all the different data types that Cadence has. So we can tell how to encode and decode the argument we are passing. t arg 5. Mutating the Flow blockchain While our previous functions were just “read only,” our next ones will have actions that can mutate the blockchain state and write to it; aka “mint an NFT.” To do this we’ll write another Cadence script as a constant. const MINT_NFT = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

transaction(name:String, image:String){
    let receiverCollectionRef: &{NonFungibleToken.CollectionPublic}
    prepare(signer:AuthAccount){
        // initialise account
        if signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath) == nil {
            let collection <- Collectibles.createEmptyCollection()
            signer.save(<-collection, to: Collectibles.CollectionStoragePath)
            let cap = signer.capabilities.storage.issue<&{Collectibles.CollectionPublic}>(Collectibles.CollectionStoragePath)
            signer.capabilities.publish( cap, at: Collectibles.CollectionPublicPath)
        }
        //takes the receiver collection refrence
        self.receiverCollectionRef = signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath)
      ?? panic("could not borrow Collection reference")
    }
    execute{
        let nft <- Collectibles.mintNFT(name:name, image:image)
        self.receiverCollectionRef.deposit(token: <-nft)
    }
} Now add the below function after the transaction code to the file. page.js async function mint() {
	try{
	  const txnId = await fcl.mutate({
        	cadence: MINT_NFT,
        	args: (arg,t) => [arg(name,t.String), arg(image, t.String)],
	   	payer: fcl.authz,
	  	proposer: fcl.authz,
	  	authorizations: [fcl.authz],
	  	limit:999,});
	} catch(error){
	console.error('Minting failed:' error)
}
    console.log(txnId);
} As for the function, the syntax is the same as . However, we do provide several extra parameters such as the following: fcl.mutate fcl.query payer: fcl.authz,
proposer: fcl.authz,
authorizations: [fcl.authz],
limit: 50, These are Flow-specific things that define which account will be paying for the transaction (payer), broadcasting the transaction (proposer), and the accounts from which we need authorizations. (In case an account has multiple keys attached, it can behave like a multi-sig wallet.) refers to the currently connected account. fcl.authz is like gasLimit in the Ethereum world, which places an upper limit on the maximum amount of computation. If the computation crosses the limit, then the transaction will fail. limit We’ll need to add one more function that will call and handle the function we just made. mintNFT const saveCollectible = async () => {
    if (urlInputRef.current.value.length > 0 && nameInputRef.current.value.length > 0) {
      try {
        setLoading(true);
        const transaction = await mintNFT(nameInputRef.current.value, urlInputRef.current.value);
        console.log('transactionID:', transaction);
        // Handle minting success (if needed)
      } catch (error) {
        console.error('Minting failed:', error);
        // Handle minting failure (if needed)
      } finally {
        setLoading(false);
      }
    } else {
      console.log('Empty input. Try again.');
    }
  }; 6. Final code With our main functions in place, we can now plug them into our UI. However, before we do that, we’ll add some calls to help load the initial state. You can add these right above the already existing call. useEffect useEffect useEffect(() => {
    checkCollectionInit();
    viewNFT();
  }, [currentUser]);

  useEffect(() => {
    if (currentUser.loggedIn) {
      setCollectiblesList(collectiblesList);
      console.log('Setting collectibles...');
    }
  }, [currentUser]); Now back in our section with the UI, we can add our functions to the appropriate parts of the app. return return (
    <div>
      <div className="navbar">
        <h1>Flow Collectibles Portal</h1>
        <span>Address: {currentUser?.addr ?? "NO Address"}</span>
        <button onClick={currentUser.addr ? fcl.unauthenticate : fcl.logIn}>
          {currentUser.addr ? "Log Out" : "Connect Wallet"}
        </button>
      </div>

      {currentUser.loggedIn ? (
        <div className="main">
          <div className="mutate">
            <h1>Mutate Flow Blockchain</h1>
            <form
              onSubmit={(event) => {
                event.preventDefault();
                saveCollectible();
              }}
            >
              <input
                type="text"
                placeholder="enter name of the NFT"
                ref={nameInputRef}
              />
              <input type="text" placeholder="enter a url" ref={urlInputRef} />
              <button type="submit">Mint</button>
            </form>
            <mark>Your Collection will be initialized while minting NFT.</mark>
          </div>
          <div className="query">
            <h1>Query Flow Blockchain</h1>
            <mark>Click below button to check 👇</mark>
            <button onClick={checkCollectionInit}>Check Collection</button>
            <p>
              Is your collection initialized: {isInitialized ? "Yes" : "No"}
            </p>
            <button onClick={viewIds}>
              View NFT IDs you hold in your collection
            </button>
            <p>NFT Id: </p>
            {ids.map((id) => (
              <p key={id}>{id}</p>
            ))}
          </div>
          <div className="view">
            <h1>View Your NFT</h1>
            <input
              type="text"
              placeholder="enter your NFT ID"
              onChange={handleInputChange}
            />
            <button onClick={viewNFT}>View NFT</button>
            <div className="nft-card">
              <p>NFT id: {nft.id}</p>
              <p>NFT name: {nft.name}</p>
              <img src={nft.image} alt={nft.name} />
            </div>
          </div>
        </div>
      ) : (
        <div className="main-2">
          <h1>Connect Wallet to mint NFT!!</h1>
        </div>
      )}
    </div>
  ); Check the final code . here Now with the app complete, let’s walk through how to use it! First, connect your wallet by clicking the “Connect Wallet” button in the top right. Now you can mint an NFT! Enter the name of your NFT and paste in a link to the image you want to use. After you click “mint” it will prompt you to sign a transaction with your wallet. It might take a little while for the transaction to complete. After it completes, you should be able to click the bottom button to view the IDs of your NFTs. If this is your first one, then the ID should be just “1”. Now you can copy the ID of your NFT, paste it into the View section, and click “View NFT”. Conclusion Well done! You've finished part 2 of the Collectibles portal project. In summary, we focused on building the frontend of our Collectibles portal. We did this by: Creating an app with Next.js Connecting the Flow Wallet Creating our very own NFTs for minting Viewing your NFT Have a really great day! Also published here.

How to Build a Digital Collectibles Portal Using Flow and Cadence (Part 2)

কিভাবে ফ্লো এবং ক্যাডেন্স ব্যবহার করে একটি ডিজিটাল সংগ্রহযোগ্য পোর্টাল তৈরি করবেন (পর্ব 2)

So erstellen Sie ein digitales Sammlerportal mit Flow und Cadence (Teil 2)

Cómo crear un portal de coleccionables digitales utilizando flujo y cadencia (Parte 2)

Comment créer un portail d'objets de collection numériques à l'aide de Flow et de Cadence (Partie 2)

प्रवाह और ताल का उपयोग करके डिजिटल संग्रहणीय पोर्टल कैसे बनाएं (भाग 2)

フローとケイデンスを使用してデジタル グッズ ポータルを構築する方法 (パート 2)

Flow와 Cadence를 사용하여 디지털 수집품 포털을 구축하는 방법(2부)

Como construir um portal de colecionáveis digitais usando fluxo e cadência (parte 2)

Как создать портал цифровых предметов коллекционирования, используя поток и ритм (часть 2)

Akış ve Ritim Kullanılarak Dijital Koleksiyon Portalı Nasıl Oluşturulur (Bölüm 2)

Cách xây dựng cổng sưu tầm kỹ thuật số bằng cách sử dụng Flow và Cadence (Phần 2)

如何使用 Flow 和 Cadence 构建数字收藏品门户（第 2 部分）

How to Build a Digital Collectibles Portal Using Flow and Cadence (Part 1)

ফ্লো এবং ক্যাডেন্স ব্যবহার করে কীভাবে একটি ডিজিটাল সংগ্রহযোগ্য পোর্টাল তৈরি করবেন (পর্ব 1)

So erstellen Sie ein digitales Sammlerportal mit Flow und Cadence (Teil 1)

Cómo crear un portal de coleccionables digitales utilizando flujo y cadencia (Parte 1)

Comment créer un portail d'objets de collection numériques à l'aide de Flow et de Cadence (Partie 1)

प्रवाह और ताल का उपयोग करके डिजिटल संग्रहणीय पोर्टल कैसे बनाएं (भाग 1)

フローとケイデンスを使用してデジタル グッズ ポータルを構築する方法 (パート 1)

Flow와 Cadence를 사용하여 디지털 수집품 포털을 구축하는 방법(1부)

Como construir um portal de colecionáveis digitais usando fluxo e cadência (parte 1)

Как создать портал цифровых предметов коллекционирования, используя поток и ритм (часть 1)

Akış ve Ritim Kullanarak Dijital Koleksiyon Portalı Nasıl Oluşturulur (Bölüm 1)

Cách xây dựng cổng sưu tầm kỹ thuật số bằng cách sử dụng Flow và Cadence (Phần 1)

如何使用 Flow 和 Cadence 构建数字收藏品门户（第 1 部分）

app built in Swift. It’s open source and uses the Rust library to privately share TCP or HTTP services from your Mac with your friends over End-to-End Encrypted Ockam Portals. A shared service appears on their ! Portals is a Mac Ockam localhost In this post, we'll dig into how the SwiftUI macOS app interacts with Rust code. If you're curious to try Portals for Mac. You can learn more about it and install is using Homebrew as follows: in this article brew install build-trust/ockam/portals Here's a 2 minute video of the application in action: https://www.youtube.com/watch?v=eWSRNfmURJs&embedable=true Swift <> Rust The Portals functionality was already implemented in the Ockam Rust library. We set out to create a great macOS-native experience. Our first attempt at building the app was using Tauri. This made sense as we wanted to use the Ockam rust library and most people on our team are comfortable building things in Rust. This first version was easy to build and had all the basic functions we wanted. However, the experience of using the app wasn't great. Tauri only gave us minimal control over how the menu was rendered and what happened when a user interacts with the menu. This version of the app felt like it belonged in a 10 year old version of macOS when compared to super easy to use menubar items built into macOS Sonoma. We realized that to have the rich experience we want, we must build the app using SwiftUI. Unfortunately, we couldn't find an off-the-shelf solution, to integrate Swift and Rust, that would give us the best of both worlds; the safety of Rust, and the rich macOS-native experience of SwiftUI. After some more digging we realized we can connect the two using C-89. Rust is compatible with the C calling convention, and Swift is interoperable with Objective-C, which is a superset of C-89. We wrote the Rust data structures that needed to be visible to Swift twice. One version is idiomatic in Rust and easy to use. The other version is C compatible using pointers and memory that is manually allocated with malloc. We also exposed some C-compatible APIs that use raw-pointers in unsafe rust to convert the idiomatic data structures to their C-compatible versions. Finally we automatically generated a C header with the help of the cbindgen library. On the Swift side, we could have called the C APIs directly, but C data structures are not first class citizens in Swift. This makes them harder to use idiomatically within SwiftUI code. Instead, we chose to duplicate the data structures in Swift and convert between C and Swift. This may seem burdensome, but practically, the shared state doesn't change very often. The ability to quickly build components in SwiftUI using constructs like , , etc. is super helpful and worth the tradeoff. if let ... ForEach enum Here's an example of the same structure in its 4 forms: // Rust idiomatic structure
#[derive(Default, Clone, Debug, Eq, PartialEq)]
pub struct LocalService {
    pub name: String,
    pub address: String,
    pub port: u16,
    pub shared_with: Vec<Invitee>,
    pub available: bool,
}

// Rust C-compatible structure
#[repr(C)]
pub struct LocalService {
    pub(super) name: *const c_char,
    pub(super) address: *const c_char,
    pub(super) port: u16,
    pub(super) shared_with: *const *const Invitee,
    pub(super) available: u8,
}

// Generated C header structure
typedef struct C_LocalService {
  const char *name;
  const char *address;
  uint16_t port;
  const struct C_Invitee *const *shared_with;
  uint8_t available;
} C_LocalService;

// Swift idiomatic structure
class LocalService {
    let name: String
    @Published var address: String?
    @Published var port: UInt16
    @Published var sharedWith: [Invitee]
    @Published var available: Bool
} The Swift app is statically linked to our Rust lib at compile time. The data flow is simple: UI interactions are sent from Swift to Rust as actions by calling C APIs, change events are emitted only by Rust, and Swift is notified using callbacks that lead to updates to the UI. Most code in the SwiftUI views looks just like any other SwiftUI application. VStack(alignment: .leading, spacing: 0) {
    Text(service.sourceName).lineLimit(1)

    HStack(spacing: 0) {
        Image(systemName: "circle.fill")
            .font(.system(size: 7))
            .foregroundColor( service.enabled ? (service.available ? .green : .red) : .orange)

        if !service.enabled {
            Text(verbatim: "Not connected")
        } else {
            if service.available {
                Text(verbatim: service.address.unsafelyUnwrapped + ":" + String(service.port))
            } else {
                Text(verbatim: "Connecting")
            }
        }
    }
... If you're curious to learn more, checkout the code for the crate and the Portals . The in the swift folder is also a good place to explore how everything is built and linked together. ockam_app_lib app in Swift Makefile If you're interested in contributing to 's Swift or Rust code, we add new every week and love helping new contributors. Join us on the . Portals for Mac good first issues contributors discord Also appears . here

Encrypted Portals: How We Created a Swift App That Uses Rust

এনক্রিপ্ট করা পোর্টাল: আমরা কীভাবে একটি সুইফ্ট অ্যাপ তৈরি করেছি যা মরিচা ব্যবহার করে

Verschlüsselte Portale: Wie wir eine schnelle App erstellt haben, die Rust verwendet

Portales cifrados: cómo creamos una aplicación Swift que utiliza Rust

Portails cryptés : comment nous avons créé une application Swift qui utilise Rust

एन्क्रिप्टेड पोर्टल: हमने एक स्विफ्ट ऐप कैसे बनाया जो जंग का उपयोग करता है

暗号化されたポータル: Rust を使用する Swift アプリの作成方法

암호화된 포털: Rust를 사용하는 Swift 앱을 만든 방법

Portais criptografados: como criamos um aplicativo Swift que usa Rust

Зашифрованные порталы: как мы создали Swift-приложение, использующее Rust

Şifreli Portallar: Rust Kullanan Swift Uygulamasını Nasıl Oluşturduk

Cổng được mã hóa: Cách chúng tôi tạo một ứng dụng Swift sử dụng Rust

加密门户：我们如何创建使用 Rust 的 Swift 应用程序

Ever wondered about the magic behind those WiFi login pages that greet you at places like Starbucks? You know the drill – you sip your coffee, pull out your laptop or smartphone, connect to the WiFi, and voilà! Suddenly, you're redirected to a page where you need to log in or accept terms before diving into the digital realm. It's a seamless experience we've all grown accustomed to, but have you ever thought about creating one yourself? Well, probably not. But I did! And there’s a good reason why. I live in Ruppin Street, and as a joke, I call my apartment the “Royal Ruppin Relax” as if it were some kind of boutique hotel. I wanted to create my own customized WiFi login portal so that guests at my home would get a surprise when they logged in. That's what we're diving into today: In this tutorial, I’ll show you how to build and customize your own – a digital gateway that not only controls access but also acts as a canvas for your creativity, and a great conversation starter! With a Raspberry Pi and a bit of AI magic, you can transform your mundane WiFi login into an engaging, personalized experience. captive portal https://youtu.be/zbaLWR8GbdM?embedable=true But first, What is a Captive Portal? The term might sound technical, but in essence, it's the official name for those login pages you encounter when connecting to a public WiFi network. Most captive portals are like virtual gatekeepers, ensuring that only authorized users gain access to a WiFi network. But this interface can be a powerful tool, not just for authentication, but also for conveying information and engaging users creatively. Capabilities of a Captive Portal: Captive portals authenticate users by prompting them to enter login credentials or accept terms and conditions. This process ensures that the network is used responsibly and securely. Authentication: One of the features of a captive portal is its customization potential. Businesses often use captive portals to showcase their branding, display advertisements, or provide essential information. Customization: Captive portals enable administrators to control the type of access users have to the internet. For instance, they can restrict certain websites, limit bandwidth, or provide different levels of access based on user roles. So technically, you can configure it such that your devices are prioritized bandwidth-wise on your WiFi network, but that’s up to you 😉 Access Control: Now, let's move forward and create our own captivating captive portal. The creative journey begins! You Will Need: Before we dive into creating your personalized captive portal, let's gather the essentials: The heart of your project, this versatile microcomputer will serve as the central hub for your captive portal setup. Raspberry Pi: You'll need a microSD card (at least 16GB) to store the operating system and other necessary files. MicroSD Card: Ensure you have a compatible power supply for your Raspberry Pi to keep it running smoothly. Power Supply: You'll require an Ethernet cable to establish a wired connection between your Raspberry Pi and your internet router. Ethernet Cable: Why Raspberry Pi? In the landscape of network devices, not all routers are created equal. Many standard routers lack native support for captive portals, making it challenging to implement this feature seamlessly. When faced with this limitation, we turn to as a solution. This credit-card-sized, affordable computer will allow you to run complimentary network-related software, and overcome the constraints of your existing router. Raspberry Pi If you never used your Raspberry Pi before, set it up according to the . Our next step would be installing RaspAP. simple instructions on the official website RaspAP: Simplifying WiFi Management Now that you have your Raspberry Pi ready, it's time to introduce RaspAP. RaspAP is an open-source software that simplifies the process of setting up a WiFi access point on your Raspberry Pi. Think of it as the bridge between your Raspberry Pi and the devices that will connect to your WiFi. To install RaspAP, simply follow the . simple instructions on the official website Why Do We Need RaspAP for a Captive Portal? ‍To create a captive portal, we need a WiFi network that's entirely under our control. RaspAP allows you to do just that: While Raspberry Pi provides the hardware backbone, RaspAP adds the user-friendly interface we’re going for, making it incredibly easy to configure your WiFi network settings. You can customize the network name (SSID), set up passwords, and manage the connection preferences. RaspAP handles the complexities of access points, security protocols, and IP addresses, ensuring that the WiFi network your guests connect to, operates smoothly and securely. Why Is an Ethernet Cable Needed? ‍You might be wondering about the necessity of an Ethernet cable in a wireless setup. When you connect your Raspberry Pi to your router using an Ethernet cable, you establish a stable, wired connection. This wired connection serves as the foundation upon which you'll build your customized WiFi network. Introduction to Nodogsplash Now that you've set up your WiFi access point with RaspAP, it's time to introduce Nodogsplash into the mix. Nodogsplash is a high-performance Captive Portal and the key player in bringing our idea to life. Nodogsplash offers by default a simple splash page that we will customize later. Install and configure Nodogsplash by following the . If you are successful - you will see this page: easy tutorial on RaspAP’s official documentation Customizing the Splash Page Here comes the exciting part! Now we will customize the captive portal page to our liking. Customizing the splash page might seem like a challenging task for two reasons: Nodogsplash has specific rules that the splash page must adhere to, ensuring functionality. Deviating from these rules might result in our captive portal not working, making it crucial to comply with them. Nodogsplash Rules: A CDC (Captive Detection Client) is a component in operating systems or devices that helps in detecting whether a network has a captive portal. When a device connects to a WiFi network, the CDC functionality checks if the network connection is restricted by a captive portal. If it detects a captive portal, the device redirects the user to the portal's login or authentication page. Most of the CDCs don’t allow JS or even s, so we will have to work with HTML and CSS only to make a beautiful captive portal. Manipulating HTML & CSS requires a good understanding of their syntax, making customization challenging for many users. CDCs force us to work with HTML and CSS only, no JS. href To overcome these challenges, we will use some ✨ ✨. AI magic First, we will obtain a stunning boutique hotel picture with Leonardo AI: an innovative tool that generates realistic and visually appealing images from prompts. Here’s how you can use it: Go to the Leonardo AI website and click on “AI Image Generation” Visit Leonardo AI: Using Leonardo AI's intuitive interface, generate an image that resonates with your captive portal's ambiance. You can tweak various settings until you find the perfect image. My prompt was: “A beautiful boutique hotel next to the sea, palms and luxurious atmosphere, beautiful day” Generate Your Image: Once satisfied with the generated image, download it to your computer. This stunning visual will serve as the backdrop for your customized splash page. Download Your Image: Now that we have the image, we can customize the default and . To do that we will use ’s AI agents, that can quickly get us to the point: HTML CSS Fine Open Fine and click “Deploy Agent”. Upload the YAML file of the HTML Agent, found . This agent specializes in HTML and CSS tasks. Deploy an HTML Agent to Your workspace: here Place the default Nodogsplash files in a folder, together with your generated image. Run inside the folder and then add it as a new project to Fine. Create a project: git init The agents work according to a plan specified in a notebook. I wrote a short description for my wanted task and connected the notebook to the project. Create a Notebook and specify the changes you want to make: The agent will start changing the HTML and CSS pages according to the specifications in your notebook. If it isn’t exactly to your liking, make the final changes and that’s it! Run the agent, and make some final tweaks: With Fine’s AI agents, the process of customizing your splash page becomes intuitive and efficient. You don’t need to deal with HTML and CSS, and you don’t need to learn the rules of Nodogsplash. You easily transform a basic login interface into a visually appealing and engaging portal that captivates users, providing a memorable WiFi experience. Test Your Customized Page After Fine generates the code, test your customized splash page. To do that, upload your files to the Raspberry Pi and replace the default splash page files in /etc/Nodogsplash/htdocs/ Ensure that it complies with Nodogsplash rules and provides a seamless user experience. Make any necessary adjustments until you achieve the desired result. Final Words By integrating Raspberry Pi, RaspAP, Nodogsplash, Fine, and Leonardo AI, you've not only created a functional captive portal but also unleashed your creativity without the headache of coding intricacies. This project not only enhances your technical skills but also transforms your WiFi experience at home. Feel free to experiment further and explore the endless possibilities of customization, all thanks to the power of innovative AI technology. Now it's your turn to improve your home WiFi experience! Get creative, get connected, and let your imagination run wild, AI will take care of the rest! Also published here.

How to Create a Custom Captive Portal for Home WiFi with Raspberry Pi and AI 

United States Of America. v. Microsoft Corporation Court Filing by Thomas Penfield Jackson, November 5, 1999 is part of . You can jump to any part in this filing . This is part 53 of 58. HackerNoon’s Legal PDF Series here VI. MICROSOFT’S RESPONSE TO THE THREAT POSED BY SUN’S IMPLEMENTATION OF JAVA For Microsoft, a key to maintaining and reinforcing the applications barrier to entry has been preserving the difficulty of porting applications from Windows to other platforms, and vice versa. In 1996, senior executives at Microsoft became aware that the number of developers writing network-centric applications in the Java programming language had become significant, and that Java was likely to increase in popularity among developers. Microsoft therefore became interested in maximizing the difficulty with which applications written in Java could be ported from Windows to other platforms, and vice versa. A. Creating a Java Implementation for Windows that Undermined Portability and Was Incompatible with Other Implementations Although Sun intended Java technologies eventually to allow developers to write applications that would run on multiple operating systems without any porting, the Java class libraries have never exposed enough APIs to support full-featured applications. Java developers have thus always needed to rely on platform-specific APIs in order to write applications with advanced functionality. Recognizing this, Sun sponsored a process for the creation of a software method that would allow developers writing in Java to rely directly upon APIs exposed by a particular operating system in a way that would nevertheless allow them to port their applications with relative ease to JVMs running on different operating systems. On March 12, 1996, Sun signed an agreement granting Microsoft the right to distribute and make certain modifications to Sun’s Java technologies. Microsoft used this license to create its own Java development tools and its own Windows-compatible Java runtime environment. Because the motivation behind the Sun-sponsored effort ran counter to Microsoft’s interest in preserving the difficulty of porting, Microsoft independently developed methods for enabling “calls” to “native” Windows code that made porting more difficult than the method that Sun was striving to make standard. Microsoft implemented these different methods in its developer tools and in its JVM. Microsoft also discouraged its business allies from aiding Sun’s effort. For example, Gates told Intel’s CEO in June 1996 that he did not want the Intel Architecture Labs cooperating with Sun to develop methods for calling upon multimedia interfaces in Windows. Since they were custom-built for enabling native calls to Windows, and because they were developed by the firm with the most intimate knowledge of Windows, the native methods that Microsoft produced were slightly easier for developers to use than the method that derived from the Sun-sponsored effort, and Java applications using Microsoft’s methods tended to run faster than ones calling upon Windows APIs with Sun’s method. If a developer relied on Microsoft’s methods rather than Sun’s, however, his Java application would be much more difficult to port from the Windows-compatible JVM to JVMs designed to run on different operating systems. Microsoft easily could have implemented Sun’s native method along with its own in its developer tools and its JVM, thereby allowing Java developers to choose between speed and portability; however, it elected instead to implement only the Microsoft methods. The result was that if a Java developer used the Sun method for making native calls, his application would not run on Microsoft’s version of the Windows JVM, and if he used Microsoft’s native methods, his application would not run on any JVM other than Microsoft’s version. Far from being the unintended consequence of an attempt to help Java developers more easily develop highperforming applications, incompatibility was the intended result of Microsoft’s efforts. In fact, Microsoft would subsequently threaten to use the same tactic against Apple’s QuickTime. Microsoft continued to refuse to implement Sun’s native method until November 1998, when a court ordered it to do so. It then took Microsoft only a few weeks to implement Sun’s native method in its developer tools and JVM. Although the Java class libraries have yet to provide enough functionality to support full-featured applications, they have gradually expanded toward that goal. In 1997, Sun added a class library called Remote Method Invocation, or “RMI,” which allowed Java applications written to call upon it to communicate with each other in certain useful ways. Microsoft was not willing to stand by and allow Java developers to rely on new Java class libraries unimpeded. The more that Java developers were able to satisfy their need for functionality by calling upon the Java class libraries, the more portable their applications would become. Microsoft had developed a set of Windows-specific interfaces to provide functionality analogous to the functionality RMI offered; it wanted Java developers to rely on this Windowsspecific technology rather than Sun’s cross-platform interface. Microsoft thus refused to include RMI as a standard component of the Java runtime environment for Windows that it shipped with Internet Explorer 4.0. The license agreement it had signed with Sun the previous year obligated Microsoft to offer RMI, at a minimum, on its developer Web site. Microsoft did so, but with respect to the RMI beta release, it buried the link in an obscure location and neglected to include an entry for it in the site’s index. Referring to RMI and any Java developers who might access Microsoft’s site looking for it, a Microsoft employee wrote to his approving manager, “They’ll have to stumble across it to know it’s there. . . . I’d say it’s pretty buried.” It is unclear whether Microsoft ultimately placed RMI in a more prominent place on its developer Web site. Even if it did, the fact that RMI was not shipped with Microsoft’s Java runtime environment for Windows meant that Java developers could not rely on its being installed on consumers’ PC systems. If developers wanted their Java applications to call upon communications interfaces guaranteed to be present on Windows users’ systems, they had no choice but to rely on the Microsoft-specific interfaces instead of RMI. Microsoft undertook the effort to remove RMI from the rest of the Java class libraries, instead of simply leaving it in place and allowing developers to choose between it and Windows-specific interfaces, for the sole purpose of making it more difficult for Java developers to write easily portable applications. In a further effort intended to increase the incompatibility between Java applications written for its Windows JVM and other Windows JVMs, and to increase the difficulty of porting Java applications from the Windows environment to other platforms, Microsoft designed its Java developer tools to encourage developers to write their Java applications using certain “keywords” and “compiler directives” that could only be executed properly by Microsoft’s version of the Java runtime environment for Windows. Microsoft encouraged developers to use these extensions by shipping its developer tools with the extensions enabled by default and by failing to warn developers that their use would result in applications that might not run properly with any runtime environment other than Microsoft’s and that would be difficult, and perhaps impossible, to port to JVMs running on other platforms. This action comported with the suggestion that Microsoft’s Thomas Reardon made to his colleagues in November 1996: “[W]e should just quietly grow j++ [Microsoft’s developer tools] share and assume that people will take more advantage of our classes without ever realizing they are building win32-only java apps.” Microsoft refused to alter its developer tools until November 1998, when a court ordered it to disable its keywords and compiler directives by default and to warn developers that using Microsoft’s Java extensions would likely cause incompatibilities with non-Microsoft runtime environments. Continue reading . here About We bring you the most important technical and insightful public domain court case filings. HackerNoon Legal PDF Series: This court case Civil Action No. 98-1232 (TPJ) retrieved on 2-13-2023, from is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. justice.gov

Microsoft Was Threatened by Java: That's Why They Made the Decision to Undermine Its Portability

Portals, the leading yield, and protocol aggregator for DeFi, is proud to announce the launch of Milky Way, a major architecture upgrade that enables one-click gasless access to any-to-any swaps across a wide range of . With Milky Way, users and developers can enjoy a seamless, cost-effective, and user-friendly trading and building experience in the DeFi space. ERC20 tokens Milky Way consists of three innovative components: Galaxy Broadcasting System (GBS), Galaxy Hub, and Galaxy Indexer. GBS is a service that handles the on-chain order submission process on behalf of users, abstracting the complexities of gas and gas prices from their wallets. Users can sign an order with the intent to swap any token and let GBS take care of the rest. GBS also ensures fast and reliable execution, minimizing any waiting times. Galaxy Hub is an aggregator that provides optimal routing solutions for any ERC20 token, including LP tokens, vaults, interest-bearing tokens, and more. Users can swap any token pair directly with a single transaction, without the need for intermediate steps. Moreover, Galaxy Hub caps the swapping fees at a maximum of $60, regardless of the swapping amount. Developers can also benefit from Galaxy Hub’s robust routing capabilities, as they no longer need to manage multiple integrations for each platform. Its in-house routing algorithm "Warpdrive," empowers developers to assemble arbitrary routes among tokens, facilitating versatile token swaps. Galaxy Indexer is a service that functions in real-time, continuously consuming blocks to determine crucial data such as asset prices, reserves, volumes, APYs, balances, and more. By utilizing the Galaxy Indexer, DApps can enjoy faster response times and benefit from consolidated endpoints that provide Web3 across the most popular networks. Developers can leverage the Galaxy Indexer’s capabilities to enhance their applications, with coverage of over 35,000 tokens. As the Portals ecosystem expands, the Galaxy Indexer plays a vital role in accommodating a growing number of Satellites. These Satellites represent various platforms and contribute to the increasing complexity and breadth of order types that can be seamlessly handled. Currently, Portals has launched over 40 Satellites across seven networks, including Ethereum, Polygon, Avalanche, BNB Chain, Fantom, Optimism, and Arbitrum. Additionally, in the coming months, Portals will invite the community to launch their own Satellites, further enriching the Portals ecosystem. About Portals Portals is a game-changing DeFi API platform, enabling users and developers to access various DeFi protocols and platforms with ease. With powerful integrations from industry leaders like Yearn Finance, XDEFI, and Mean Finance, Portals sets the stage for unparalleled financial opportunities. Backed by a remarkable $2M seed round, Portals has experienced explosive growth, processing a staggering 8 million API calls in June, a tremendous leap from 1.3 million in February. The recent addition of a visionary Head of Marketing further underscores Portals' unwavering commitment to innovation and progress. For more information: | | | | | Website Documentation Twitter Discord Media Kit Contact Contact Co-Founder Suhail Gangji Portals.fi hello@portals.fi This story was distributed as a release by Chainwire under HackerNoon’s Brand As An Author Program. Learn more about the program here: https://business.hackernoon.com/brand-as-author

Portals Unveils Milky Way: Your Gasless Passage to DeFi Wonderland

Portals presenta Milky Way: su pasaje sin gas al país de las maravillas de DeFi

Portals dévoile Milky Way: votre passage sans gaz vers DeFi Wonderland

पोर्टल्स ने मिल्की वे का अनावरण किया: डेफी वंडरलैंड के लिए आपका गैस रहित मार्ग

ポータルがミルキーウェイを公開: DeFi ワンダーランドへのガスレス通路

Portals revela a Via Láctea: sua passagem sem gás para DeFi Wonderland

Cổng ra mắt Dải ngân hà: Con đường không tốn xăng của bạn đến DeFi Wonderland

Portals 揭开了银河系的面纱：通往 DeFi 仙境的无汽油通道

Portal ...is a platform-agnostic command-line file transfer utility for sending files from any computer to another. The year is 2023 and ChatGPT is taking over the world, yet, sending files to each other is still . incredibly annoying How many times haven't you tried to send a file to a friend through Messenger, WhatsApp, or Discord, just to find out that you cannot send a folder, or a file, or more than a measly in total? .zip 25MB So... you head over to Google Drive, but then you have to fiddle with the link permissions, and if you're uploading a large file, you have to wait for it to be completely uploaded to Google Drive, before your friend can even downloading it. . start Uuuuuugh As a developer, you know sending files isn't hard. So did we, and we got fed up with the current state of things. So we created , a command-line utility to send files quickly and easily. that Portal Installation See the installation options (curl, brew, yay) on GitHub! Leave a ⭐ if you like it ❤️ https://github.com/SpatiumPortae/portal?embedable=true How it works Sending files and folders To send files: portal send <file1> <file2> <folder1> <folder2> ... The application will output a temporary password in the format . 1-inertia-elliptical-celestial The sender will communicate this password to the receiver over some secure channel. Receiving files and folders To receive those files: portal receive 1-intertia-elliptical-celestial The two clients will establish a connection through a relay server. The file transfer will then commence with a direct or relayed connection, depending on what's possible. What it looks like ✨ The sender sends a folder and three files to the receiver . (top) (bottom) In this case, as you can see in the event log, the transfer is made using . That means the files are sent from one client to the other, . direct transfer directly no middlemen involved As it happens, these computers are in the same local network, and recognizes this. portal Demo Features provides: portal End-to-end encryption using PAKE2 Direct transfer of files if possible (e.g. sender and receiver are in the same local network) Fallback to relay server if sender and receiver cannot connect directly Parallel gzip compression of files for faster and more efficient transfers Hosting your own relay (we'd appreciate it if you plan to send a lot of data!) Configurability and shell completions A shiny UI ⭐✨ to gaze your eyes upon while you wait for your files Completions provides extensive TAB completions for the following shells: portal bash zsh fish powershell To see installation instructions for your shell and platform, run: portal completion [bash|zsh|fish|powershell] --help Tip! You probably didn't catch the password Bob was screaming across the room. quite You can use TAB completions to auto-complete passwords on the receiving end. Press TAB when entering parts of your password... portal receive 42-relative-parsec-s... ...and will suggest the possible words portal $ portal receive 42-relative-parsec-s...

42-relative-parsec-supernova  42-relative-parsec-scatter    42-relative-parsec-solar      42-relative-parsec-spin       42-relative-parsec-static     
42-relative-parsec-sigma      42-relative-parsec-solid      42-relative-parsec-star       42-relative-parsec-storm      42-relative-parsec-system . . boom supernova portal receive 42-relative-parsec-supernova Flags Receiver : overwrite existing files without prompts -y/--yes [Y/n] Relay : port to host the relay server on -p/--port and Sender Receiver : address of the relay server ( , , ...) -r/--relay :8080 myrelay.io:1234 : the style of the tui ( | ) -s/--tui-style rich raw , and Sender Receiver Relay : output help messages for any command -h/--help : log debug info to file -v/--verbose Configuration places its configuration file in . portal $HOME/.config/portal/config.yml As evident by the file extension, the config is a simple file with descriptive field names. YAML Default configuration relay: portal.spatiumportae.com
verbose: false
prompt_overwrite_files: true
relay_serve_port: 8080
tui_style: rich Hosting your own relay The binary comes with a built-in relay server.
Spinning up your own relay is as easy as... portal portal serve --port 1337 The server log output is . Super-recommended to run it through ! JSON jq portal serve --port 1337 2>&1 | jq . ... {
  "level": "info",
  "ts": "2023-02-28T02:57:45.310134+01:00",
  "caller": "rendezvous/server.go:77",
  "msg": "serving rendezvous server",
  "version": "v1.2.1",
  "address": ":1337"
} Maintainers Arvid Gotthard Zino Kader DigitalOcean <3 A to our sponsors . The public relay available for everyone to use is sponsored by DigitalOcean. special thanks DigitalOcean Also published . here

Portal: The Easy Way to Transfer Large Files Between Computers 🌌✨

A browser-based Metaverse, is an immersive social space where you can explore, make your own, and gather with others. You don't need to have any coding skills to build your own experience there. And that was the idea on which Portals were built. Portals I am talking with Adam Gomez, co-founder of Portals. We've talked a few times, and I found Adam very passionate and inspirational on how always to keep moving forward. Before founding Portals, he worked with brands like Sega and Sony, and being a gamer gave him a unique opportunity to build something he believes in. Please tell me a little bit about yourself and how you came up, you know, with the idea to do something in the space. I've been interested in games for as long as I can remember. Since I was a kid, at 3 years old, I was already gaming. I was very interested in games and had questions like how the games are made. And that's what led me down the path of coding. And I've continued to follow that interest my whole life. Started learning to program around 7 or 8 years old. Just making simple games. I followed that interest through to about 2007, when I got more introduced to the holistic picture of games and business and how they all fit together. Worked with brands like Sega and Sony through their early digital marketing campaigns. So, how did the Portals start? The first idea that came to mind was basically the foundation for Portals, and that was in early 2020 when we, with other co-founders, started exploring different ideas. We knew that Facebook was working on things in the space, but taking our expertise and software in the browser, we thought that that would be a really interesting concept to do something really high quality. We started building full-time in 2021, and then around the end of 2021, we launched an early version. Started with just a blank space of a virtual world that you could walk around. It's also not just a game that we're creating. We are creating the tools to create experiences. And we make those tools available to other developers too. So, we've taken a different approach there. Even if you don't know how to code, you can go into Portals, drag and drop, create an NPC, and give it dialogue. And we're right at the beginning of our next phase, where many more of those tools are being released. So, for example, if you wanted to have currency and daily items and those types of things in your space, you could do that. There are more tools for creating obstacle courses and escape rooms. We love getting our community feedback and seeing what kind of tools they want. Metaverse Gaming is now like social gaming in a way. Because people tend to come to different metaverses to meet others and join the community. Do you feel Portals already has a strong community, and how is that community helping you? It was awesome that people that have typically never done coding just jumped in and created things like NASA launch center rooms. And this was all just using the limited set of items they would combine in interesting ways and create these super fun experiences. So those are a very core group of users that have spent 20-25 hours a week in Portals and have been building spaces for 6-7 months. Many fashion brands are trying to get into the metaverse space right now. So we see a lot of big brands collaborating with various games in the space. What about Portals? There are a few, we still have ongoing partnerships that aren't public yet. But we're always trying to ensure that the brands we're working with there are really clear awesome use cases and experiences that can be possible through those brands. So through that, you know, we've done things with Atari - we've had some really cool experiences with them, where you'd go back in time to a 1970s Atari office. There were a bunch of puzzles that you needed to solve, and you hacked into the computers and those sorts of things. Another example that we're working on now is Tomorrowland. So when we launch the Tomorrowland experiences, it's gonna be on another level. It's not just gonna be a dance hall. There's gonna be things to do when the event is not going on! And what about the ownership? Do users have ownership, for example, of their avatars or some other in-game assets? So the portal's world map is owned by the players, who are building with us through the portals and NFTs. We started out on Solana. But we've always been looking towards a multi-chain future. So that's our next phase. We've started partnering with some great names in the Ethereum space too. In terms of ownership, it's gonna be exciting to see how that evolves. Avatars are a really big thing, and we support avatars on Portals, and we've seen those active and strong communities have 3D avatars. They absolutely love Portals because they can bring in their 3D avatars here. Those who own the Portals NFTs can be visible on the portals world map. Such brands like Atari have a lot of prominence on the map. It'll be really interesting to see how that evolves over time with more adoption and Web3 assets across different games, being able to bring them from one place to another. We also have our own avatars that will be interoperable, and you'll be able to take them to any other games or metaverse platforms. So what is next for Portals? What are you working on right now? It really has been about this awesome onboarding experience. We call it "a story mode," where you're essentially guided through an experience. Then, it teaches you how to build. You can start collecting items and unlocking new ones. It opens up the whole world and guides players to other places to explore. You visit the Atari City Center and collect some Atari items and those sorts of things. But we're super excited about the next phase there as well. Things like a Survivor Island experience where teams can play against each other. And you know, you can vote out the losing team member of the island. So that's where we combine these multiplayer social experiences. Who's behind the team who's working with you? Not including the community of builders that is quite large at this point, the core team is 20 to 30 people now. We've decided not to raise tons of money and just expand like crazy before it's too early. We've seen throughout history that some of the best products are made by smaller and more passionate teams. So, for the last question: What is the future of the Metaverse and Web3? In our case, we've kind of taken, I guess you can say, a conservative approach when it comes to like fully diving into Web3 and creating tokens and decentralizing everything from the very beginning because we want to make sure that we have a focused team that can create a great product as a foundation. I think only some people will want to build and sell. People might just be coming into the Metaverse wishing for a good experience. So not requiring a wallet, not requiring having to purchase tokens, and allowing anybody and everybody to come in is very important. So we're always looking at what are the things that long term we think are gonna make sense for Web3. A smaller percentage of your user base that's going to be really, really interested in that. Adam, thank you so much for your time, and congrats on Making such a great product!

Meet the Metaverse: Adam From Portals

Why You Need A Portal If You Want to Serve Developers When you’re teaching a kid to drive, you don’t hand them a car key, the operation manual for the car and then leave them to figure it out. Of course you could, but not everyone would get the car moving, and there might be some easily avoided accidents along the way. But this is exactly how many companies teach people to use their APIs: they hand over a stack of documentation, an API key and call it a day. Of course, those tools are important; without them, your users are stuck at ‘Go’. But these tools alone don’t deliver any experience to users. It’s basic. It’s lackluster. It’s experience, but probably not developer experience you want to give your users. It’s certainly not a delightful experience or memorable enough to tell others about. And that lackluster experience has a material impact on the adoption and usage of your API. an THE If developer experience has been underinvested in, a common set of issues begin to pop up: The average time gap between user signup and first successful request is longer than one day. Your team spends hours every week troubleshooting client integrations. The average number of API calls & endpoints made by users isn’t expanding over time. Resulting in: Decreased API adoption and usage A higher cost to support for each user. A reduced LTV for each user. To address these issues, you need to improve your API’s DevEx vastly. which makes your API: The key to a great user experience is providing your users with an API DevEx Portal, : there is zero friction to begin sending API requests. Accessible : users can get immediate feedback on their API usage and self-service troubleshoot issues when they do occur. Understandable : It is trivially easy for users to discover and test out new use cases for your API that naturally expand their usage. Usable But what tooling gets you to this point? Let’s walk through each of the above criteria and discuss the specific tools that can help you give your API users the DevEx they deserve. What Tooling Does Your API Portal Need Accessible Making the API accessible means making it as easy as possible for users to make that first API call. 99% of companies are still stuck somewhere in this first stage. : Key Capabilities - There has been a pervasive view that documentation equals great DevEx. We think that documentation is only the first step: it’s critical, but on its own it will still leave your API users wanting. Documentation should be comprehensive, easy to navigate / search, and have code snippets / examples embedded. Ideally, docs should enable users to try the API without any additional tooling or configuration. API docs should also differentiate between API reference (a full list of all endpoints, parameters, response codes, etc.) and usage guides (tutorials that take users step-by-step through how they can use the API to accomplish key tasks). API Documentation - If you want to offer developers a more personalized experience, auth is the prerequisite. You need to know who someone is before you can issue them an API key, and start giving them tools to help them understand and track their usage. Login should of course be managed by a single shared identity service e.g. auth0 or other system of record – you don’t want to build a separate user management system for your application and your API for example. Auth Login - Nobody wants to have to fill in a typeform and wait for customer support to review before they can get started with an API. If there’s no way for a developer to create keys on their own, most will never convert into users of your product. By the time someone has reviewed their access request, they will have moved on to a new priority, or found an alternative solution. If the API interfaces with sensitive data, and a review process is a legal requirement for production credentials, then enable users to provision sandbox keys without review (more on Sandboxes below). API Key Management Understandable Even companies where APIs are the primary surface area often struggle to make the investment required to advance their developer portal to being understandable. : Key Capabilities - When debugging, there’s no substitute for being able to step through things one at a time. A request viewer makes it possible for your users to view the full list of requests they’ve sent to your API – without creating additional work for your team to pull logs, send screenshots via email or Slack, or jump on a Zoom call. Without a self-service request viewer, broken integrations create poor API experience and leads to churned clients. A request viewer should provide users the ability to filter by time, response code, endpoint and more, and ideally allow users to edit and replay the request for quick debugging. API Request Viewer - A request viewer is only useful to developers if they know there’s an issue to investigate. That is why it’s important to surface key usage metrics in real time – so that users know the overall health of their integration. Usage metrics should place an emphasis on error reporting and significant changes in usage so that your users can take corrective action to any errors or unintended changes. API Usage Metrics - Developers need a place to check if APIs are experiencing downtime. Nothing is more frustrating than having to email a company, “is your API working?” An API status page brings transparency, and transparency is important for building trust with your users. API Status Page Usable Usability tooling is focused on making it easy to test out new API use cases and also making those new use cases easy to find. Usability tooling shines as APIs become larger. Early on an API will serve a single use case, and documentation will focus on supporting that use case. As the API’s surface area grows, documentation becomes denser, and isolating relevant instructions becomes challenging. Usability tooling will help insulate users against this by providing structure for the documentation, and making it easier to test out new use cases. : Key Capabilities - You need to meet your developers where they already are. Providing client SDKs makes it easier for developers to get started with your API by grounding them in the familiarity of their favorite language and significantly reducing the amount of boilerplate they need to write. This is especially true if your SDKs can handle auth, pagination, and retries and others. They are, therefore, great at helping maximize your audience while minimizing support costs. But it’s not enough to have SDKs, it’s critical that the SDKs are developer-friendly, meaning that they are language idiomatic and human readable. Unfortunately, creating client SDKs is prohibitively expensive for most API teams since they need to be created and updated by hand. While open-source generators exist, the SDKs they output are often buggy and not ergonomic. Client SDKs - We think of runbooks as live usage guides. They take users step-by-step through the process of using your API to accomplish specific tasks, but also show relevant, live API requests in real time. This helps to focus developers on the key use cases required to complete API integrations. Your customers can use them to grow their usage of your API. As an API builder, runbooks also help you understand the maturity of your customer base: you can begin to understand your API usage as a customer funnel, and start to measure where and why users drop out of the funnel. API Runbooks - Probably nothing helps more with adoption than giving developers an easy way to play with your API. A sandbox can allow prospective users to use your APIs without needing to sign up for an account. Developers are more likely to trust an API if they’ve seen it working before needing to hand over their information. And a sandbox can give existing users a way to learn by doing and without any risk of corrupting production workflows. This enables users to expand their use cases for your API easily. API Sandbox How to get to Best-In-Class: Build or Buy? The list above is presented as a rough roadmap. To improve your DevEx, just build each of the tools listed above in order, and you can progress from having no tooling, to having a great Developer Portal. But as any PM or engineer will tell you, knowing what to build is only the beginning. Finding the resources required to build is the real battle. Great DevEx is extremely important for a successful API, but building all of the above is a huge commitment of resources, requires significant ongoing maintenance, and likely isn’t a core competency for your organization. As a result, investing in Developer Experience is the project slated for next quarter. For almost every company therefore, investing in a best-of-breed solution makes more sense. With an API DevEx Portal from a company like Speakeasy, your customers get a world-class API Developer Experience in days instead of quarters, your product roadmap has negligible impact, and your eng teams don’t need to reinvent the wheel. Furthermore, our product is designed with maximum flexibility in mind, giving you the best of both worlds. Every tool in our API DevEx Portal is a React component, and can be customized, branded and extended as you need. Similarly, our platform can be self-hosted or run in our Speakeasy Cloud depending on your requirements. Final Thoughts For a long time, companies have been able to get by with substandard developer experiences, but that is beginning to change. Developer Experience is now getting the attention it deserves, and we are rapidly reaching an inflection point. What has been previously considered great DevEx is becoming table stakes for developer products. We know that DevEx isn’t ignored because companies don’t see the value. Rather, it’s the result of painful prioritization decisions. That’s why Speakeasy exists. We don’t want anyone to have ever to make that tradeoff. With Speakeasy you can get a best-in-class, composable developer portal up and running in a matter of minutes. If you want to learn more, or join our beta program chat with us in Slack! Originally published . here

API DevEx Portals: A Definitive Guide 

When we create components in React, normally they exist within the component tree. This is mostly fine, but sometimes we want certain parts of a component to appear , or somewhere entirely different. outside the component tree This is a common requirement when we create modal popup windows, which need to be above all other components. We may create these within a component, but ultimately we'll want them above everything else, and having them nested within many components can cause issues as their will fall below whatever they are within: z-index To solve this problem, we can the modal out of its own component and into another part of our template using . teleport createPortal This allows us to put our component anywhere we desire else, like the base of the HTML tree, inside the tag, or inside another element. body Even though the element exists within the component tree, gives us the power to put it anywhere we like. createPortal Using React Portals To show you how portals work, consider we have the following basic React code inside our file. Here, we want the modal to appear on top of everything else. As such, we've created a called . This is ultimately where we want all of our modals to go into: App.js div #modal-container import logo from './logo.svg';
import './App.css';
import { useState } from 'react'
import Modal from './components/Modal.js';

function App() {
    const [isModalOpen, setIsModalOpen] = useState(false);
    return (
        <div className="App">
            <header className="App-header">
                <img src={logo} className="App-logo" alt="logo" />
                <p>
                Edit <code>src/App.js</code> and save to reload.
                </p>

                <button onClick={() => setIsModalOpen(!isModalOpen)}>
                    Click to Open Modal
                </button>
                <Modal modalState={isModalOpen} onClickEvent={() => setIsModalOpen(!isModalOpen)}>
                    This is Modal Content!
                </Modal>
            </header>
            <div id="modal-container"></div>
        </div>
    );
}

export default App; Inside , I've imported a component called . This is our Modal component, which will pop up any time the user clicks the button. App.js Modal Whenever is set to true using , the modal should appear. Otherwise, it'll disappear. isModalOpen setIsModalOpen() I've also got a bit of CSS to ensure our modals do indeed appear on top of everything else: #modal-container {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    z-index: 9999;
    height: 100%;
    pointer-events: none;
}

.modal {
    position: absolute;
    top: 200px;
    background: white;
    border-radius: 4px;
    left: calc(50% - 100px);
    width: 200px;
} Creating Our {ortal Creating a portal is pretty easy - there is one function, . Instead of returning some DOM in React, we return the instead. createPortal() Portal accepts two arguments - the DOM element we want to return - in this case, the modal - and the DOM element we want to teleport our DOM element to. createPortal() So, our second argument is , since we want to put all of our modals into : document.getElementById('modal-container') #modal-container import { createPortal } from 'react-dom';

function Modal({modalState, onClickEvent}) {

    if(!modalState) return null;

    return (
        createPortal(
            <div className="modal">
                <button onClick={onClickEvent}>Close Modal</button>
                <div className="modal-content">Modal Content goes here</div>
            </div>, 
            document.getElementById('modal-container')
        )
    );
};

export default Modal; Although we teleported our DOM element to , it still behaves like a normal React child. Since the Portal still exists in the React tree, features like the context the element is in still work the same. modal-container It should also be noted that although we have and in the same file, the place you teleport your DOM element to can be in your React code. modal-container Modal anywhere So, you could teleport it to a completely different subcomponent, element, or parent anywhere in the DOM. It's pretty powerful and useful - so use it wisely. Let's look back at our HTML: App.js 
    <button onClick={() => setIsModalOpen(!isModalOpen)}>
        Click to Open Modal
    </button>
    <Modal modalState={isModalOpen} onClickEvent={() => setIsModalOpen(!isModalOpen)}>
        This is Modal Content!
    </Modal>
</header>
<div id="modal-container"></div> Now, even though sits in our header, it will appear in whenever we open the modal using the button: Modal #modal-container Conclusion Portals are a pretty powerful tool in React. They are a useful way to solve the main issue with component-based systems - transporting certain elements above all the rest. As such, I hope you've enjoyed this guide to React portals. If you are learning React, I'd suggest mastering Javascript first - which you can do with my full . Javascript Handbook Have a great day.

How to Transport Your Components Anywhere With React Portals

Cómo transportar sus componentes a cualquier lugar con React Portals

Comment transporter vos composants n'importe où avec les portails React

रिएक्ट पोर्टल के साथ कहीं भी अपने घटकों को कैसे परिवहन करें

React ポータルを使用してコンポーネントをどこにでも転送する方法

Como transportar seus componentes para qualquer lugar com React Portals

Làm thế nào để vận chuyển các thành phần của bạn đến bất kỳ đâu với cổng React

如何使用 React Portal 将组件传输到任何地方

What Is Happening? Coinbase-backed announced its Reg D equity offering through the to raise capital from 1,900 investors across the globe for its equity offering. Portal is a cross-chain Layer-2 DEX network that is being built on Bitcoin and is raising capital on Republic, a private equity-based investment platform that lets anyone invest in vetted startups from different industries such as AI, Blockchain and Crypto. Portal Republic platform The Layer 2 and Layer 3 technology of Portal allows the development of censorship-resistant communications, media and cross-chain swaps with a single click, all on Bitcoin. The sale to the public started on Monday, July 18. : Vested Interest Disclosure The author is an independent contributor publishing via our . Be it through direct compensation, media partnerships, or networking. The author has a vested interest in the company/ies mentioned in this story. HackerNoon has reviewed the story for quality, but the claims hereon belong to the author. This article is not investment, taxation or legal advice. #DYOR brand-as-author program What is the Portal Platform? Portal Defi is a decentralized financial platform that combines the most advantageous aspects of Bitcoin and Layer 2. With Portal, decentralized finance becomes uncensorable, peer-to-peer and little dependent on trust. Similar to Bitcoin's fundamental features. It makes trading unstoppable with anonymous, zero-knowledge swaps through the first trust-minimized cross-chain DEX. It removes the necessity for minting wrapped currencies such as wBTC and wETH and dangerous staking via intermediaries. What is a Reg D Equity offering under US laws? Regulation D of the Securities Act offers a variety of exemptions from the registration requirements, enabling some entities to offer and sell their securities without registering with the SEC. to the SEC, offerings of securities Rule 504 or 506 of Regulation D or Section 4(a)(5) of the Securities Act of 1933 are exempt from the registration requirements of the Securities Act of 1933. However, the issuing company must submit the required notice to the SEC. According under to the SEC, businesses that meet the criteria of Regulation D are exempt from the need to disclose their offering of securities with the SEC. When their securities have been sold for the first time, they should digitally submit a "Form D" with the SEC. The names, addresses, and contact information of the company's promoters, executive officers, and directors are all that are required to be included in Form D, along with a few data regarding the offering. According How is Republic Disrupting the Private Equity Market? Republic is the private investing platform utilizing web3 technology such as blockchain and security tokens for investors seeking high growth potential. Republic opportunities with strong growth potential in the startup, gaming, real estate and cryptocurrency industries. The platform provides an avenue for accredited and non-accredited investors to meet entrepreneurs and access private market projects with great development potential. identifies private investment It is important for investors to note that Reg D offerings are generally only open to accredited investors. However, technically, up to 35 non-accredited investors may participate. They simply need to show financial expertise and business acumen. Further, to Republic, their vetting process only permits just 3 percent of startups to fundraise on their platform. according The general public will be able to participate in an ambitious project creating DeFi on top of the Bitcoin blockchain via the stock offering. The equity offering being conducted by Portal is a safer and secure avenue for investors, considering that the offering is being held in the US. It is critical for investors and companies alike to comply with SEC regulations and crypto companies such as Portal taking this initiative may start a new era of fundraising for blockchain startups. Final Thoughts on Portals Equity Offering on Republic Portal’s equity offering on Republic reflects that the trend for blockchain startups and the blockchain industry is a net positive. Companies are raising capital and building protocols and technology applications for the future, which may disrupt existing businesses and their business models.  Further, it looks like equity offering under Reg D in the US is gaining traction again as a mode of raising finance for blockchain startups. Don’t forget to share the story! Image credits: and Jeremy Bezanger. Austin Distel

Portal is Raising Capital on Republic Through Reg D Equity Offering

Last year, I became very interested in getting involved in the development of core Ethereum protocols. So I decided to participate in the Ethereum Core Developer Apprenticeship Program as a start. Cohort-one I was specifically interested in EVM and Stateless Ethereum at the time and finally worked on implementing a prototype of predicting access list for clients. predict-al Portal Network Applying a methodology like a , the prototype, when tested with about one million historical transactions on Ethereum Mainnet, achieves an average improvement of 2.448x on reducing the number of iterations to retrieve the state from the network. taint checking Background initially proposed the idea of predicting the access list in the Ethereum Core Developer Apprenticeship Program . Piper Cohort-one It's crucial for blockchain decentralization that a regular user is able to run a node on resource-constrained devices. The is an in-progress Ethereum research effort towards this goal. Portal Network In the Portal Network, Ethereum state data, including account balances, nonce values, contract codes, and storage values, should be evenly distributed across the nodes. A portal client that participates in the network typically exposes the standard JSON-RPC API, even though it only stores a small part of the whole state data of the network. A portal client will encounter a new serious problem that does not exist in the current full nodes when it executes the API eth_call or eth_estimateGas because it typically does not have necessary state data and has to retrieve them on demand from the network. If we keep the same implementation of EVM as the current popular execution layer clients in portal clients, the EVM engine will need to be paused to retrieve data from the network each time state data is accessed. This will dramatically slow down the EVM execution when the number of states to be accessed grows too large. A potential solution for this problem is to build an engine that could predict a significant amount of the accounts and storage slots to be accessed before a transaction is performed. Then those predicted state data could be fetched concurrently instead of one by one. If this contract calls for another contract's method or the location of a storage slot to be accessed depending on another storage slot's value, we can't predict all-state in one round. Once the predicted state data in the last round has been retrieved, the tool should be run again with those values to find more states to be accessed until there are no more new states. We could run one process to perform the actual EVM execution and spawn another process at the same time to run this tool, predicting the transaction's access list and retrieving their values from the network in the background. Another potential benefit of this solution is that the current popular implementation of EVM could be re-used by portal clients without much modification. Prototype Implementation When the tool receives a transaction payload, the sender and receiver can be easily extracted directly from the payload. Once the two accounts' state data such as balances, nonces, and bytecodes have been fetched from remote nodes, the next step is to find out more state accesses if the receiver is a contract or zero. We can perform some simple static analysis with the retrieved contract bytecode to find out some state accesses with constant locations. For example: PUSH1 0x00
SLOAD But for some more complicated data structures, such as dynamic arrays and maps, the storage locations are usually dynamically computed with the provided parameters. For example: // bytecode snippet of loading the value from a map by the provided key
      //
      //  mapping(address => uint256) public balances; 
      //  function balanceOf(address _owner) public view returns (uint balance){
      //    return balances[_owner];
      //  }
      //
     
      CALLDATALOAD
        ...           // A lot of codes many jumpings are omitted here
      JUMPDEST          
      PUSH 0            
      DUP1          
      PUSH 0            
      DUP4          
      PUSH FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF         
      AND           
      PUSH FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF         
      AND           
      DUP2          
      MSTORE            
      PUSH 20           
      ADD           
      SWAP1             
      DUP2          
      MSTORE            
      PUSH 20           
      ADD           
      PUSH 0            
      KECCAK256             
      SLOAD Even though we can find out these access patterns by static analysis, obviously we still need a virtual machine to execute those bytecodes to compute the exact storage locations. Taint Checking A customized EVM has been implemented in this prototype to resolve the above issue. We can run a transaction with this EVM and record potential state accesses. s were introduced into this EVM to dynamically identify which state accesses should be recorded. At the same time, it also removed the need to pause EVM execution when state access happens. Taint check Considering the following example described in the , there are four possible different state accesses in this function. YUL language function foo() -> result {
    let x := 0
    let y := 1
    let m := sload(x)
    let n := sload(y)
    let z := 2
    
    let k := gt(m, n)
    switch k
    case 0 {
        result := sload(n)
    }
    default {
        result := sload(z)
    }
} The graph below shows the flow of taint in the first round of running this tool. The return value of any state access will be marked as tainted unless the value has already been retrieved from the network and saved into local storage. Red nodes and arrows in this graph indicate taint, and dotted lines represent indirect influence. Obviously, is tainted by in this round. The customized EVM only marks it as tainted and then continues to handle the following opcodes. At the end of the execution of this function, there are four to be found in total, but the location of the third is a tainted value whose exact value is unknown at the moment. So only the other three untainted locations , and will be recorded after this round. m sload sloads n sload x y z Once these three states have been retrieved, we can run this tool again. A new flow of taint is shown as the following: In this second round, the variables and are not marked as tainted anymore because their values have been retrieved and can be loaded from the local storage. Consequently, the switch condition is also untainted. m n k If " " is executed by the EVM, only will be recorded in this round. It will be merged with the other three state accesses found in the previous round as the final access list. case 0 n If " " isn't executed, there will be no more new state access. The state access list found in the previous round will then be the final access list. case 0 Branch Traversal The conditional branch is a very important case that needs to be handled carefully in this prototype. It's very common in a contract that there are many conditional branches based on the values of other storage slots. We need to traverse both branches and look up the possible state accesses either way if the slot value has not been retrieved from the network yet. The YUL code in the above section also shows an example of this case. The switch condition depends on the values of storage slots and . We need to follow both branches when is tainted. Obviously, both branches would be traversed in the first round, but only one of them would be followed in the second round in this example. k x y k In order to follow both branches, the EVM context needs to be backed up before the first branch is executed and restored before the second branch is executed. Branch paths will grow exponentially once there are nested branches with tainted conditions. So the depth of nested branches must be limited to avoid path explosion. If a conditional branch with a tainted value were repeatedly hit in the execution, it's possible that there's an infinite loop here. We also need to set a threshold to break it up. Testing with Real Transactions To test the prototype with real transactions on Mainnet, this tool needs to fetch data from an archived Geth node via the JSON-RPC API to simulate retrieving state data from other nodes in the Portal Network. First, I ran the prototype with some historical blocks on mainnet to get predicted access lists. Then the tool was run with the same blocks to generate exact access lists for the validation of those predicted results. At last, another tool was executed to validate the outputs of predict-al and trace-helper and import them into a PostgreSQL database for further investigation. predict-al trace-helper predict-analyze The testing was performed with 5000 historical blocks on the Ethereum mainnet from block 13580500 to 13585500 (exclusive). The total number of transactions is 1043603. Among the 671567 contract calls and creation transactions among them is what we are interested in. The remaining other simple Ether transfer transactions will be ignored in the analysis because they don't interact with any contracts. Finally, we got the following findings with this data. Effectiveness of State Retrieval To measure the effectiveness of state retrieval of this prototype, we define a factor as follows: factor = iterations-of-worst-case / (rounds-of-prediction + (total-pieces-of-state - number-of-correctly-predicted-accesses)) Suppose that there's a historical transaction that involves touching 20 different pieces of state. The worst case is that the tool has to fetch them one piece at a time sequentially. This means 20 iterations of network lookups for this transaction. Suppose the tool has predicted 18 possible state accesses in 4 rounds, we found out that only 15 of them are accurately accessed in this historical transaction after comparing them with the exact access-list produced by the trace-helper tool. The remaining 5 pieces of state that haven't been predicted will still have to be fetched sequentially. factor = 20 / (4 + (20 - 15)) According to the above expression, the factor of effectiveness should be 2.22. It means that this tool could fetch 2.22 pieces of state concurrently in each lookup on average, reducing the total iterations of lookups from 20 to 9. The tool achieved an average effectiveness factor of 2.448x in this testing. To better understand the average factor, we further show the effectiveness distribution across all 671567 contract calls and create transactions in the above figures: Most of them are showing the effectiveness of between 1.0x and 4.0x Only 0.62% of them are less than 1.0x. With further investigation of these transactions, we found that 80.4% of them are failed historical transactions. They reverted during the execution and only accessed small parts of the possible access lists that were predicted by the tool. This should explain why the tool got less effective for most of them. Prediction Correctness As mentioned in the above section, all the predicted access lists need to be validated with the exact access lists produced by tracing the same transactions. The tool predicts the access list based on the state of the previous block, while the generates the data based on both the state of the previous block and the position of this transaction in this block. predict-al trace-helper This will usually cause some small differences between the datasets produced by these two tools. The ratio of correctness means how much percentage of the exact access list has been predicted correctly. ratio = 15 / 20 For the example transaction mentioned in the above section, the ratio should be 75%, according to the above expression. The tool achieves an average ratio of 91.45% correctness. It means that on average, 91.5% of the exact state accesses have been predicted correctly in this testing. The figure above shows the distribution of the ratio of correctness. It reports that about 76.37% of them have been predicted with 100% correctness. Frequently Accessed State In the testing, we observed that some contracts and their methods are called far more frequently than others. The table below shows the top 10 contract methods that have been called with high frequency. Rank Contract Method Count Percent 1 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0xa9059cbb 120025 5.35% 2 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0x70a08231 117522 5.23% 3 0xdac17f958d2ee523a2206206994597c13d831ec7 0xa9059cbb 105986 4.72% 4 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0xd0e30db0 61787 2.75% 5 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 0xa9059cbb 45667 2.03% 6 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0x2e1a7d4d 43122 1.92% 7 0xc18360217d8f7ab5e7c516566761ea12ce7f9d72 0x76122903 33253 1.48% 8 0xe592427a0aece92de3edee1f18e0157c05861564 0xfa461e33 32037 1.43% 9 0x7a250d5630b4cf539739df2c5dacb4c659f2488d 0x7ff36ab5 24397 1.09% 10 0xe592427a0aece92de3edee1f18e0157c05861564 0x414bf389 23785 1.06% There are a total of 89647 unique contract methods that have been called 2245330 times in all of the 671567 transactions. The top 10 contract methods have been called 607581 times in total, and occupy 27.06% of all method calls. The potential to improve the efficiency of this tool is based on this kind of access pattern. For example, we could save bytecodes of some most frequently accessed contracts in local storage as a cache, then we could save one round to fetch those contracts' bytecodes sometimes. Conclusion With the approach of taint checking, the prototype of this solution can predict about 91.45% of the access lists correctly and achieves an average of 2.448x effectiveness of state retrieval. We also observed that some contract methods are called more frequently than others. This kind of access pattern can be utilized to improve this prototype. It's very important to reduce the time spent on state data retrieval when a portal client executes the API eth_call or eth_estimateGas. Predicting the access list is a potential solution to resolve this problem, and as a result, speed up the EVM execution for portal clients. Also published . here

How Predicting Access Lists Can Be a Potential Way to Speed Up Evm for Portal Clients

Tech giants like and use Angular to gain business growth and deliver seamless end-user experience. In recent years, Angular has gradually become the top-most preference of several big brands, such as , , and . Uber Microsoft PayPal Upwork Deutsche Bank Paypal - a renowned online payment system uses AngularJS for its checkout/transaction portals. Similarly, Delta airlines are deploying Angular to display real-time airfare data. Overall, several diverse enterprises using Angular have exponentially increased business ROI and brand reputation over the last decade. But several businesses find it challenging to hire Angular JS developers that can meet their project requirements. This blog post outlines the top sites where you can find expert Angular.js developers and team members. Your Team In India Your team in India is a renowned Indian IT outsourcing company that enables you to hire developers, engineers, programmers, and coders remotely. Bring down the software development cost up to 60% with dedicated offshore developers. Highlights Your offshore development partner 97% client retention rate. 100% confidentiality on NDA. Quick & easy onboarding process. Toptal Toptal is a renowned developer provider in the United States. It has thousands of engineers, developers, coders, programmers, and consultants with experience in several industries. As a result, it's easy to search for an AngularJS developer that has working experience in your domain. One of the USPs of Toptal is that it offers you a no-risk trial when you agree on a developer. During that time, you can work with the dev to decide whether or not they are a good fit for your project. If you're looking for an AngularJS developer to partner with, Toptal is ideal for you. Highlights Hire in under 48 hours Highest levels of integrity, professionalism, and communication. Every applicant is rigorously tested and vetted. Angular Jobs It's a community of dedicated software Angular developers, engineers, coders, and programmers. The majority of them have rich years of experience with AngularJS. You can post your jobs to hire AngularJS on the job board for full-time, part-time, and contractual work. Plus, you can set up additional parameters, such as location-specific developers, app developers, and more. Highlights Reliable platform Dedicated team Transparency Remoteok.io RemoteOK is a remote job board that offers talented prospects across various developer skillsets, including Angular, iOS, full-stack, and tons of other specialties. RemoteOK is a prominent platform to hire Angular developers, given its large pool of remote talent. While it offers paid job posting option, you will get several useful added features like featured ads and branded employer pages. Highlights Reliable team of developers Quick response Timely delivery Hired Hired is a platform that offers an opportunity to hire app developers and software developers possessing expertise in the AngularJs framework. On Hired, you can use their channel to find custom matches to work within your development process. You can create a company profile, search for candidates using their search algorithm, and schedule interviews with candidates to ensure that they can meet your project requirements. Highlights Ensure project delivery Excellent remote players Lower time-to-market AngularJobs.io AngularJobs.io is a new addition to dedicated Angular job boards. It has a large pool of dedicated AngularJS developers. You can look for remote, contract, and full-time positions on the site. It's suggested to provide your cost to hire Angular JS developers in the original job post since that will get you better proposals. Moreover, you can add additional skill requirements to your search. Highlights App Design & Development AngularJS Cross-Platform Development Quick response Quick turnaround time Upwork Upwork has one of the largest marketplaces to hire AngularJS developers. You can hire software developers by bidding on the platform for a series of complex NodeJS projects. If you like the idea of bidding, interviewing, and collaborating with freelancers on a fixed or hourly basis, Upwork's marketplace will probably meet your needs. Highlights Hire developers at Fixed prices and hourly rates An extensive team of developers and testers Rich experience Devteam.space DevTeam has an extensive vetting process, and its comprehensive services are more than just technical skills. For example, if you want an Angular.js developer who also possesses project management skills, DevTeam will find someone with those skills. Furthermore, DevTeam has a very diverse pool of developers. So no matter your project requirements or how complex your project is, you will find a software developer for your exact needs. Highlights A diverse pool of developers Quick response Timely delivery Fullstack Labs FullStack Lab is a platform where you can hire Angular.js developers, architects, programmers, and engineers. On this platform, renowned brands like Siemens and Uber go for their development needs. You can find feedback and experience from some of the recognized high-profile companies on their site. The developers also sign an NDA to prevent a breach of project-related information security and privacy. Highlights Security and Privacy NDA sign Custom solutions CodeMentor X CodeMentorX is a platform for hiring developers, engineers, and consultants for your software development. The site has over 4,230 Node.js developers who have gone through a strict vetting process. You can find and hire freelancers to meet your software app development needs. Plus, they will provide you with potential candidates and help you hire your Angular.js developer within 72 hours or less. Highlights Hire dedicated developers Rich experience Support and maintenance What's Next? Now that you know the top platforms to hire AngularJS developers, it's time to take action and save a lot of resources in the long run. Frequently Asked Questions (FAQs) Where can you find top AngularJS developers for my project? You can find dedicated AngularJS developers on the following sites: Your Team In India DevTeam Angular Jobs AngularJobs.io Review the post above for the complete list of hiring platforms. How can you hire an AngularJS developer in 2022? Check out comprehensive tips to hire : AngularJS developers in 2022 Gain a deep understanding of your project, including the scope, size, and potential for future developments. Consult the experts to hire developers with rich experience. Consider core skills such as knowledge of programming languages and frameworks, UI/UX design experience, etc. Discuss the project details with the shortlisted team of developers and plan of action. How much would it cost to hire an AngularJS developer? An AngularJS programmer would cost you around $50-150 approximately. However, the overall cost depends on the project's size, complexity, and developmental timeline. What skills should you look for in an AngularJS developer while hiring? Any AngularJS developer you hire should possess the below-mentioned skills at a minimum: Rich experience in several major programming languages and front-end frameworks that includes HTML, C++, Angular (JavaScript), and various others. Experience with front-end app framework development.

Top 10 Portals to Hire AngularJs Developers

The Metaverse tends to ebb and flow between absurdity and hype. It's getting a lot of attention since it's being billed as the next step in the internet's spatial development, allowing us to explore experiences alongside information. It also seems a bit outlandish to some people because, when read aloud, it sounds like Asimov-Esque fiction that veers into fantastical territory. We have ideas about how the will emerge, but there is a huge amount of white noise and rubbish beyond these insights. Metaverse The same noise causes consternation. Since there is no common definition, experts might interpret its hazy contours to match their story. The s predict that "the Metaverse will be sociable." social specialist "The Metaverse will be fantastic for training," in the training field. say specialists All of this may be true, like parallel lines on a highway, but none of these scenarios capture the full magnitude and promise of the next spatial computing platform. What the dialogue lacks is a feeling of solid reality on which to base all of our talks. A solid foundation on which we may argue and investigate, standing tall on the terra firma of common reason. In this case, augmented reality (AR) has the potential to thrive as a Metaverse doorway. But first, let's take a step back. When we talk about this, we tend to lump together the different threads of augmented reality (AR), virtual reality (VR), and smart glasses – and treat them all as one. The ambiguity is reasonable; the large canopy of immersive technologies may embrace a wide range of technology advances, but the broad strokes can be misleading for a true Metaverse conversation. When deciding which of these functions as a gateway, we must ask ourselves one question: which is the most convenient to use? Which of them has the frictionless experience of a smartphone, where the boundaries are so low that anybody can walk over them and into a new world without difficulty? AR is the most suited doorway for consuming material out of the three. Anyone may dive into a portable gadget, scan a code, and be instantly engulfed in a personalized experience. One good example is augmented reality platform OVER (formerly OVR) who have recently launched a new NFT collection. worked with Swedish soccer player to deliver 11 NFTs to the OVER platform, inspired by Ibrahimovic's book " ." OVER Zlatan Ibrahimovic Adrenaline. My Untold Stories The 11 NFTs inspired by parts of Zlatan Ibrahimovic's latest best-seller were made accessible on the metaverse. The artworks will be auctioned off on the marketplace, an online digital art auction platform for non-fungible tokens, between March 22nd and April 19th. overthereality.ai Nifty Gateway The simplicity of use is significantly superior to a VR headset, which may take hours to set up, and smart glasses, which will almost certainly be too pricey for general appeal in the future. The Metaverse's entrance should be broad and friendly, enabling many people to enter the new world. Take, for example, in the wildly succesfull . By presenting interactive AR tasks that interest the user, the game kept players engaed and emmersed in the mobile app. the use of augmented reality Pokemon Go Take the same ideas and apply them to a Metaverse. Companies may take control of the virtual area and further engage their pupils in their world by competing or exploring other aspects of the brand's narrative. AR already offers advantages over other forms of technology in terms of dwell time and engagement; with an immersive Metaverse, these advantages become much more significant. Views will be significantly less important than key KPIs like dwell time and engagement. While hypothetical, augmented reality (AR) is a great contender for serving as a Metaverse gateway since it outperforms other technologies in terms of engagement and accessibility. A free and open Metaverse must be constructed on concepts that enable everyone to use it without incurring expensive hardware expenses. AR is the most promising future contender of all the current immersive technologies. But for now, let's work together to create it and see how far we can go.

Why Augmented Reality Could Be the Portal to the Metaverse

DEX Portal is bringing multichain cross-exchange without wrapped tokens DEX Portal is bringing multichain cross-exchange to the DeFi ecosystem. According to Vitalik Buterin, most cross-chain bridges are particularly susceptible in 51% of assaults. It is neither trustless nor decentralized to lock and wrap money onto other chains. Portal, a real cross-chain DEX based on Bitcoin (BTC/USD), thinks wrapped tokens and third-party asset custody will have no place in the future. Only during trade execution should users’ assets be locked. Bridges are difficult to understand and secure. Wrapping assets on other chains effectively inherits an IOU’s assurances. It becomes challenging to safeguard user cash when hundreds of millions or billions of dollars are held by poorly constructed systems and custodians with unproven security methods. Security is critical because the “code is law” nature allows hackers and attackers to get away with almost anything. We prefer simplicity and trusting established, long-lasting contract types and transaction models, like Bitcoin’s, over various experimental approaches to real-world money. Portal is creating DeFi on top of the Bitcoin blockchain to provide various DeFi services while keeping anonymity inside open and transparent marketplaces. Coinbase Ventures and other big-name investors fund the startup. Thanks to the Bitcoin network’s strong security, its Layer-2 and Layer-3 technologies enable zero-knowledge cross-chain swaps and censorship-resistant communications. Portal removes the need for wrapped currencies (wBTC and wETH) or dangerous staking with intermediaries. The Rise of Cross-chain trading solutions The three main components of the decentralized finance (DeFi) market are permissionless trading, permissionless marketplace development, and permissionless market-making. The final two are essential for the DeFi derivatives market to grow successfully and boost liquidity provider profits. Permissionless trading has been the most widely adopted so far, owing to the development of on-chain Web 3.0 wallets and their adoption by almost all DeFi protocols. Automated market makers, on the other hand, provide decentralized marketplace creation and market-making as relatively new capabilities (AMMs). However, AMMs have not resulted in similar decentralized marketplace building and growth in the spot and derivative markets. A market for any asset paired with any other asset may be constructed on the spot, and if no such pair exists, a swap can still be completed by routing via an intermediary asset like USDC. Consequently, the market for tokens is customizable and straightforward to implement. In the derivatives market, however, this is more challenging. As a consequence, a wide range of techniques has been created. One option is to use a virtual liquidity machine to build an immortal on-chain liquidity product that can provide both long and short liquidity. This strategy removes liquidity provider problems by eliminating the liquidity provider (LP) from the equation. The risk is now shifted from the LP to the protocol. The key to permissionless derivatives is that LPs can use a liquidity provision strategy. The derivatives liquidity problem would be solved if a protocol could answer the product-market fit challenge. Perpetual products include inverse contracts, which are a kind of perpetual product. Instead of depending on stablecoins, they enable dealers to trade their tokens. LPs, on the other hand, may provide liquidity. Inverse perpetual may be used to grow the DeFi derivative market. They allow for the development of external contracts in any asset, from stablecoins to crypto-assets, LP tokens to index assets, as long as a price oracle is available. For example, protocols DAOs have built a strong use case for LP tokens in DeFi 2.0. Accepting all crypto assets in derivatives is on a similar upward trend. Catch all the breaking news, and Don’t forget to like the story! Image credits: . Luca Bravo

Stories, News & Mentions about PORTALIQ

Portaliq’s Stories on HackerNoon