Akounto helps you simplify your finances so you can focus on growth. Perfect for Small &amp; Medium businesses. Start your FREE Lifetime Plan Today!

Best Accounting Software for Small Businesses - Akounto

Akounto | 360 followers on LinkedIn. Redefining Accounting | Akounto, redefining the financial ecosystem for Small businesses, Freelancers, and Startups. Akounto&#x27;s suite of products &amp; platform provides &quot;All-in-one&quot; financial solutions that put you in complete control of your finances.

Akounto | LinkedIn

AKOUNTO SERVICES PRIVATE LIMITED - company information, business information and directors/partners details

AKOUNTO SERVICES PRIVATE LIMITED - Company, directors and contact ...

Check Akounto Services Private Limited registration details online. Get financial highlights, company network &amp; industry details. Sign Up now for more reports &amp; updates

AKOUNTO SERVICES PRIVATE LIMITED - Company Profile, Directors, ...

Get insights about Akounto Company Profile, reviews, salaries, interviews questions, offices, locations, headquarters, employee benefits and more.

Akounto Company Profile & Overview | AmbitionBox

Akounto Services Private Limited Find ✓ Company Information ✓ Trademarks ✓ Directors ✓ Documents ✓ Charges ✓ Prosecution &amp; more

Akounto Services Private Limited - Company Information, Trademarks ...

Akounto is a dedicated team of experts who works day and night to simplify finances and focus on growing business.

Akounto - Crunchbase Company Profile & Funding

With Akounto handling your finances for as low as $199/month, you can concentrate on growing your business confidently. ... Anyone can write a Trustpilot review. People who write reviews have ownership to edit or delete them at any time, and they’ll be displayed as long as an account is active. Companies ...

Bookkeeping Services in USA - Akounto Books Reviews | Read Customer ...

To Know More About AKOUNTO SERVICES PRIVATE LIMITED Details And Company Profile And Other Details, Please Visit Www.Companydetails.In

AKOUNTO SERVICES PRIVATE LIMITED Details | Company Profile | ...

Akounto is an accessible, cloud-based accounting software. It helps business owners to manage their cash flow, financial transactions, bookkeeping, ...

Akounto 2023 Pricing, Features, Reviews & Alternatives | GetApp

Streamline your business accounting processes with one cloud-based solution. Discover the best deal for akounto on AppSumo today.

akounto - Simplify your accounting processes | AppSumo

Streamline the finances of your SaaS business with Akounto, an easy-to-use accounting software for non-accountants. Sign up for FREE and get started.

Best Accounting Software for SaaS Companies - Akounto

Compare the best business software and services based on user ratings and social data. Reviews for CRM, ERP, CAD, PDM, HR, and Marketing software.

Akounto Reviews 2023: Details, Pricing, & Features

Akounto is a cloud based accounting software that provides financial services and software for small businesses

Akounto

Have you ever added something to your online shopping cart only to abandon it before checking out? If so, you’re far from alone. Research shows the average shopping cart abandonment rate is . In other words, for every 100 people who add items to their cart, only 30 will actually go through with the purchase. Sounds high, right? 69.57% There are many different reasons for a high cart abandonment rate. Whatever the core cause, the impact is the same; it will have a major impact on your profits and long-term growth. If you’re losing a lot of sales, it’s important to take steps to reduce it. Today, I’ll share five smart strategies for reducing shopping cart abandonment. We will cover everything from improving your checkout process to building customer trust. By following these strategies, I firmly believe you can get your abandonment rate below the average and dramatically boost sales. Let’s dive in! Minimize Unexpected Costs Unexpected costs can be a major turnoff for potential customers and can often lead to people abandoning their carts before they hit the checkout button. In fact, surveys show that unexpected fees are the customers leave without paying. You can avoid this problem by being transparent about all costs upfront and offering clear and concise pricing information. number one reason Here are a few actionable tips for keeping costs crystal clear throughout the sales process: Show all costs upfront, including shipping, handling, and other fees.Introduce a free shipping option for users who spend over a specific amountOffer people discounts and promotions. This can help to offset any unexpected costs and .Have an all-star customer service team available to answer questions about costs and ease your customers’ minds. boost satisfaction When someone adds your product to their cart, they are far more likely to click the purchase button if the total doesn’t change drastically between “add to cart” and “checkout.” Use a Mobile Responsive Design If your website is not mobile-friendly, you are missing out on a massive opportunity to connect with your customers and reduce cart abandonment. Globally, people own mobile devices, and many use their smartphones to shop and research brands. 5.45 billion are a way to build your site that automatically adjusts to the size of the screen it is being viewed on, which means that your website will look great and be accessible on desktop and mobile. Mobile responsive designs Not using a mobile responsive design can cause an increase in cart abandonment. When people use their phones to shop, they expect to easily add items to their cart and complete the checkout process. If your website doesn’t perform well on mobile, these people will be more likely to abandon their cart and shop elsewhere. You can see where you stand by using . This tool will scan your website and let you know whether it is mobile-friendly. If it is not, the tool will give you suggestions on how to make it more mobile-friendly. Google’s Mobile-Friendly Test Making your website mobile-friendly is a simple way to improve your website’s usability and increase your sales. If you are not already using a mobile responsive design, now is the perfect time to set it up. Streamline Your Checkout Page Next, let’s talk about your checkout page. It doesn’t matter how great a visitor’s experience is until now. If the final part of the process is clunky, complicated, or takes too long, you can expect most people to leave before they pay. Optimizing your checkout page is one of the best things you can do to reduce cart abandonment. Here are a few actionable strategies for streamlining your checkout page. Make sure your checkout process is easy to follow and understand. Add a progress bar if necessary.Use clear and concise language.Avoid asking for too much information. Keep your short and sweet.Offer multiple payment options.Provide a secure checkout experience.Offer a discount for completing the checkout process quickly. payment forms Turn First-Time Visitors Into Email Subscribers I highly recommend turning first-time visitors into email subscribers if you want to keep your abandonment rate low. This way, you can stay in touch and remind them about the items they left in their carts. There are a few different ways you can make this happen. The most common way is to offer a discount on their first purchase if they subscribe to your email list. Another name for this type of promotion is a lead magnet. You should also ask users to enroll when they create an account and add an item to their cart. Once you have their email addresses, you can send cart abandonment emails. Cart abandonment emails are designed to remind users about the items they left in their carts and offer them a discount or incentive to complete their purchase. We found that sending a cart abandonment email one hour after they leave can help you recover of lost sales. 6% These emails are an excellent way to recover lost sales and increase revenue. But for it to work, you have to convince them to join your email list. Show Social Proof is a powerful psychological phenomenon. Essentially, It refers to the idea that people are more likely to do something if they see others doing it. You can use social proof to reduce cart abandonment by showing potential customers that others are happy with your brand and products. Social proof There are three core ways to use social proof to reduce cart abandonment. They are: User reviewsTrust badgesLive sales notifications Reviews show potential customers what other people have thought of your products and can help to build trust. For context on how much reviews mean to customers, consider this; of shoppers say user reviews directly affect their daily shopping habits. 90% Trust badges are small seals of approval often appearing on payment forms and at the bottom of your site. They indicate to readers that your website is secure and trustworthy. We found that by simply attaching a reliable badge to our forms, we could increase conversions by as much as . 42% Finally, you can also use live sales notifications to show potential customers that other people are currently buying your products. This is the equivalent of seeing a line of people outside a new restaurant or at the release of a new iPhone. People think, “If others are buying now, I should too!” All these methods can help reduce cart abandonment by making potential customers feel more confident in your business and your products. If you’re looking to reduce cart abandonment, social proof is a powerful tool you can use to your advantage. Final Thoughts As you can see, there are plenty of ways to keep people from leaving before they place an order. The strategies outlined today will help you keep first-time visitors and existing subscribers engaged, which is bound to improve sales and spark long-term growth.

5 Smart Strategies for Reducing Shopping Cart Abandonment

In this guide, we will go through the process of creating a script in for making cross-chain swaps with Stargate. Also, we will cover the LazyerZero protocol that is used under the hood of Stargate, how to interact with smart contracts, and passing CLI arguments. Our final goal is to make a cross-chain swap from Fantom to Polygon through Stargate by calling the script. Typescript So, let’s dive in! About Stargate and LayerZero is an organization powered by the community, that is working towards building the initial fully composable native asset bridge, as well as the initial dApp constructed on LayerZero. The primary objective of Stargate is to enable the transfer of cross-chain liquidity as a seamless process that requires a single transaction. As stated in their , current cross-chain bridge solutions mint you their own wrapped version of an asset on the destination chain, not the native asset itself. Stargate whitepaper Stargate on the other hand is providing liquidity pools on different chains so you receive the native token on the destination chain, not some wrapped version. Hence, you won’t be in a situation when there is not enough liquidity on DEX to unwrap your token and don’t have to pay fees for unwrap as well. Actually, Stargate is the first dApp built on LayerZero. is an omnichain interoperability protocol that provides easy cross-chain messaging. This messaging mechanism is used for cross-chain swaps on Stargate. LayerZero Setting up Project Dependencies dontenv - for environmental variables handling ethers - for interaction with smart contracts minimist - This tiny tool will make it easier for us to handle CLI arguments, so we could set e.g. fromNetwork, toNetwork, token and amount straight from terminal when running a script. typechain - generating types for smart contracts ts-node - run Typescript Env Variables We will just store private key and slippage here. Slippage is set to 5, that means 0.5% actually. It is used for calculating minAmountOut for swap. DON'T FORGET to set private key before running script ABIs ABI (Application Binary Interface) - is an interface of smart contract that includes data about contract's events, functions etc. It allows us to interact with the smart contract. We'd need Router ABI and a basic ERC20 so we could send any token available through Stargate with our script! Here are the links to the Router’s official smart contract and to the Gist with ERC20 ABI, so you can grab ABIs from here: StargateRouter - https://etherscan.io/address/0x8731d54E9D02c286767d56ac03e8037C07e01e98#code ERC20 - https://gist.github.com/nfedosenko/ed8f2f4c229fd24422e35a8c6b6c8815 Coding script Generate types Create utility providers.ts Here we will define utility functions for initializing providers for different blockchains, store router addresses and any arbitrary data needed. I’ve put data in such kind of mappings for easy fetching needed data related to blockchain. It would be useful in the main script All of the addresses could be found here: https://stargateprotocol.gitbook.io/stargate/developers/contract-addresses/mainnet Create utility tokens.ts This utility will store data about tokens(address, decimals) on different blockchains so we could use it for swaps. Currently, it only has USDC but can be extended easily. We have to remember that Stargate supports specific list of tokens and paths available for cross chain swaps. Full list of paths could be found . here Main script Here is our final cross chain swap script! Firstly, we initialize so we would use environmental variables. dotenv Then we parse CLI arguments passed with the script: we would be able to specify , , , . fromNetwork toNetwork token amount We calculate based on the slippage percentage specified in . amountOutMin .env Next step is initializing providers for different chains and fetch fee data for source chain so we can set correctly. gasPrice Checking if wallet has enough balance and allowance for the Router contract. Script will throw error if it’s not enough balance and will approve needed amount if allowance is lower than needed. Now we are going to quote LayerZero fee data. We need to pass it when calling a cross chain swap. Finally, we are calling on the router contract, passing chainId, liquidity poolIds on each chain respectively swap Wait for confirmation and write URL to the transaction on the source chain to the terminal Testing Here are the logs from my terminal after running the script, works like a charm! It took about 5 mins for money to come from Fantom to Polygon. Also, you can see that I'm passing fromNetwork, toNetwork, token and amount as CLI args Conclusion All in all, we've set up a perfect infrastructure for running cross-chain swaps in Typescript with a brand new blockchain technology stack! In the next guide, I’m going to improve the script to store info about possible cross-chain paths and run swaps consequently from chain to chain. P.S. Full Code Github Repo Link

Making Cross Chain Swaps with Stargate in Typescript

Many IT companies have adopted the practice of on-duty duty. An engineer is on duty, and his duty lasts for a shift. Usually, the shift lasts one day or one week. There are cases of increasing or decreasing this period, but this is rare. The engineer's duties in this role vary from company to company, but there are some common points. You have to answer the questions that come into the team. It is necessary to monitor the performance of the services for which the team is responsible. To deal with fires and incidents. Escalate the incident further if you can't figure it out. We'll talk about how to be well-prepared for duty as an engineer in this article. Definition of perfect duty engineer If incidents or fires occur on your shift in a combat environment, it does not mean you are a terrible engineer. To be a good duty engineer, if problems occur, you need to solve them as quickly and cost-effectively as possible. A well-trained engineer understands where they can handle himself and where it's worth escalating the situation further. They should know when and whom to call for help. They must not allow, if possible, the same problems to be repeated. Experience It is helpful to take advantage of the experience of yourself and the team to better prepare for duty. It's a good idea to start by looking at what documentation already exists for handling incidents. Is there documentation at the company or team level? It is essential to know where it is and be familiar with it. If it doesn't exist, could you try to initiate the process of creating one? Then it is worth checking what incidents have already happened and how they are recorded in the knowledge store. Are there any postmortems and are there tasks to be fixed? Do you know if these tasks are being done? If tasks for fixing the situation are created, but not implemented, this is a reason to discuss this in a meeting with your manager. Do you know if the duties of the engineer on duty are recorded? What are they responsible for, and what is not? If there is no such documentation or understanding, it would be helpful for the whole team to have one. Tools The toolkit for the on-duty engineer is specific and somewhat different from the developer's everyday toolkit. The main tasks that arise during firefighting are those that cannot be solved by existing queries Let's look at these tools in more detail: The primary technical tool for the dutyman, with the help of which you can solve many problems, is bash. Often in fire mode, you need to perform some operations with the product database. The skill of working with the database via the terminal - psql for PostgreSQL or mongosh for MongoDB will help. These tools are given as examples, you can search for your own database. For many databases, there are visual tools to work with, but the terminal is available everywhere, requires minimal internet, and is very flexible. For fire mode, it can be very useful. https://www.postgresguide.com/utilities/psql/ https://www.mongodb.com/docs/mongodb-shell/ curl is a tool that will allow you to make a considerable number of queries, and when combined with knowledge of bash, you will become almost omnipotent. It will be very useful if you have a set of ready-made scripts at hand at the time of the fire. They should be as simple and straightforward as possible. Yes, you can probably write them very quickly, but when you have limited time, it's great to have a ready-made set that allows you to think only about the crash and not how to implement the same tying. The scripts below are just a representation of the potential structure of such scripts. Of course, your code should be tested before the incident and be as simple and straightforward as possible. It is helpful to have the following scripts: A script that generates a file from the data provided. These can be obtained from other commands or by making an independent request. An example of such a script in Python is shown below. import csv

def modify(filename):
 tmpFile = "tmp.csv"
 # Reading file with data and creation of output file
 with open(filename, "r") as file, open(tmpFile, "w") as outFile:
 # Create reader for initial file
 reader = csv.reader(file, delimiter=',')
 # Create writer for output file
 writer = csv.writer(outFile, delimiter=',')
 # Read header line
 header = next(reader)
 # Write header line
 writer.writerow(header)
 # Process initial file line by line
 for row in reader:
 colValues = []
 # Process each column of each line
 for col in row:
 # Let for example transform all columns to lowercase
 colValues.append(col.lower())
 # Write modified line to final file
 writer.writerow(colValues)

filename = 'sample_data.csv'
modify(filename) A script that will call the required endpoints with the specified parallelism. It doesn't have to be anything complicated. Below is an example of a simple JavaScript code that will generate a sh file with the specified parallelism that can help you with that. Yes, we don't have result handling here, but it's not always needed, and you can modify your toolkit with a result handling version if required. For example, we have a file that reads and writes the whole data, but you can create stream scripts for huge files. const fs = require('fs');

const initialFilePath = 'sample_data.csv';
const outputFilePath = 'sample_script.sh';

const amountOfParallelRequests = 5; // Remember about the throughput and the bandwidth of your services
const delimiterForCSV = ',';

// Read the initial file and split it by lines
// You could transform it to an object if it's relevant to your situation
let initialFile = fs.readFileSync(initialFilePath).toString().split('\n');

// Prepare boilerplate for sh script
let outputString = '#!/bin/bash\n\n';

// Write data with parallel execution
// Skip header for CSV
// The code for parallel requests was received from https://serverfault.com/questions/456490/execute-curl-requests-in-parallel-in-bash
// and you could implement your version instead
for (let i = 1; i < initialFile.length; i++){
 let line = initialFile[i];

 if (!line) {
 continue;
 }

 let processedLine = line.split(delimiterForCSV); // We don't implement processing of errors here
 // Let's suggest that the necessary for request value lies in second column
 let desiredValue = processedLine[1];

 if (desiredValue === undefined) {
 console.error('We have a trouble ' + line);
 }

 outputString += `curl -s -o foo http://example.com/file${desiredValue} && echo "done with ${desiredValue}" &\n`;

 if (i % amountOfParallelRequests === 0 || i === initialFile.length - 1) {
 outputString += '\nwait\n\n';
 }
}

fs.writeFileSync(outputFilePath, outputString);

// Indicate the success
console.log('Success'); A script that gets something from a database or service and puts the converted result back or maybe calls another endpoint. I suggest implementing it yourself, not forgetting about authorization and appropriate usage scenarios. Knowledge In addition to tools and experience, a certain amount of knowledge is helpful when you go on duty. I would like to know about the logs and metrics of your services. Where do they go and how do you get there? Would you happen to know how to use these tools? When you get a call at night from an on-call service that tells you that your service is down - it's in your best interest to quickly discover what's going wrong. To do that, you need to know precisely where your metrics and logs store and what to look at first. How to postpone alerts? After analyzing the incident, it often comes out that the current accident may be waiting for the morning, so it is good to understand how to postpone the alert. Not to close, because in the case of some operations you will be notified again, but precisely to postpone. You should remember to deal with and correct the situation or alert as soon as you start your typical work day. Where do the contacts lie or how do you get in touch with colleagues or members of other teams? There must be a clear tool or knowledge in your head - who understands/should know about the situation when it happened. The experts can help you solve the incident, and the stakeholders need to know that something is going wrong. You must have access to their contacts, ideally their phone, because many people turn off notifications from office chats outside of business hours. How do you get access to the production/database and increase access if access levels exist? If you don't have access, you need to know who to go to or what to do to get the access you want. How do you get the code into production quickly? Sometimes problems require a quick change in the service code in production. In general, this is rightly considered bad practice, but often in an emergency, this is not the case. Sometimes you don't want to wait for long E2E tests but need to quickly get the code into the production environment. I would like you to understand how to do this. What data is stored in the database? Are there any schemes of data movement within the product and between services? If you need to interact with the database, it's good to know how the data is organized in a particular service, where it comes from, and who uses it. This will allow you to deal with problems, if there are any, sooner. In addition to tools and experience, a certain amount of knowledge is helpful when you go on duty. Conclusion Even in companies and teams with an excellent engineering culture, on-duty accidents and fires happen. To avoid this, the team must make every effort to improve current processes and products. Still, each engineer must also be prepared that an accident will happen and urgently have to deal with it. To do this, it is worth using all the accumulated personal and team experience. Knowing about the organization and services and being confident in your toolkit is worth knowing. Useful links https://zach-gollwitzer.medium.com/the-ultimate-bash-crash-course-cb598141ad03 https://www.youtube.com/watch?v=oxuRxtrO2Ag https://www.postgresguide.com/utilities/psql/ https://www.mongodb.com/docs/mongodb-shell/

What is a Perfect Duty Engineer?

Ingeniero de servicio perfecto

Ingénieur de service parfait

परफेक्ट ड्यूटी इंजीनियर

パーフェクト デューティ エンジニア

Engenheiro de serviço perfeito

Kỹ sư hoàn hảo

完美值班工程师

is a decentralized exchange to automatically exchange ERC20 tokens, there is no need to wait for a buyer or seller. It has the advantage of the low costs and security of the RSK network. It also doesn’t require KYC and has no limits for withdrawals or deposits. RSKSwap In this post I will present a step-by-step guide to create your own token and exchange it in automatically, using smart contracts. RSKSwap You can read the RSKSwap to learn more about it. Documentation Overview Here is a summary of the steps we will take in this tutorial: We will do these steps: Configure Metamask to connect to RSK testnet; Get some testnet R-BTCs at faucet; Connect Remix with RSK Testnet; Create a token Configure to use RSKSwap - UniswapV2Router02 Add liquidity in a pool on RSKSwap Query prices Do the swap itself Requirements Metamask - google chrome extension Remix - Solidity IDE online To learn more about Remix and Metamask, go to the tutorial . how to use Remix and Metamask to deploy smart contracts on the RSK Testnet Metamask Go to and install it. metamask.io Remix To use Remix, visit remix.ethereum.org Connect MetaMask to RSK testnet Click on the Metamask extension in your browser. Go to networks Select Custom RPC Fill in the fields with the information below: Network Name: RSK Testnet New RPC URL: https://public-node.testnet.rsk.co ChainID (optional): 31 Symbol (optional): tR-BTC Block Explorer URL (optional): https://explorer.testnet.rsk.co After configuring it, close the window and select the . RSK Testnet TestNet Faucet You can get some Testnet R-BTC at faucet.testnet.rsk.co Remix Go to remix.ethereum.org Solidity compiler In the third button on the left side, click Solidity compiler It is useful to enable automatic compilation (auto-compile), to compile smart contracts automatically when editing in Remix. Connect Remix to RSK Testnet First of all, be sure that you selected the RSK network in Metamask. Then, in Remix, on the left side, locate the fourth button - Deploy and run transactions.. In Environment, choose Injected Web3 Injected Web3 connects Remix with active accounts in Metamask A Metamask popup window will open to authorize the connection. First, select the account and click the Next button. You probably only have one, and in the other window, click the Connect button In Remix, in Deploy and run transactions, look at the Custom Network. ChainID 31 was defined at RSK Testnet custom network in Metamask. Create the token Click on the second button on the left side - file explorer Click on + create a new file File name: TokenLaBitconf.sol Copy and paste this token: pragma solidity ; ;
 
contract TokenLaBitconf is ERC20 { (uint256 initialSupply) public ERC20("Token La Bitconf 2020", "TLB") {
        _mint(msg.sender, initialSupply);
    }
} // SPDX-License-Identifier: MIT 0.6 .12 import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol" constructor Compile the token If you enabled auto-compile, the smart contract is already compiled and a green light will appear next to the third button from the left - Solidity compiler. If you didn't enable it: Click the third button from the left: Solidity compiler Click the Compile TokenLaBitconf.sol button Check the green sign on the third button with the message: compilation successful Deploy the token In the left side panel, go to the fourth button - Deploy and run transactions. For now we have only one smart contract, so it is automatically selected in the dropdown. We are going to create 1000 tokens, with 18 decimal places: 1000000000000000000000 For easy conversions, I recommend you use: eth-converter.com Click the Deploy button. It will open a Metamask popup window, to confirm the transaction to create the smart contract TokenLaBitconf.sol Click on confirm. At bottom right, we can check the message: creation of TokenLaBitconf pending... When the transaction was confirmed, copy the token address For example, mine is: 0x2346dDF3D362472A80cF18Ab288594F3204Fb415 RSKSwap - UniswapV2Router02 Now we are going to interact with RSKSwap's main smart contract, which is the UniswapV2Router02 RSK - UniswapV2Router02 testnet / mainnet address: 0xf55c496bb1058690DB1401c4b9C19F3f44374961 Interface UniswapV2Router02 We must have an interface with the functions of UniswapV2Router02 to use in this tutorial. In file explorer, create a new file. File name: InterfaceRouter.sol Copy and paste this example: pragma solidity ; contract InterfaceRouter { ;
 
    address WETH; ; ;
} // SPDX-License-Identifier: MIT 0.6 .12 // Source: https://github.com/Think-and-Dev/rskswap-periphery/blob/master/contracts/UniswapV2Router02.sol; abstract function ( ) external payable ( ) addLiquidityETH address token, amountTokenDesired, amountTokenMin, amountETHMin,
        address to, deadline uint uint uint uint virtual returns amountToken, amountETH, liquidity uint uint uint public //Si quiero comprar tokens X, ¿cuándo tengo que enviar tokens Y? function ( ) 
        external view ( ) getAmountsIn amountOut, address[] calldata path uint virtual returns [] memory amounts uint function ( )
        external
        payable ( ) swapETHForExactTokens amountOut, address[] calldata path, address to, deadline uint uint virtual returns [] memory amounts uint In the right side of button, paste the UniswapV2Router02 address: At Address Now I have two contracts in the section: deployed contracts RSKSwap App Using the user interface of RSKSwap in , we can do simulations and follow along. Click on , choose the wallet, approve the connection on Metamask pop-up window, then go to . app.rskswap Connect to a wallet Metamask Pool Do these steps: Click Import it Click Select a token Paste your token address Click on the Token line to select it You will receive the message . No pool found Do NOT create the pool here because we will do it programmatically. Add Liquidity on RSKSwap To add liquidity to Uniswap, you always need to match it with two pairs. Let’s create a liquidity pool to exchange our token with tRBTC. You are the first liquidity provider. The ratio of tokens you add will set the price of this pool. For example: 0.1 RBTC = 100 tokens 0.001 RBTC por token 1000 token por RBTC We must do 2 steps to add liquidity: Approve in the Token ERC20::approve(address _spender, uint256 _amount) Add liquidity using the funcion UniswapV2Router02::addLiquidityETH(...) Approve Router to Spent Token In the token, we will approve RSKSwap in order to use 100 tokens. address _spender: 0xf55c496bb1058690DB1401c4b9C19F3f44374961 uint256 _amount: 100000000000000000000 These are the parameters in Approve function: , "0xf55c496bb1058690DB1401c4b9C19F3f44374961" "100000000000000000000" Then click the Approve / Transact button Add Liquidity using Remix In the interface, expand the addLiquidityETH button. InterfaceRouter Complete with the following parameters: = token address token = amount of tokens which we would like to add in the liquidity pool. amountTokenDesired = amountTokenDesired because it is the first time, the liquidity pool is empty amountTokenMin = we are creating this liquidity pool now defining the amount of RBTCs (Ethers), so we are defining the price of the token in RBTC (ETH) amountEthMin = your address, because you would like to receive the fees later to = it is a timestamp of Unix in the future, so view the current timestamp and add a few minutes. deadline I use the site to know the current timestamp. To add 5 minutes, use + 300 seconds. unixtimestamp Here is my example: = 0x2346dDF3D362472A80cF18Ab288594F3204Fb415 token = 100 * 10 ^18 (100 y 18 zeros) = 100000000000000000000 amountTokenDesired = amountTokenDesired because it’s the first time we add liquidity amountTokenMin = 0.001 * 10 ^18 = 1000000000000000 amountEthMin = to 0x1b1E4115dFD9352c3E2f6EFB289554C5Ee0560CD = 1610316260 deadline These are the parameters in addLiquidityETH function: , , , , , "0x2346dDF3D362472A80cF18Ab288594F3204Fb415" "100000000000000000000" "100000000000000000000" "1000000000000000" "0x1b1E4115dFD9352c3E2f6EFB289554C5Ee0560CD" "1610316260" you press the transact button, fill in the amount of RBTCs (ETHs) to send at the top of the form. We will send 0.001 RBTC (Ether) BEFORE Click the button or and confirm the transaction on Metamask. Transact addLiquidityETH Check the RSKSwap app In the RSKSwap app, go to , you should probably find your pool now! Pool WRBTC / WETH ERC20 Address The address of the WETH ERC20 token can change from one network to another, but it is saved in a public variable of UniswapV2Router02 contract and we can query it in the interface. So the WRBTC = WETH is . 0x09B6Ca5E4496238a1F176aEA6bB607db96C2286E Get prices Let's get quotes and prices in RSKSwap programmatically. If I would like to buy tokens, how many WETH (wRBTC) do I need to send? To know this I will use the function, with the parameters: getAmountsIn amountOut = The amount I would like to receive path = el path is an array of addresses used to exchange, in this case: [wethAddress, tokenAddress] This will calculate the amount you need to provide, so you will provide some RBTCs / ETHs (or wRBTC / wETH, which are automatically converted), since you want to receive an amount of tokens. Now we would like to have 1 token (1 * 10 ^ 18). What is the price? amountOut = Receive 1 token = 1 * 10 ^ 18 = 1000000000000000000 path =  ["0x09B6Ca5E4496238a1F176aEA6bB607db96C2286E", "0x2346dDF3D362472A80cF18Ab288594F3204Fb415"] Call function using the parameters getAmountsIn , , ] "1000000000000000000" "0x09B6Ca5E4496238a1F176aEA6bB607db96C2286E" "0x2346dDF3D362472A80cF18Ab288594F3204Fb415" For our example, the result is amounts 10131404313952,1000000000000000000 Which means that: 10131404313952 wei RBTC (ETH) = 1000000000000000000 wei Token 0.0010131404313952 RBTC (ETH) = 1 Token I would like to buy 1 Token, I must send 0.0010131404313952 RBTC (ETH). Why aren't you sending exactly 0.001 RBTC (ETH)? It has a small fee of 0.30%. Also the effect of this trade will influence reserves and, therefore, it is necessary to adjust the formula of the constant product, so that the product must remain constant. This will give a different price to the price given to foreign exchange reserves. Execute the swap The last step is to execute an exchange. That's pretty easy now that you understand how the Router works. When you buy tokens with RBTC (ETH), which are probably one of the most common scenarios, you will call the function, with parameters: swapETHForExactTokens amountOut = amount of tokens, including the decimals places, so 1 token is 1 * 10 ^ 18 path = is the array ["addressWei", "addressToken"] to = it is your address deadline = the Unix timestamp in the future, so get the current timestamp and add a few minutes. For example, I want to buy 1 Token: 0.0010131404313952 RBTC (ETH) = 1 Token amountOut = 1000000000000000000 path = ["0x09B6Ca5E4496238a1F176aEA6bB607db96C2286E", "0x2346dDF3D362472A80cF18Ab288594F3204Fb415"] to = 0x54bE4C3721d2dE76eE0104e53b52Ca8B3A1E27Ca deadline = 1607694938 These are the parameters to use in the funcion : swapETHForExactTokens ,[ , ], , "1000000000000000000" "0x09B6Ca5E4496238a1F176aEA6bB607db96C2286E" "0x2346dDF3D362472A80cF18Ab288594F3204Fb415" "0x54bE4C3721d2dE76eE0104e53b52Ca8B3A1E27Ca" "1610317574" pressing the transact button, fill in the amount of RBTCs (ETHs) to send at the top of the form. We will send 10131404313952 WEI BEFORE Click the button or . Transact swapETHForExactTokens Check the RSKSwap app In the RSKSwap app, go to the Pool and confirm that you have one less token! Final considerations In this tutorial, I have shown you how to create a token and exchange it programmatically, using RSKSwap smart contracts. I hope this tutorial has been helpful and I appreciate your comments. Share it if you like it :) The end Author: Solange Gueiros Reviewer: Owanate Amachree

How To Use RSKSwap Smart Contracts To Automate Trading

ORM frameworks like Hibernate and other JPA implementors can significantly simplify development of persistence layer. Introducing entity abstraction level helps to model clean business domain and to hide underlying SQL statements used to achieve persistence of the domain. Such approach is especially useful in large domains, since developer no longer needs to create and maintain all SQL statements used by application. Just a few JPA annotations like / / etc. on the domain classes and or custom repositories to obtain domain aggregate roots, and you are ready to go. Having that, the vast majority of use cases involving persistence can be handled in domain model by JPA cascades and traversing associations and performing operations on them. @Entity @ManyToOne @OneToMany EntityManager Everything comes with a price. In exchange for clean and easy development, some issues can arise sooner or later: Large amount of SQL statements issued by i.e. due to problem excessive lady-loading N+1 SELECT Eager fetches performed (i.e fetchType = on associations) in inefficient way FetchType.EAGER No easy way to invoked across some use case / service call and to list all SQL statements correlate them with exact lines of code Even if for some use case fetching had been optimized to load all necessary data in efficient way, future change in code can silently break it, and there is no way easy to prevent it. In next steps I’ll show the how these problems could be detected, but first let’s see to classic way. new approach Logging JPA issued SQL statements by Hibernate As for now the easiest way to check what SQL statements were executed by JPA was to enable logging of all SQL statements issued by JPA, and then investigate one by one if it was triggered by lazy loading or explicit repository call to fetch/flush some data or maybe commit of transaction triggered it. To enable logging SQL statements executed by JPA via logger, following properties needs to be added in application.yml. logging.level: org.hibernate.SQL: DEBUG spring: jpa: properties: hibernate: format_sql: true # optional use_sql_comments: true # optional Logging to stdout (legacy) instead of via logger can be activated by enabling property. spring.jpa.show-sql As a result a log like the one below can be reported: 2020-10-31 19:37:40.730 DEBUG 15775 products0_.order_id order_id1_9_0_,
 products0_.product_id product_2_9_0_,
 product1_.id id1_14_1_,
 product1_.manufacturer_id manufact3_14_1_,
 product1_.name name2_14_1_ order_product products0_ product product1_ products0_.product_id=product1_.id products0_.order_id=? --- [ main] org.hibernate.SQL : select as as as as as from inner join on where Part of the hibernate logs may contain SQL comments associating SQL statement with the JPA entity class: 2020-11-25 23:51:58.390 DEBUG 28750 book
 (author_id, title, ) (?, ?, ?) --- [ main] org.hibernate.SQL : /* insert com.adgadev.blog.examples.bookshop.Book */ insert into id values In general such logs can be useful, but they lack one crucial information: . Was it executed as a result of initializing entity’s proxy while traversing though JPA entity associations or maybe it was a result of explicit JPQL query execution by a service? If multiple various services in the application could have triggered such query which one of them was it? What was the flow? How to locate place in application source code responsible for triggering it You can try to guess it when the domain and the logic in your codebase is simple or SQL statement points to just one specific place in the code, but it’s not always that easy, especially with queries generated by JPA to lazy load some entities. In such case debugging the code and checking which exact line causes SQL statement may be the only option. Another problem with debugging is that it can alter the real flow how entities are loaded due to resolving variables' values at breakpoint by IDE. Now imagine situation when invoking a service causes dozens of SQL being triggered from various places in your code called by such service. Investigating it is cumbersome and can really take a lot of time. JPlusOne comes to the rescue library aims to solve these problems. It can generate concise reports with all JPA/SQL activity triggered during handling some use cases by your application. That way you can easily correlate invoked SQL statements with JPA operations and locate exact lines in the code responsible for issuing them. JPlusOne 2020-11-26 22:20:52.096 DEBUG 9990 ROOT
 com.adgadev.examples.bookshop.BookshopControllerTest.shouldGetBookDetails(BookshopControllerTest.java:46)
 com.adgadev.examples.bookshop.BookshopController.getSampleBook(BookshopController.java:31)
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails [PROXY]
 SESSION BOUNDARY
 OPERATION [EXPLICIT]
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails(BookshopService.java:32)
 com.adgadev.examples.bookshop.BookRepository.findById [PROXY]
 STATEMENT [READ] [...] book book0_ book0_.id= OPERATION [IMPLICIT]
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails(BookshopService.java: )
 com.adgadev.examples.bookshop.Author.getName [PROXY]
 com.adgadev.examples.bookshop.Author [FETCHING ENTITY] [ ] [...] author author0_ author0_.id= OPERATION [IMPLICIT]
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails(BookshopService.java: )
 com.adgadev.examples.bookshop.Author.countWrittenBooks(Author.java: )
 com.adgadev.examples.bookshop.Author.books [FETCHING COLLECTION] [ ] [...] book books0_ books0_.author_id= --- [ main] c.a.j.core.report.ReportGenerator : select from where 1 34 STATEMENT READ select from where 1 35 41 STATEMENT READ select from where 1 Moreover, it detects what kind of action triggered it: implicit fetching single entity to initialize lazy-loaded "one" side of the association ( / with set to ) @ManyToOne @OneToOne fetch LAZY implicit fetching collection of entities to initialize lazy-loaded "many" side of the association ( / with set to ) @OneToMany @ManyToMany fetch LAZY explicit fetching of data via repository call (SpringData JPA, custom DAO) or directly via EntityManager / triggered at the transaction commit INSERT SELECT is compatible with all Spring Boot 2.x based application running on JDK 9+ with Hibernate as JPA implementor. JPlusOne Sample JPA domain & service To better illustrate the examples let’s assume we have simple domain consisting of two JPA entities. First one is entity: Author { Long id; String name; (fetch = FetchType.LAZY, mappedBy = ) Set<Book> books = HashSet<>(); { books.size();
 }
} @Getter @Entity class Author @Id private private @OneToMany "author" private new int countWrittenBooks () return and second one is entity: Book (of = ) { Long id; String title; (fetch = FetchType.LAZY) (name = ) Author author;

} @Getter @Entity @EqualsAndHashCode "id" class Book @Id private private @ManyToOne @JoinColumn "author_id" private There is also a simple service : BookshopService { BookRepository bookRepository; {
 Book book = bookRepository.findById( ).get();
 String authorName = book.getAuthor().getName(); amountOfBooks = book.getAuthor().countWrittenBooks(); BookDto(authorName, book.getTitle(), amountOfBooks);
 }
} @Service @Transactional @RequiredArgsConstructor class BookshopService private final BookDto public getSampleBookDetails () 1L int return new and a simple MVC controller: { BookshopService bookshopService; ( ) { bookshopService.getSampleBookDetails();
 }
} @RestController @RequiredArgsConstructor class BookshopController private final @GetMapping "/book/lazy" BookDto getSampleBook () return Reporting JPA lazy-loading operations and related SQL statements In order to detect JPA lazy loading operations let’s add following dependency: com.adgadev.jplusone jplusone-core 1.0.1 test < > dependency < > groupId </ > groupId < > artifactId </ > artifactId < > version </ > version < > scope </ > scope </ > dependency The last step is to configure logger for jplusone, i.e. by adding following lines to : application.yml logging.level: com.adgadev.jplusone: DEBUG Spring Boot’a autoconfiguration will do the rest of configuration automatically. Now let’s run any integration test, which directly or indirectly utilizes JPA persistence, i.e. the test which sends request to endpoint. BookshopController ( ) (webEnvironment = MOCK) { MockMvc mvc; {
 mvc.perform(MockMvcRequestBuilders
 .get( )
 .accept(MediaType.APPLICATION_JSON))
 .andExpect(status().isOk());
 }
} @ActiveProfiles "integration-test" @SpringBootTest @AutoConfigureMockMvc class BookshopControllerTest @Autowired private @Test Exception void shouldGetBookDetails () throws "/book/lazy" It will result in adding a log entry containing JPlusOne report of JPA operations / SQL statements, like the one below: 2020-11-26 22:27:59.683 DEBUG 10730 ROOT
 com.adgadev.examples.bookshop.BookshopControllerTest.shouldGetBookDetails(BookshopControllerTest.java:46)
 com.adgadev.examples.bookshop.BookshopController.getSampleBook(BookshopController.java:31)
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails [PROXY]
 SESSION BOUNDARY
 OPERATION [IMPLICIT]
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails(BookshopService.java:34)
 com.adgadev.examples.bookshop.Author.getName [PROXY]
 com.adgadev.examples.bookshop.Author [FETCHING ENTITY]
 STATEMENT [READ] [...] author author0_ author0_.id= OPERATION [IMPLICIT]
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails(BookshopService.java: )
 com.adgadev.examples.bookshop.Author.countWrittenBooks(Author.java: )
 com.adgadev.examples.bookshop.Author.books [FETCHING COLLECTION] [ ] [...] book books0_ books0_.author_id= --- [ main] c.a.j.core.report.ReportGenerator : select from where 1 35 41 STATEMENT READ select from where 1 In this case we see that there was two lazy loading operations: Within method there was execution of method on object which was proxy to JPA entity . As a result initialisation of this proxy object was triggered, causing execution of SQL query. BookshopService.getSampleBookDetailsUsingLazyLoading getName Author Within method a content of collection representing "many" side of the association with entities has been accessed. As a result initialisation of this collection was triggered ( ) along with execution of SQL query. Author.countWrittenBooks books Book Author.books Due to the fact that queries generated by JPA, especially those where a few joins are applied, can contain very large number of selected columns, which doesn’t bring too much value from performance optimisation point of view but degrade readability of complex SQL statements, JPlusOne replaces them with in a report. […​] Reporting other types of JPA operations and related SQL statements By default only lazy loading operations ( ) resulting in SQL statements are included in a report. JPA operations related with explicit calls to fetch / flush some data ( ) are not included. Likewise, operations related with session flush on transaction commit ( ). IMPLICIT SELECT EXPLICIT COMMIT Default behaviour can be easily changed by defining custom filtering criteria by adding following lines to More details about supported filtering modes and other configuration options can be found in . application.yml JPlusOne documentation jplusone: report: operation-filtering-mode: EXPLICIT_OPERATIONS_ONLY statement-filtering-mode: ALL_STATEMENTS Running the same test as in previous example result now in following report: 2020-11-26 22:30:13.497 DEBUG 10997 ROOT
 com.adgadev.examples.bookshop.BookshopControllerTest.shouldGetBookDetails(BookshopControllerTest.java:46)
 com.adgadev.examples.bookshop.BookshopController.getSampleBook(BookshopController.java:31)
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails [PROXY]
 SESSION BOUNDARY
 OPERATION [EXPLICIT]
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails(BookshopService.java:32)
 com.adgadev.examples.bookshop.BookRepository.findById [PROXY]
 STATEMENT [READ] [...] book book0_ book0_.id= --- [ main] c.a.j.core.report.ReportGenerator : select from where 1 Report shows that there is one explicit fetch operation, triggered in in line 34 by calling method of Spring Data JPA repository , which result in one SQL query being executed. BookshopService.getSampleBookDetailsUsingLazyLoading findById BookRepository Ensuring JPA / SQL optimized service stays optimized in future Nowadays tests no longer serves just purpose of ensuring that a piece of code works as expected and is bug free. Other aspects of the code also can be tested. Great example of it is a which allows unit testing architecture of the application, i.e. ensuring layered structure of the application is maintained. Since you can unit test architecture, why not test if once optimized from JPA/SQL performance point of view use case logic stays optimized after future changes in the code? Adding or modifying some JPA mapping / association can easily introduce some additional lazy loading operation in some flows, but it may be hard to spot that when such change is applied. ArchUnit Let’s extend integration test from previous example with validation checking that there are only two JPA lazy loading operations: first for loading JPA entity, and second for loading collection. In order to write such tests following dependency needs to be added: Author Author.books com.adgadev.jplusone jplusone-assert 1.0.1 test < > dependency < > groupId </ > groupId < > artifactId </ > artifactId < > version </ > version < > scope </ > scope </ > dependency and then object has to be defined and checked against injected . JPlusOneAssertionRule assertionContext ( ) (webEnvironment = MOCK) { JPlusOneAssertionContext assertionContext; MockMvc mvc; {
 mvc.perform(MockMvcRequestBuilders
 .get( )
 .accept(MediaType.APPLICATION_JSON))
 .andExpect(status().isOk());

 JPlusOneAssertionRule rule = JPlusOneAssertionRule
 .within().lastSession()
 .shouldBe().noImplicitOperations().exceptAnyOf(exclusions -> exclusions
 .loadingEntity(Author.class)
 .loadingCollection(Author.class, )
 );
 rule.check(assertionContext);
 }
} @ActiveProfiles "integration-test" @SpringBootTest @AutoConfigureMockMvc class BookshopControllerTest @Autowired private @Autowired private @Test Exception void shouldGetBookDetails () throws "/book/lazy" "books" Since the rule is fulfilled the test is green. Let’s see what happens when third lazy loading operation is introduced to implementation. The easiest way to do that would be to change single line in from: BookshopService.getSampleBookDetailsUsingLazyLoading Book book = bookRepository.findById( ).get(); 1L to: Book book = bookRepository.getOne( ); 1L causing JPA proxy being returned instead of JPA entity. The proxy will be initialized on first operation invoked on it, leading to lazy-loading of entity. When test is re-run is thrown: Book AssertionError java.lang.AssertionError: Actual amount of IMPLICIT operations after applying exclusions is different than the expected amount
 Expected: exactly (0)
 Actual : (1)

Operations after applying requested exclusions:
 ROOT
 com.adgadev.examples.bookshop.BookshopControllerTest.shouldGetBookDetails(BookshopControllerTest.java:46)
 com.adgadev.examples.bookshop.BookshopController.getSampleBook(BookshopController.java:31)
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails [PROXY]
 SESSION BOUNDARY
 OPERATION [IMPLICIT]
 com.adgadev.examples.bookshop.BookshopService.getSampleBookDetails(BookshopService.java:34)
 com.adgadev.examples.bookshop.Book.getAuthor [PROXY]
 com.adgadev.examples.bookshop.Book [FETCHING ENTITY]
 STATEMENT [READ] [...] book book0_ book0_.id= com.adgadev.jplusone.asserts.impl.rule.AmountVerifier.checkAmount(AmountVerifier.java: ) com.adgadev.jplusone.asserts.impl.rule.Condition.checkOperation(Condition.java: ) com.adgadev.jplusone.asserts.impl.rule.Condition.check(Condition.java: ) com.adgadev.jplusone.asserts.impl.rule.Rule.lambda$ $ (Rule.java: ) java.base/java.util.ArrayList.forEach(ArrayList.java: ) com.adgadev.jplusone.asserts.impl.rule.Rule.check(Rule.java: ) com.adgadev.jplusone.asserts.impl.Assertion.check(Assertion.java: ) com.adgadev.jplusone.asserts.impl.ConditionDoneBuilderImpl.check(ConditionDoneBuilderImpl.java: ) com.adgadev.examples.bookshop.BookshopControllerTest.shouldGetBookDetails(BookshopControllerTest.java: )
 ... select from where 1 at 44 at 84 at 54 at check 0 48 at 1540 at 48 at 38 at 38 at 57 Summary The full source code of the examples is available . here If you find useful and worth further development, please star the project repository on , thanks! JPlusOne library GitHub Previously published at https://adgadev.com/finding-origin-and-context-of-jpa-issued-sql-statemets/

How To Find Origin And Context of JPA For Issued SQL Statements

The Humans of design unprecedented products, and contribute to the internet in unprecedented ways. One such human is from the US - interviewed here following for contributions to . “In these unprecedented times…” Hacker Noon Agnieszka Zimolag a 2020 Noonie Nomination the subject of Product Design Thank you to our 2020 Noonies partners : Sustany Capital , .TECH Domains , Grant for the Web , Skillsoft , Flipside Crypto , Udacity , and Beyondskills ! The Noonies are Hacker Noon’s way of getting to know — from a community perspective —  what matters in tech today. So, we asked our Noonie Nominees to tell us. Here’s what Agnieszka Zimolag had to share. 1.  Which 2020 Noonie have you been nominated for? Hacker Noon Contributor of the Year - PRODUCT DESIGN . 2. Tell us a bit about yourself. I'm a Product Designer at BCGDV, part of the Boston Consulting Group Inc. with 7 years of industry experience working for startups across the US and India. I am excited to be part of a vastly digitizing world where more and more value is captured online and therefore can be made accessible to people and digital ecosystems around us. Product Design is a tool for me that allows me to build interfaces between people and businesses and allow for the exchange of this value. I am constantly trying to learn and update myself about the changing role of the product designers and bring that fresh perspective to the projects I am working on. As a product designer, I am thinking very holistically about the products/services I am working on and when evaluating the Product Market Fit or the Right To Win - I am taking every aspect of the product such as the UX/ Branding/ User Impact/ Business Impact/ Acquisition/ Retention models. I believe that all puzzles need to work together in order to build sustainable and edge-cutting solutions. 3. Tell us about the things you make / write / manage / build. I write about new ideas for products that can help businesses and users to gain more value out of the digitized world. I like to take the specific aspect of the product design for example; building trust or ethical principles and dissect it into small pieces and advise companies how they can implement these changes into their own offerings. These product ideas can be implemented into the organizational structures/ DevOps too and are not bond purely to product design. I am also very enthusiastic about the new technical solutions for example Explainable AI (XAI) and how that can be brought into the product design so that people can use it in the most intuitive and impactful way. To summarize, I am product designer by heart but I am trying to enrich that discipline by doing research in various fields to see how products are going to evolve in a couple of years and bring that knowledge back to the community. 4. What are you most excited about right now? How technology such as quantum technology, blockchain, AI/ML is becoming accessible on the enterprise level and product designers can get their hands dirty with these amusing offerings and be researchers and main stakeholders at the same time! 5. What are you worried about right now? One of things that bothered me is that discontinuity from the research world and the enterprise level design. I would love to see more connections/ interactions happening so both can influence each other and let designers get up-skilled faster. I would like product design field to be evolving at more accelerated pace just like the tech solutions are. 6.   What's the most useful advice you've ever given somebody? Worry later. Try first. Learn from mistakes. 7. How has the pandemic changed your life and/or career? It made me think that we need to shift from the human-centered thinking to more societal, global, civilizational level as we are one big community that lives off the ecosystems surrounding us. 8. If we gave you $10 million to invest in one thing right now, where would you put it? Program that could allow product designers to work with the companies they always dreamt to work with or projects they really want to be involved. I think eye-opening experiences can accelerate someone's life to unprecedented scale and could let more people be super excited about product design discipline! 9. What's an opinion you have that most people don't agree with? Human Centered Design and Design Thinking. I think these terms are overused. Since we face many global challenges we should shift our thinking from the individual level to be more ecosystem oriented and see impact on a larger scale. Design thinking term became vague to me so i would propose to think beyond it and define what actions we should take to iterate. 10. Which apps can't you live without? Definitely Instagram and Linkedin. I just love the amountoof news cming from the tech and design world everyday. 11. What are you currently learning? I am learning about the smart contracts, quantum computing, product management and just discovered this very exciting website called untools - around systemic thinking. VOTE for Agnieszka Zimolag as Hacker Noon Contributor of the Year - PRODUCT DESIGN before voting closes on 12 October, 2020! 🚀 With gratitude to Hacker Noon's 2020 Noonies Partners: Sustany Capital , .TECH Domains , Grant for the Web , Skillsoft , Flipside Crypto , Udacity , and Beyondskills !

"Worry Later. Try First," says Product Designer Agnieszka Zimolag

If you have been part of the / Cryptocurrency ecosystem for at least a few months, you might be aware of the ICO craze going around.There’s literally dozens of ICOs / Token Sales springing out every day as can be seen on popular platforms — like or — tracking ICO activity. Ethereum IcoAlert TokenMarket One of the most common practices used by ICO teams to promote and incentivize their token sales is to offer hefty discounts or bonuses to contributors based on they buy into their tokens or they are willing to invest. when how much Why should the rich get richer? Recently, there’s been some hot debate whether or not it’s ok for ICOs to offer bonuses based on volume purchased / money spent. Detractors of this practice argue that it goes against the spirit of Ethereum — And crypto in general — to reward people with more resources to gain an advantage over other people with less resources. Accessing Volume Discounts by Resource Pooling Volume-based bonuses won’t be going away anytime soon. So… How can we take advantage of these bonuses if we can’t (or won’t) commit the minimum ether the ICO team is asking for? One of the ways to do this would be to find a few friends that are also interested in contributing to a particular ICO and have them send their ether to one of the members of the group, have him buy the tokens and then distribute the acquired tokens accordingly among this group of friends. Love, Faith and Hope. These are much needed when investing together with friends. (Photo by on ) Jonathan Brinkhorst Unsplash In theory, this approach is pretty easy and straightforward, but in practice, it can become problematic. For one, you would have to trust this person receiving everyone’s ether to come through, which already is a risky proposition. What if this person disappears with the money? What if he forgets his private key? What if his private key gets stolen? What if he makes a mistake and sends the money to an incorrect address? There’s so many things that could go wrong. Also, what if we don’t have enough friends that are interested in investing with you in a particular ? You might still want to do it and pool the money with complete strangers. There are a few sites and forums where people can find other people to invest together, but this presents a huge risk for everyone involved. I wouldn’t send money blindly to someone I don’t know extremely well, and neither should you. ICO So, how can we collaboratively invest on an ICO without having to trust anyone else with our money? With a smart contract, of course! 📄 Building an Investment Pool Smart Contract In the following paragraphs I’m going to describe how to build a smart contract that allows several contributors to send money to it; have it invest in the selected ICO when some pre-conditions are met; and finally have it distribute the tokens purchased on a pro-rata basis. This smart contract would act as an intermediary that collects the money from several accounts and then forwards the collected funds to an ICO contract in one transaction in order to gain access to the volume-based bonus offered by the team. The tokens would then be bought by the contract, which allows the contributors that participated in the investment pool to withdraw them to their own accounts. Let’s take a look at the smart contract that allows all this. But first, a few disclaimers, warnings and considerations: Before using the following contract to create an investment pool for an ICO you should make sure said ICO will allow you to later withdraw the tokens. Some ICOs don’t use an smart contract while collecting contributions for example. Some ICOs also have whitelist mechanisms in place and KYC steps that need to be completed that might prevent a contract from investing on behalf of a physical person. The ICOPool contract has no way to know the details of the ICO it is targeting since there is no standard protocol to crowdsale contracts. This means that, for example, it doesn’t know if there’s a deadline for the bonus or what’s the minimum / maximum contribution amounts, or if the ICO has already finished, etc. So, the contract relies on its admin to properly configure it and trigger the token purchase at the right moment. The ICOPool contract ends up participating in the ICO by making an external call to the crowdsale contract, executing its fallback function. Most crowdsale contracts are prepared to execute a buyTokens function(or a function with a similar name) upon receiving ether without any other data. You should make sure the ICO you do the investment pool for works this way. It goes without saying that the tokens being bought must be ERC20 compliant. If they are not, you won’t be able to guarantee that the tokens can be transferred from the investment pool to the contributors. The following code has not been tested yet in a real-life project. Also, make sure the ICO you choose for the investment pool is not a scam. Using this contract has the same risks as if you would invest in the ICO by sending ether to it, this contract adds no additional security mechanisms. Use it under your own risk, I’m not to be held responsible for its improper use. Proceed with extreme caution. The ICOPool Smart Contract You can find the complete source code in my Github repository. Please take a look at the README.md file for further usage instructions, more in-depth information and examples. The ICOPool contract has 4 parts to it: Configuring the investment pool. Receiving ether from contributors to form the pool. Investing in the target ICO once the pool’s requirements have been met. Allowing the contributors to obtain the acquired tokens. Configuring the investment pool In order to put an investment pool in place, first we have to deploy the contract with a few parameters. The account deploying the ICOPool contract will become its admin. The admin’s only purpose is to execute the function that buys into the ICO. Here’s the code involved in the creation of the investment pool. function ICOPool(address _targetICO,uint _minContribution,uint _maxContribution,uint _poolSoftCap,uint _poolHardCap,uint _contributorsSoftCap,uint _contributorsHardCap) public { require (\_targetICO != address(0)); 
 require (\_minContribution > 0); 
 require (\_maxContribution > \_minContribution); 
 require (\_poolHardCap > \_poolSoftCap); 
 require (\_contributorsSoftCap > 1); 
 require (\_contributorsHardCap >= \_contributorsSoftCap); 
 
 // Max people \* their minimum contribution should be able to meet pool softcap 
 // For example, we can't allow having the max contributors (10 people) put $100 each when the softcap is $1500. 
 require(\_contributorsHardCap \* \_minContribution >= \_poolSoftCap); 
 // Min people \* their maximum contribution should be within pool hardcap 
 // For example, we can't allow 3 people to reach the hardcap if the minimum contributors is 5 
 require(\_contributorsSoftCap \* \_maxContribution <= \_poolHardCap); 
 
 targetICO = \_targetICO; 
 poolAdmin = msg.sender; 
 minContribution = \_minContribution; 
 maxContribution = \_maxContribution; 
 
 poolSoftCap = \_poolSoftCap; 
 poolHardCap = \_poolHardCap; 
 
 contributorsSoftCap = \_contributorsSoftCap; 
 contributorsHardCap = \_contributorsHardCap; 
} The contract receives quite a few constructor parameters: This is the ICO the investment pool will contribute its funds to. Anyone using this contract should double check this variable is pointing to the ICO the organizer says it does. address _targetICO: These are the minimum and maximum amount of ether (expressed in wei) that the contributor to the investment pool can put into the pool. uint _minContribution & uint _maxContribution: These are the minimum and maximum amount of ether (expressed in wei) that the investment pool allows in order to be able to invest in the target ICO. The soft cap must be reached before the admin can buy the tokens from the ICO. And no contributions may be accepted once the hard cap is reached. uint _poolSoftCap & uint _poolHardCap: These are the minimum and maximum amount of contributors the investment pool may accept. uint _contributorsSoftCap & uint _contributorsHardCap: Notice there’s a complex relationship between all these parameters so we don’t risk the chance of the investment pool getting stuck: The soft cap ( should be lower than the max amount of contributors ( multiplied by their minimum possible contribution ( _poolSoftCap) _contributorsHardCap) _minContribution). This way, it is not possible for the ICOPool to reach full capacity in terms of people but not reach the minimum ether goal. (If 10 people is the maximum number of contributors allowed, they should not be able to only invest 1 eth each, if the soft cap is greater than 10 eth). Along the same lines, the hard cap should be higher than the minimum amount of contributors multiplied by their maximum possible contribution. This way, it is not possible for the ICOPool to reach full capacity in terms of ether but not reach the minimum people required. (2 people should not be allowed to reach the pool’s hard cap if the minimum people was 3 or more). It’s also extremely important to notice that the ICOPool contract has no way to know what the minimum contribution is in order to trigger the bonuses. It’s up to the admin to correctly set the soft and hard caps accordingly. Receiving ether from contributors Once the investment pool is set up, the person who created the contract can start promoting it among other people to pool contributions. Sending ether to the investment pool is done the same way as one would with a crowdsale. Just transfer the ether to the given address and the contract will take care of it. *It’s worth mentioning that the contributor should take the same measures he takes when investing directly on the crowdsale. For example, they must send the money from an account they own the private key of. Here’s the code that gets executed when someone sends money from their account. function() payable public {require(msg.value > 0);require(msg.value >= minContribution && msg.value <= maxContribution); // Must send eth within min and max contributionsrequire(contributorsBalance[msg.sender].add(msg.value) <= maxContribution); // msg.sender's balance can't exceed max contribution limit // Pool can't exceed hard cap 
 require(poolBalance.add(msg.value) <= poolHardCap); 
 
 //Register how much eth the pool has 
 poolBalance = poolBalance.add(msg.value); 
 
 //If it is the first time this account contributes, increase num. of contributors 
 if (contributorsBalance\[msg.sender\] == 0){ 
 amountOfContributors++; 
 } 
 // Pool can't exceed contributors hard cap 
 require(amountOfContributors <= contributorsHardCap); 
 
 //Register how much eth has each contributor put into the pool 
 contributorsBalance\[msg.sender\] = contributorsBalance\[msg.sender\].add(msg.value); 
} First, we make sure that the contribution being made is within the boundaries the admin defined and that the people/money hard cap is not exceeded. If the contribution is accepted, we add the money sent to the contributor’s balance. The contributor doesn’t have to put all the money in one go, but each contribution should meet the minimum set by the admin. Investing in the target ICO At any point in time — as long as the minimum requirements are met — , the admin may decide to stop collecting funds and make the purchase of the tokens from the ICO. Once he does, the investment pool contract may no longer accept incoming transfers of ether. As I mentioned before, this step must be performed by the admin, although the contract could be modified to allow any of the contributors to do it. This other approach makes the contract less dependent on one person, but it also makes it more messy and prone to problems. The main issue with allowing anyone to buy the tokens has to do with the fact that this ICOPool contract has no way to know the inner workings of the target ICO. In order to avoid conflict, the admin is the one that decides when to buy the tokens, and responsible for it. For example, the contract has no way to check if the volume bonus promoted by the ICO team is active at the moment, so it’s up to the pool admin to check that and move forward with the token purchase. — Or not doing anything so the contributors can withdraw their funds — . function buyTokensFromICO() public {require(!investedInICO);require(poolBalance >= poolSoftCap);require(amountOfContributors >= contributorsSoftCap);require(this.balance >= poolBalance); //Can be called only by the pool admin to avoid timing problems 
 // We'll need to trust the admin to execute this at the right moment 
 // Could be changed to allow any contributor to call it. 
 require(msg.sender == poolAdmin); 
 
 investedInICO = true; 
 
 // BE CAREFUL, OPENING RE-ENTRANCY DOOR 
 require(targetICO.call.value(poolBalance)()); 
 
 // \*\*\*\*\*\*\*\*\*\*\*\*\*\* 
 //If you are hesitant about using call() you can instead instantiate 
 //the target ICO and directly use whatever function it has to buy tokens 
 // ------ 
 //Crowdsale c = Crowdsale(targetICO); 
 //c.buyTokens.value(poolBalance)(); 
 // \*\*\*\*\*\*\*\*\*\*\*\*\*\* 
} Sending the funds to the target ICO is pretty straightforward. Once we have checked that the soft caps have been met, we proceed to forward the ether to the target ICO. Using the call() function and sending the pool balance along will trigger the ICO’s fallback function. Once thing the admin (and contributors) should do before investing in the pool is making sure the pool will indeed be able to invest in the target ICO. This contract assumes the ICO has a fallback function that triggers the contract’s own buyTokens (or whatever it is called) function. If the target ICO doesn’t have a fallback function implemented or you feel insecure about using the call() function to execute potentially insecure code, then you could use another method I’ve left commented in the code. You could instantiate the target ICO contract and call it’s buyTokens function directly. This function also sets the investedInICO flag so we can only call this function once. If the people involved wanted to pool more money and invest a second time, they would have to create a new ICOPool contract. Withdrawing the tokens Once the previous step has been completed, the target ICO’s token should be holding our ICOPool’s token balance. You should be able to check this by calling the balanceOf() function of the token by passing the ICOPool’s address to it. So, there’s one more step left that each contributor has to complete; the withdrawal of the tokens each one is entitled to. function withdrawTokens(address _tokenAddress) public {require(contributorsBalance[msg.sender] > 0); ERC20 token = ERC20(\_tokenAddress); 
 require (token.balanceOf(this) > 0); 
 
 // tokenBalance is always the max tokens the pool bought (balanceOf + already withdrawn) 
 uint tokenBalance = token.balanceOf(this).add(tokensWithdrawn); 
 
 // Get contributor share based on his contribution vs total pool 
 // poolBalance (total wei pooled) -> contributorsBalance\[msg.sender\] (wei put by msg.sender) 
 // tokenBalance (total tokens bought with poolBalance) -> tokensToWithdraw (how many tokens corresponds to msg.sender) 
 uint tokensToWithdraw = tokenBalance.mul(contributorsBalance\[msg.sender\]).div(poolBalance); 
 tokensToWithdraw = tokensToWithdraw.sub(tokensWithdrawnByContributor\[msg.sender\]); 
 
 require(tokensToWithdraw > 0); 
 
 // Keep track of tokens already withdrawn 
 tokensWithdrawn = tokensWithdrawn.add(tokensToWithdraw); 
 tokensWithdrawnByContributor\[msg.sender\] = tokensWithdrawnByContributor\[msg.sender\].add(tokensToWithdraw); 
 
 // Transfer calculated tokens to msg.sender 
 require(token.transfer(msg.sender,tokensToWithdraw)); 
} As I mentioned above, the ICOPool contract is now holding the tokens it bought. Now it’s up to each contributor to withdraw their own tokens by having each one of them call the withdrawTokens(address _tokenAddress) function. Notice the function requires one parameter, the token’s address, not to be confused by the ICO’s address. At this point, the ICO has no utility, what we need is to change the ownership of the tokens, so we need to get a hold of the token address. When one of the contributors calls this function, it will calculate how many tokens they are entitled to based on the total money the pool received and how much this person’s contribution represents. For example, suppose the total pool balance was 100 eth, that were used to buy 100.000 tokens. If I invested 30 ether, then I would be entitled to 30.000 tokens. The function will figure out how many tokens of the total that were bought correspond to the contributor and then call the transfer function on the token to make the transfer from the contract to the contributor. If you call balanceOf() again, the contributor should now own those many tokens and the contract should have those many less. One thing to notice is that this function has been designed so that the contributor may call it more than once, and if there were more tokens than before, he would get the difference. You might be wondering why we are doing this if I previously mentioned that the ICOPool contract may only buy tokens once. Well, there’s the slight chance that our ICOPool contract might receive tokens besides buying them. There’s a popular marketing practice some ICOs are implementing lately called Airdrops where they basically send tokens to random addresses in order to promote their product.The way our withdrawTokens() function works allows the contributors to get their share of these tokens as well. Where to go from here There are lots of improvements that can be done to this contract. For example: The person deploying the contract — the admin — will incur in more costs than the rest of the contributors because he has to pay the necessary gas to deploy the ICOPool contract, and he is not reimbursed for it. We could device some scheme that rewards more tokens to the person organizing the investment pool. We could add a deadline to it so if the tokens are not bought by that date the pool gets cancelled. If there was some standard or common protocol to crowdsale contracts we could make our contract friendlier to the contributors. The contract could be modified to allow investing in more than one ICO, and even decide, somehow, in which ICOs to invest given their bonus schemes. Drop me a line if you are interested in implementing this contract to invest in an ICO. And please do contact me if you find any bugs or you want to discuss any parts of this code. I hope you enjoyed reading this article as much as I enjoyed writing it. I’m currently taking consultancy jobs related to smart contracts development. If you are planning on raising funds through an ICO or building a Blockchain-based product, feel free to get in touch with me.

AKOUNTO

akounto.com

-- employees

Since n.d.

COMPANY RANKING

AKOUNTO

EVERGREEN INDEX #1918

Representing this company? Click here to claim and customize this page!

Akounto WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

AKOUNTO

akounto.com

-- employees

Since n.d.

COMPANY RANKING

AKOUNTO

EVERGREEN INDEX #1918

RELATED COMPANIESRANK

STORIES ABOUT AKOUNTO

Representing this company? Click here to claim and customize this page!

Akounto WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!