Doctors, nurses, and other paramedical professionals use ShareSmart everyday to conduct referrals, collaborate on clinical cases and to provide decision support in order to enhance patient care

ShareSmart

Smart contract development is no different than other types of software development. Code is written to perform a certain task, and there are tools that help make this process easier. The Ethereum ecosystem contains many mature tools to help build Web3 projects, but what about a newer ecosystem, such as Flow? If you’ve been following along with this series so far, you’ll know that the Flow blockchain is optimized for digital asset creation and management. Additionally, its smart contract language, Cadence, improves upon other languages’ pitfalls through its resource-based approach and a strong, static type system. In this article, we’ll take a look at the essential tools smart contract developers can use to make building on Flow easier—tools such as CLIs, IDE extensions, client libraries, local networks, and more. We’ll also contrast these to Ethereum tools you may already be familiar with, so if you’re making the switch to Flow, you’ll know exactly what to expect. Command-line Interfaces Command-line interfaces (CLI) are the bread and butter of software development. They are intuitive for most developers and integrate easily with other software. This easy integration applies to smart contract development as well. For example, if you need to quickly deploy a contract to test it or run it with different accounts, a CLI can help immensely. And later, when you want to add the deployment process to a CI/CD pipeline, you’ll be happy to have a simple CLI tool you can automate with shell scripts. On EVM-compatible networks like Ethereum, Truffle and Hardhat both offer powerful tools for these tasks. The is used for almost all actions with Hardhat, while the __ __enables developers to quickly interact with their smart contracts via JavaScript without having to write script files. Hardhat Runner Truffle Console is the primary tool for developing, testing, and deploying smart contracts written in Cadence to the Flow network. In addition, it’s the interface you use when interacting with the Flow blockchain, such as creating and checking accounts, signing transactions, or automating tasks with scripts. The Flow CLI Unlike Ethereum, where you would generate an address to interact with the blockchain, Flow requires you to have an account. This account holds your smart contracts, tokens, and keys, and is necessary for interacting with the blockchain. You can . easily create accounts using the Flow CLI IDE Extensions Next, you want to write some code, and languages like Cadence and Solidity offer static type checking that gives you some helpful information about how your code will behave in your editor. While Solidity comes with a fundamental type system that prevents you from mixing different number types, Cadence goes a few steps further and introduces the concept of ownership. You might know this from Rust, but the basic idea is that Cadence has resources, like NFTs, that can only be owned by one address. A Cadence IDE extension will notify you about issues with your NFT transactions right at the point when you’re writing the code, while also offering syntax highlighting, code completion, and type checking. Linters You might know linters from languages like JavaScript, where no static typing is available. In this context, a linter helps to prevent common errors and to aid developers in following best practices. The same is true for , a linter tool for Solidity. Again, Solidity’s static type system is very rudimentary and doesn’t prevent many errors while using the language. Solhint comes to aid here and provides tips on top of the type system to avoid misuse. Solhint The Cadence language has a much more sophisticated type system and comes with more help than Solidity. A correctly typed Cadence smart contract is more secure than a correctly typed Solidity one. The typical linter functionality is built right into the Cadence language itself through its type system, but if you want to run type checks on multiple Cadence files inside your CI/CD pipeline, the tool can help. Cadence lint Local Networks A local network, or a network emulator, is a tool that will run a blockchain network on your development computer, so you can test in a clean environment and not risk pushing unfinished smart contracts to a live blockchain. A local network also has lower latency and allows you to control the block creation, so you can step through everything that happens when your smart contract executes. When developing on the EVM, you probably know and use or Ganache for this task. Both tools simulate a blockchain environment on your local machine and allow you to fork a version of mainnet to interact with real accounts and contracts. the Hardhat Network Flow offers a similar feature called that simulates the real Flow network but gives you to interact with. It enables account storage limits, setting initial FLOW token supplies, and enabling persistent state between restarts. This powerful tool is used via the Flow CLI mentioned above and together, they provide all the features developers need to build fully functioning dapps and the environment to test them in. the Flow Emulator more options With the , all one has to do to start the emulator is type the command flow emulator in their terminal. Flow CLI installed Testnet Faucets When developing smart contracts, you typically need crypto tokens to deploy and interact with your code. Otherwise, how will you test transactions? Flow, just like Ethereum, has__ __ that comes with that drips you free testnet FLOW or FUSD for development. a testnet a faucet Additionally, Blocto Swap is a multi-use tool that makes creating an account on Flow simple for users. All one has to do is enter an email address. Blocto Swap allows users to easily exchange their tokens for different types to use in testing. This tool is also a handy way to get FUSD if that collection is not already initialized in the account. : tokens on a testnet hold no value outside of testing. Remember Automated Testing Cadence and Solidity both have test automation tools that allow you to write your tests in JavaScript. The Hardhat development tools use the Chai test runner and supply you with and for the EVM. smart contract matchers network helpers Cadence has that use as the base, but they’re framework agnostic. So if Jest isn’t your thing, you can use a different test runner. its own tools Jest Blockchain Explorers Another vital part of all blockchain networks is the block explorer—a tool that allows you to check out everything that happens on-chain. For the Ethereum network, you might know . It’s a web application that lets you browse mainnet and testnet transactions and addresses. Etherscan Flow comes with a much more powerful tool, ! Flowser Flowser (Flow Browser) is a web application, but you can run it locally. It allows you to browse both the Flow mainnet and any local network you start with the Flow Emulator. It even comes with a GUI to configure and start an emulator and manage your development wallets. However, if all you need to do is check transactions or browse on the Flow mainnet or testnet, then the traditional block explorer__ __ will suit your needs. Flowscan Additionally, the tool allows users to inspect accounts and their various attributes, such as balances, keys, and any contracts they may contain. flow-view-source Interfacing with JavaScript To build a decentralized application (dapp) for your smart contract, you need a bridge between the blockchain network and the web. Flow and Ethereum both come with Webpack integrations to solve this problem. will automatically reload your application when you change your Solidity code, so your frontend always runs with the current version of your smart contract while in development. The Solidity Loader Cadence offers similar features via its and . Webpack plugin the Cadence utilities Additionally, the (FCL) JS is one of the best ways for a developer to quickly start building on the Flow blockchain. This package makes interacting with wallets and smart contracts simple and secure, while providing all the tools necessary to create fully functioning dapps. Flow Client Library Playgrounds Being able to test your code in environments without having to invest the time in creating an entire project enables developers to quickly figure out what works and what doesn’t. To that end, Flow has the . Not only is it an excellent resource to iterate through ideas quickly, it’s also a great environment to learn in, with tutorials included to teach important concepts and how to build common projects. Flow Playground Although Ethereum doesn’t have any projects exactly like the Flow Playground, there are a few you could take advantage of to create a similar experience. The online Solidity code editor, , provides an environment to quickly build and test smart contracts. Additionally, you could follow along with the to help get you up to speed with Solidity and Remix. Remix Developer DAO Academy Summary Software development, and smart contract development in particular, is a complex process that consists of different vital steps. Planning, coding, testing, deploying, and maintenance are all important parts of the process, and having the proper tools at hand makes things easier. Although Flow has a younger ecosystem compared to Ethereum, the tools and libraries available are mature enough to help speed up the development process. From command-line interfaces and IDE extensions to local networks and block explorers, Flow has all the tools an Ethereum developer might be expecting and more. Additionally, the type system and built-in features of the Cadence smart contract language offer controls that Solidity can’t offer without additional tools such as linters. Even then, the value those Solidity tools delivers is inferior to the features Cadence provides natively. Overall, the Flow ecosystem comes with for each step of the development lifecycle. To get started building on Flow, check out their . Developers are also encouraged to share their own tools with the ecosystem, contribute to already existing tools, or to build your projects. all the tools you need Developer Portal apply for grants For a list of other great tools in the Flow ecosystem, . check out this Github repo Have a really great day!

Building Easy Workflows For Web3 Using Flow & Cadence

How To Write a Solidity Smart Contract and Deploy it on Ropsten

Cómo escribir un contrato inteligente de Solidity e implementarlo en Ropsten

Comment rédiger un contrat intelligent Solidity et le déployer sur Ropsten

सॉलिडिटी स्मार्ट कॉन्ट्रैक्ट कैसे लिखें और इसे रोपस्टेन पर कैसे लागू करें?

Solidity スマート コントラクトを作成して Ropsten にデプロイする方法

Como escrever um contrato inteligente de solidity e implantá-lo no Ropsten

Làm thế nào để viết một hợp đồng thông minh vững chắc và triển khai nó trên Ropsten

如何编写 Solidity 智能合约并将其部署在 Ropsten 上

Or — why you shouldn’t try to know everything I’ve really gotten into podcasts lately — they are accessible, they are free, and there’s a ton of them. A couple of days back caught my attention. Podcast authors spread the ideas of how to live meaningful lives with less. Just to make it clear — I’m not even close to being a minimalist. If there’s something to buy, I’m on it. However, one of their episodes, mysteriously named , sucked me in completely. I got so affected by the topic I wasn’t able to get it out of my head ever since. The Minimalists “Access” In the aforementioned episode, hosts Joshua Fields Millburn and Ryan Nicodemus discuss of things versus access to things with Ryan Delk from Omni. The basic idea behind the topic is that people of our generation are trying to own everything while losing access to what they actually need. I see this as a huge issue as well and I believe it is not limited to the items we buy. ownership We will never own everything There is no doubt that it is impossible to own everything for most of us. Yet somehow we are still trying to do that. There was a simple yet very accurate example provided in the podcast. Imagine this — you own a house with a two-car sized garage. You also own a lot of stuff you rarely use — a ladder, a drill, a drone, a DSLR, and lots more. You are obviously keeping all of these things in your garage as you do not need them most of the time. Your garage eventually gets so overloaded that there is no space left for any of your cars. What’s worse — you are about to travel to Greece, you need your DSLR but it is so deep inside of your garage you do not have enough time to unload everything for the access to the camera. This leads to the vacation without quality pictures and that sucks! This perfectly illustrates the paradox of owning more while owning less at the same time. I believe this fits well into our career lives as well. What we own and what we want to own in our jobs is knowledge. Usually, we want to get involved in our businesses as much as possible and the most straightforward way to achieve this is to try to know everything that’s going on around us. We think that by having more information, we will be able to participate in more meetings and become a part of more of the decisions being made. Well — this is not entirely true. Why? Try to re-imagine our garage situation with a few changes — replace the garage with your head and look at every single piece of information you are receiving as a separate item. You will see that we face the same issue — our minds get overloaded and the accessibility of information decreases. Our brains are not designed to remember everything as garages are not designed to fit everything in. One of today’s best-known memory researchers, Elizabeth Loftus, has identified a few reasons why people forget. One of them fits our case very well — . This theory suggests that some memories compete and interfere with other memories, especially when pieces of information are similar to each other. This is often the case if we think about the information we receive while at work. All of it is related to our company, our field, and our daily problems. Due to this, our brains cannot access the specific memory because previously learned information is blocking new information or vice versa. interference theory This and other limitations of our brains brings us back to the paradox when our knowledge increases and decreases at the same time. By knowing more, we reduce the access to our own knowledge more. This is entirely against our initial goal of becoming more involved — we actually find ourselves incapable of participating in the company’s processes because the information we had is suddenly gone. Build an infrastructure Minimalists see the one and only solution to this problem — sharing infrastructure. We can only stop buying so much stuff when there is another way to access the items we need. If there is no easy and cheap way to get DSLR for our trip to Greece, we will buy it and put it in the garage after the trip. However, if we could rent it for a week and even get it delivered to our doors, we would never even consider buying it. For all of this to become a reality, we need to build an infrastructure and it needs only two things to work — service providers or tools to enable us to get access to things and a critical mass of enthusiasts who would use these services instead of buying. And once people stop buying — their garages start to declutter. And this does not mean that people start to make trade-offs of some kind and find themselves lacking things. They actually kind of owns everything now as they have access to every possible item in the world at any time. Same applies to our . With correct infrastructure, we might start knowing more with less information in our heads. We do not become lazy and we do not start to embrace apathy and ignorance — we simply learn how to access information. Knowledge sharing infrastructure can be successfully built with the same ingredients as item sharing infrastructure — people and tools. It would never succeed without the vast majority of your colleagues understanding it and trusting it. A few pioneers might be enough for starters but the mindset has to become global eventually. knowledge I have noticed that knowledge sharing itself is a bit trickier than lending items to other people. It’s easy to get a drone from your room and carefully place it in the trunk of your friend’s car. But when it comes to our knowledge, we have to know how to effectively share not only the information itself but the full context as well. What’s making it even harder is time needed to do that. We might have been collecting information piece by piece for weeks and now trying to share it all at once during an hour-long meeting. This is where correct tooling comes. We need to build and use tools that make sharing and accessing information easier and almost effortless. Like Omni does with item sharing — they eliminate all of the struggles and effort needed to transfer items from one place to another by fully handling the delivery process. We need something like that for our knowledge. Invest in people and dedicate The very first thing you should do in order to build an infrastructure is to embrace high trust culture in your company. You have many smart people who can help you avoid overloading your head with information around you. And as I have discovered, many of them are more than happy to use their “garages” to keep part of the knowledge we own. So, we have to transfer bits of our knowledge to them or let them get the information in the first place and trust them as a reliable storage for it. Sometimes it is hard to get over ourselves and let other people know more about something than we do. But remember this — it is way better to know who knows than to not know. Some of you might ask — how do we keep track of who knows what? Well, you will need to do some experimentation. You will need to find out what kind of process helps you keep everything organized best. One way to achieve that is to dedicate like we do. We have people and/or teams dedicated to specific knowledge. We try to keep at least one person as the owner of some kind of a knowledge. Let it be a business field, an internal service, a tool or even a mindset. What this gives us is the first step for the access to knowledge. If we know who owns the most of the information, we can go to that person or team and get what we need or at least further directions. This helps us to organize knowledge sharing infrastructure and improves information accessibility. You can introduce the same thing to your companies or find your own way to do that. As long as your shared knowledge is organized, there is no wrong way. Find the right tools If you got everything figured out to this point, you have already improved your knowledge sharing process a ton. However, there is always that next step. What we have so far is knowledge spread across the whole company and well organized. But we still need at least two people when we need to access even the tiniest bits of it. And what if the information owner is on vacation? Or worse — what if he’s leaving and a new owner is being dedicated? In some cases, our access is still limited and sharing becomes difficult again. By picking the right tools and getting them used by information owners, we can solve these issues. Essentially, we have to pick a way to get our knowledge digitalized to some point. We need to get our knowledge to the cloud somehow. And there is no one right way to do that. It highly depends on how you share the knowledge, what are your workflows, etc. For example, if you are a software engineering company and most of the information is put to the Jira tasks, you might want to focus on improving your user stories, labeling tasks consistently and linking tasks to the Confluence pages that contain detailed documentation of relevant business requirements. You can also start a decision log and link decisions to the tasks as well. Another example, if your company shares new information via presentations and demos, you could put all of the slides and manuscripts, or recorded presentations to the Google Docs. In both examples, you should always tag owners and stakeholders next to the data items so others could clearly see who knows what. This actually solves both of the issues we’ve found earlier. If the knowledge owner is not available, we are not stuck. We can either find a documented answer to our inquiry, or other stakeholders who are probably available. Also, in the case of knowledge owner leaving, he does not need to transfer all of his knowledge to the new owner. Mostly, he needs to introduce the structure of his documentation and teach new owner how to use it. This process could become extremely fast if every team and every individual in the company would use the same patterns when documenting. However, it should not be forced as separate teams might find unique ways to digitalize their knowledge better than other teams do. Flowchart diagrams are an excellent way to document information for developer teams. But marketing teams will most likely find them useless. So, let every team their own tools as long as they use them. Conclusion Knowledge sharing has always been an important aspect of a modern company. However, people make a mistake and try to keep as much information as possible in their heads. You do not need to know everything, you only need to know how to access information. You also need to know how to keep your knowledge easily accessible. And, the minimalistic approach might be a good way to start.

Forget ownership, focus on access

In an era where digital security is paramount, Shamir's Secret Sharing (SSS) stands as a revolutionary technique, offering robust protection for sensitive data. This cryptographic method, developed by , is not just a tool but a safeguard, ensuring that a secret is not just hidden but also shared securely. Adi Shamir In this article, we delve into the ingenious mechanics of SSS, exploring its foundations in polynomial mathematics and its practical applications in securing data, from corporate secrets to personal credentials. In our case, we will save credentials for the user account, aka mnemonic phrase. This article will be divided into several digestible parts. Ultimately, we will create one service for working with SSN, which includes the following microservices: Auth: for exchanging a JWT token for an internal identifier Generator: This gives the user addresses where he can get his parts of the key Shares: that is responsible for storing shares Metadata:  responsible for storing other information necessary for work Disclaimer: When I was creating this service, I was very much inspired by these guys: , so for production development, I would recommend them more and use a self-written service only if there is a security audit that will analyze each of your actions. Our company uses a self-written solution for several reasons, one is that it is better to have your own solution in conditions of modern uncertainty. We were audited by the Hallward company, and I hope that we will soon be able to open-source our implementation https://web3auth.io/safeauth.html In the first part (part 0), I want to dive into SSS in a basic way and show the basic formulas for working with polynomial mathematics using JavaScript as usual Part 1. will contain works with auth and generator microservices. We will change the user JWT token into our token, check some credentials for using our service, and choose where they will be stored user shares. Part 2. In this chapter, I’m going to dive into the storage part of our service First and most important - safely storing user's share into the blockchain Second, store other user's data into metadata microservice, aka blockchain 2. Principles Shamir's Secret Sharing (SSS), developed by Adi Shamir in 1979, is a cryptographic method that divides a secret into multiple parts, known as "shares." The fundamental idea behind SSS is that the secret can only be reconstructed when a sufficient number of these shares are combined. Here's a breakdown of how it works: : The process begins with creating a polynomial of degree , where is one less than the number of shares required to reconstruct the secret (known as the threshold). For example, if the threshold is 3, a polynomial of degree 2 (quadratic polynomial) is created. The secret is embedded as the polynomial's constant term (coefficient a_0), and the other coefficients (a_1 to ) are randomly generated. Polynomial Construction d d a_d : The polynomial is then evaluated at several points (other than zero) to generate the shares. Each share consists of two parts: the point at which the polynomial is evaluated (x-value) and the corresponding value of the polynomial at that point (y-value). For a threshold of , at least distinct points are chosen, and their corresponding polynomial values are calculated, forming shares. Generation of Shares n n n : These shares are distributed to the participants. No single participant can reconstruct the secret with their share alone. Distribution of Shares : When it's necessary to reconstruct the secret, a minimum of shares (as per the threshold) is brought together. The original polynomial is reconstructed using these shares, typically using a method like Lagrange interpolation. Reconstruction of the Secret n : Once the polynomial is reconstructed, the secret can be found by evaluating the polynomial at zero, which gives the constant term of the polynomial – the original secret. Retrieving the Secret Key Properties of SSS: : The threshold can be set according to the level of security needed. The secret can only be reconstructed if the threshold number of shares is combined. Threshold Flexibility : As long as the threshold is not met, even having access to −1 shares gives no information about the secret, assuming the polynomial coefficients are chosen randomly and securely. Security n : Loss of some shares does not compromise the entire system. The secret can be reconstructed if the threshold number of shares is available. Error Tolerance : Since the secret is not stored in a single location but instead distributed across multiple shares, the risk associated with a single point of failure is mitigated. No Single Point of Failure SSS is beneficial when security and reliability are paramount, such as securing cryptographic keys, safeguarding access to critical digital assets, or other cases you can imagine yourself. Formulation of the problem About number schemas: we can use different threshold values, but we need to know that the more parts of the key we create, the more likely a hacker will obtain the required number of key parts and assemble the original key. In our service, we will use the following schemas for storing data: On the user’s side, we will use scheme 3-2. This means that the private key will be divided into 3 different parts with indexes. And to restore the original private key, we need at least 2 of them. For further convenience, I suggest using the following names for our 3 parts: Social share: this share will be again divided into some parts and stored between different share nodes User share: this share should be stored on the user side (for example, if we use a browser, it can be localStorage or different storage), and we don’t need to encrypt it cloud share. This share can be saved everywhere by a user. We can present this share as a mnemonic phrase or store it on the web, but before we do it, we need to encrypt this share with a password or a different method that allows us to get the original value for the share. As mentioned, the user needs only 2 of 3 shares to work with a private key. For example, if a user has “user share” and “cloud share”, he doesn’t need to get “social share” for work, or if he restores on a new device or browser, he needs “social share” and “cloud share” On the backend for “social share” we will use 5-3. This means that we divide social share into 5 parts, and to restore the original key, we need only 3 of them. And all of them will be saved on different storages. As has been said earlier, our service is built from 4 microservices: Auth, Generator, Shares, and Metadata. Shares service can be stored by different participants of our service. In a perfect world, it should have different providers for deploy different storage like PostgreSQL, Ethereum smart contract, and others (in our solution, we will use only smart contracts), But no one is limited to choose their own storage. How it works First, users need a JWT token; for example, it can be taken from auth with Google or Apple auth services. After we get JWT, we exchange it for an internal JWT token. Why so hard? Good question. One of this service's central ideas is decentralization, which applies to the blockchain and the service for storing private key shares. However, we are not going to share the user's credentials with external services, and for this reason, we change the actual identifiers to internal. Also, we checked the credentials that only allowed OAuth providers to be limited. Now, we will check whether there is a saved key; if not, we suggest creating it. After creation, we divide one of the parts into five according to the same principle and distribute them between services and save the critical index, save another part, the locale, and offer the third part to be held somewhere by the user (there are a lot of options on how this can be done) If we understand that the user has already saved his private key, go to the shares service and get a list of services where the user shares and their indexes are stored. Get shares. After Lagrange interpolation, we have the first part of the share. But we don’t know its index. Here, the metadata service comes to our aid, from which, based on the key we receive, we will receive the index of this very key. The next step is to find the locally stored part or ask the user to provide it. We restore the original private key if we receive the required number of critical parts. A little bit of code Initially, I did not plan the code for this part of the article, but I still decided that the essential functions for working with Lagrange interpolation would look very nice here since it underlies the entire project. export class Polynomial {
    shares: BN[];
    polynomialId: string;

    static initialize(
        privateKey: BN | Buffer | null,
        threshold: number,
    ) {
        const pk = privateKey ? privateKey : randomBytes(32);

        const shares = [new BN(pk)];

        for (let i = 1; i < threshold; i += 1) {
            const share = randomBytes(32);
            shares.push(new BN(share));
        }

        const polynomialId = keccak256(...shares.map(bn => bn.toString()));

        return new Polynomial(shares, polynomialId);
    }

    static fromShares(shares: Share[]) {
        const unsortedPoints = shares.map<PolynomialPoint>(s => ({
            x: new BN(s.shareIndex, 'hex'),
            y: new BN(s.share, 'hex'),
        }));
        const sortedPoints = pointSort(unsortedPoints);
        const polynomial = generateEmptyBNArray(sortedPoints.length);
        for (let i = 0; i < sortedPoints.length; i += 1) {
            const coefficients = interpolationPoly(i, sortedPoints);
            for (let k = 0; k < sortedPoints.length; k += 1) {
                let tmp = new BN(sortedPoints[i].y);
                tmp = tmp.mul(coefficients[k]);
                polynomial[k] = polynomial[k].add(tmp).umod(curveN);
            }
        }

        const polynomialId = keccak256(...polynomial.map(bn => bn.toString()));

        return new Polynomial(polynomial, polynomialId);
    }

    constructor(shares: BN[], polynomialId: string = '') {
        this.shares = shares;
        this.polynomialId = polynomialId;
    }

    getPrivateKey(): BN {
        return this.shares[0];
    }

    getShare(x: string | BN): Share {
        const tmpX = new BN(x, 'hex');
        let xi = new BN(tmpX);
        let sum = new BN(this.shares[0]);
        for (let i = 1; i < this.shares.length; i += 1) {
            sum = sum.add(xi.mul(this.shares[i]));
            xi = xi.mul(tmpX);
        }
        return {
            share: sum.umod(curveN)?.toString('hex')?.padStart?.(64, '0'),
            shareIndex: tmpX.toString('hex'),
            polynomialID: this.polynomialId,
        };
    }
}

const pointSort = (innerPoints: PolynomialPoint[]): PolynomialPoint[] => {
    const pointArrClone = [...innerPoints];
    pointArrClone.sort((a, b) => a.x.cmp(b.x));
    return pointArrClone;
};

const generateEmptyBNArray = (length: number): BN[] =>
    Array.from({length}, () => new BN(0));

const denominator = (i: number, innerPoints: PolynomialPoint[]) => {
    let result = new BN(1);
    const xi = innerPoints[i].x;
    for (let j = innerPoints.length - 1; j >= 0; j -= 1) {
        if (i !== j) {
            let tmp = new BN(xi);
            tmp = tmp.sub(innerPoints[j].x).umod(curveN);
            result = result.mul(tmp).umod(curveN);
        }
    }
    return result;
};

const interpolationPoly = (i: number, innerPoints: PolynomialPoint[]): BN[] => {
    let coefficients = generateEmptyBNArray(innerPoints.length);
    const d = denominator(i, innerPoints);
    if (d.cmp(new BN(0)) === 0) {
        throw new Error('Denominator for interpolationPoly is 0');
    }
    coefficients[0] = d.invm(curveN);
    for (let k = 0; k < innerPoints.length; k += 1) {
        const newCoefficients = generateEmptyBNArray(innerPoints.length);
        if (k !== i) {
            let j: number;
            if (k < i) {
                j = k + 1;
            } else {
                j = k;
            }
            j -= 1;
            for (; j >= 0; j -= 1) {
                newCoefficients[j + 1] = newCoefficients[j + 1]
                    .add(coefficients[j])
                    .umod(curveN);
                let tmp = new BN(innerPoints[k].x);
                tmp = tmp.mul(coefficients[j]).umod(curveN);
                newCoefficients[j] = newCoefficients[j].sub(tmp).umod(curveN);
            }
            coefficients = newCoefficients;
        }
    }
    return coefficients;
}; Main class is which have 2 static methods: Polynomial : Creates a new polynomial with a specified number of shares. If is not provided, it generates a random one. Each share is a random 32-byte number, and the is computed using hash of the shares. initialize(privateKey, threshold) threshold privateKey polynomialId keccak256 : Constructs a polynomial from given shares. It sorts these shares, performs polynomial interpolation, and computes a . fromShares(shares) polynomialId in current scheme used for create unique identifier of our shares polynomialId And 2 Instance Methods: : Returns the first share, which is presumably the private key. getPrivateKey() : Computes and returns a specific share of the polynomial, given an input . getShare(x) x Helper Functions: : Sorts an array of objects based on their values. pointSort(innerPoints) PolynomialPoint x : Generates an array of objects initialized to zero, of the specified . generateEmptyBNArray(length) BN length : Helper for calculating the denominator in the Lagrange polynomial interpolation. denominator(i, innerPoints) : Computes the coefficients for the Lagrange interpolation polynomial for a given point. interpolationPoly(i, innerPoints) I understand that so far it all looks quite crumpled and chaotic, but still at least something =) For a better understanding of the theory, I recommend taking a look at (or another favorite source of information) Wikipedia Conclusion In this article, we took a superficial look at the operating principle of the future service and determined the scope of work that needs to be done in the following articles (tentatively, there will be two more) See you next time =)

Utilizing the Mechanics of Shamir's Secret Sharing Service

Introduction In this article, I would like to share my experience of implementing Silent Push Notifications in an iOS app. The purpose of using Silent Push Notifications was to solve the problem of some services going to sleep when the phone is idle for a long period of time. Or for example, if you have a messenger app and you want the user to be able to access new/updated content and not have to wait for it to download. Silent Push Notifications allowed us to activate the app once every 21 minutes (the minimum value we picked up so that Apple would not grant a temporary ban) and run the services in the background to update. Silent Push Notifications Provide the ability to update the content of your application, make API calls, and perform background tasks. They are sent without activating screen beeping or other visible notifications. In fact, the application goes into an “active” state and is generally no different from a normal startup. Navigation will function, and screens will initialize, although they will not be visible on the screen. All actions called in the “didFinishLaunchingWithOptions” method will also be executed. Silent push notifications wake up your application in the background, allowing time to download data from the server and perform tasks in the background. 1. Setting up Silent Push Notifications First, you need to set up support for Silent Push Notifications in your application. Here is a brief overview of the steps you need to follow. **1.1 Developer Portal
\ Go to the Developer Portal on Apple’s website and make sure Background Modes and Background Fetch support are enabled. **1.2 Provisioning Profile
\ Ensure that the Provisioning Profile (linked to your App ID) includes support for Background Modes and Background Fetch. **1.3 Enabling Remote Notifications
\ In your project in Xcode, open the file AppDelegate.swift and add the following code to the method `application(_:didFinishLaunchingWithOptions:)`: // Registration to receive notifications

let center = UNUserNotificationCenter.current()
center.requestAuthorization(options: [.alert, .badge, .sound]) { (granted, error) in
    if granted {
        DispatchQueue.main.async {
            UIApplication.shared.registerForRemoteNotifications()
        }
    }
} **1.4 Signing & Capabilities
\ Here you need to give permission to use push notifications Scroll to the bottom. And tick the box for “Remote notifications.” Check the rest, depending on your needs. 2. Handling Silent Push Notifications After setting up Silent Push Notifications, you’ll need a handler that will respond to receiving such notifications and trigger a service. Here’s a sample code to add to your AppDelegate.swift func application(_ application: UIApplication, 
     didReceiveRemoteNotification userInfo: [AnyHashable: Any], 
     fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        // Silent Push Notification processing
    if let silentNotification = userInfo["aps"] as? [String: AnyObject], 
       silentNotification["content-available"] as? Int == 1 {
        // Launch of a some service
        SomeManager.shared.startUpdatingAnything()
    }
        // Ending a background operation
    completionHandler(.noData)
} Using the completion handler You only have 30 seconds to execute the background request, and you should call the completionHandler on completion. 3. Backend All the things you should tell your backend developers You must tell the backend which body to send. You can add additional fields at your discretion. For notifications to be silent, you must specify “content-available”: 1. 3.1 {
   “aps” : {
      “content-available” : 1
   },
   “apns-priority” : 5,
   “apns-push-type” : “background”,
} You can read more about it . here If you want to check your notifications without a backend like I do. You will need an application that emulates the backend to check. 3.2 I used . PushNotifications (You can skip this point and go straight to 3.2.1) On the day I published this article, apple introduced a new tool for push notifications 😅 Update! 3.2.1 Push Notifications Console “The new Push Notifications Console makes it easy to send test notifications to Apple devices through the Apple Push Notification service (APNs). You can access logs that provide insights into the delivery process and leverage tools to generate and validate tokens.” — Taken from Apple’s official . website You will not need the p8 file for Push Notifications Console. You simply log in to your account and start testing. It’s also very convenient to use push notifications logging. **3.3 Registration token
\ A registration token is required to send remote notifications. In order to send notifications to remote devices, your application must receive a registration token that the APNs (Apple Push Notification Service) uses to deliver notifications to a specific device. The registration token is a unique identifier tied to the device and your app. When your app is launched, it communicates with APNs to receive a registration token, which can then be sent to your server. Your server uses this token to send notifications to the relevant device. func application(_ application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken:Data) {
   let pushToken = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
   self.yourPushNotificationsService.pushTokenDidReceived(pushNotificationToken: pushToken)
} Once you have a registration token for a particular user, you can send notifications to their remote device via your server, a third-party service (PushNotifications), or Firebase Cloud Messaging. The process of receiving a token and sending notifications is shown in the diagram below. 3.4 Download the .p8 file If your app already has normal push notifications, request the p8 key from the person in charge of push notifications on the backend or a senior/lead iOS developer. a. If you are setting up push notifications for the first time, the following instructions are for you: b. Go to Apple developer account and go to Certificates, Identifiers & Profiles. Go to the Keys section and click on a new key using Add button(+). Choose a unique name for the key and select the Apple Push Notification service (APN) checkbox. Click continue and then confirm. Note and save the key ID. Click Download to generate and save the key. you have to save the key in a secure place because you can’t download the key more than once. Do not rename Auth key file. !!! Please note 4. After installing the app on your physical device When you install the app, be sure to check whether it has Background App Refresh enabled Settings > (scroll down) > Your app > Background App Refresh (enable) 5. Problems and solutions In the process of implementing Silent Push Notifications, I have encountered a few problems which may be useful to you. Apple’s restrictions Apple has a strict limit on how often Silent Push Notifications are sent. 5.1 If several Silent Push Notifications are sent in a row, they may stop reaching the user. To avoid this problem, I used a backend timer to ensure that Silent Push Notifications are only sent once every 21 minutes. Error handling 5.2 It is important to handle possible errors when processing Silent Push Notifications. For example, if a service is already active, new Silent Push Notifications should be ignored to avoid having to run the service continuously and using resources unnecessarily. Optimise battery usage 5.3 Running some services can consume a significant amount of battery power. To minimize this, I have set a limit on the time the service will run after each Silent Push Notification. It is very important to note the following points: The Silent Push does not work in “low power mode.” 5.4 The treatment of the silent-push system depends on several factors: 5.5 Amount of free memory available: when you close an application, the system creates a snapshot of the memory used and assigns points to the Silent Push processing speed. If your application is training a machine learning model or using more than 400 MB of memory, the system may refuse to process the push notification. It is therefore recommended that you try to minimize resource usage and free up memory when switching to background mode. Battery charge level. Frequency of push notifications: the system can handle silent push notifications no more frequently than once every 20 minutes. Time of day: the system can change its attitude towards handling push notifications depending on the time of day. Phone charging status: if the device is charging, the system may be more prone to handle silent push. App crash: if your app crashes, the system will probably not handle the silent push and may assign penalty points. So when you put your phone on charge and get your first silent push the next morning, the system will gradually increase the likelihood of handling push notifications and reduce the penalty points over time. Conclusion The use of silent Push notifications in the app has solved the problem of some services falling asleep when the phone is left for extended periods. Launching the service every 21 minutes after receiving a silent Push notification updates the data in the app, providing a better experience and usability. Share your thoughts about the article. Your comments will help me expand on this research and provide additional material on the topic of the article. This will make it more useful. I would like to dedicate my first technical article to my mentor. I want to express my sincere gratitude for your patience, politeness, and consistency while I was a junior developer. Keep up the great work! Also published . here

A Comprehensive Guide to Silent Push Notifications in iOS: A Step-by-Step Walkthrough

How to create global state management in React applications without side dependencies and unnecessary rerendering First of all, I would like to give special thanks to for inspiring this topic. Jack Herrington has made a significant advance in the tools that help us create global state management. React has pushed us to a new level, and ’s huge boilerplate base and Mobx’s decorators have sunk into oblivion. Creating your own global state management without side dependencies is an easy challenge. React Redux Today, we’ll learn about the hook and add polish to create state management without unnecessarily rendering our components. useSyncExternalStore Application structure Before diving into the code, let’s check the structure of our test application. Each component will iterate with the global store. We need that structure to know which component will be rerendered with the store’s manipulation. Create components To simplify the development process, I will use , and choose React with JavaScript. https://vitejs.dev/ Here are a few steps to get started: Run yarn create vite Choose your project name, framework: , and language variant: React javascript Add the following: and cd project_name yarn Remove in to avoid a second rerender <React.StrictMode> main.jsx Now, let’s create components in . There should be four files with the following names: , , , and . src/components Header.jsx Body.jsx Shares.jsx Footer.jsx Create store In the folder, create the folder and put the following two files into it: and . src store initialState.js index.js For , I put some nested objects and values that will get updated in our application. initialState.js Here’s what the code looks like: export const initialState = {
  name: "John",
  age: 30,
  status: "active",
  details: {
    shares: [
      {
        symbol: "AAPL",
        price: 100,
      },
      {
        symbol: "MSFT",
        price: 200,
      },
      {
        symbol: "GOOG",
        price: 300,
      },
    ],
  },
}; Before creating the function, let’s figure out how the store should work and what we should expect. Similar to Redux, we can use hooks or with and apply them across the application. useState useContexts useReducer Let’s check the implementation with , as shown below: useState import { useState } from "react";
import { initialState } from "./initialState.js";

function createStore() {
  return {
    useStore() {
      return useState(initialState);
    },
  };
}

export default createStore(); As you can see, we’re gonna reuse the across the application. No magic; it’s a simple implementation that clarifies which component will be rerendered after manipulating the store. useState Let’s update our with : App.jsx store.useStore() import "./App.css";
import { Footer } from "./components/Footer/index.jsx";
import store from "./store/index.js";

function App() {
  console.log("App updated");
  const [state, setState] = store.useStore();

  return (
    <div>
      <div>My value: {state.name}</div>
      <div>My value: {state.age}</div>
      <button
        onClick={() =>
          setState((prevStore) => {
            return {
              ...prevStore,
              name: "New name",
              age: 100,
            };
          })
        }
      >
        Update Shares From App
      </button>
      <Footer />
    </div>
  );
} And let’s have access the current state with the following code: Footer.jsx import store from "../../store";

export const Footer = () => {
  const [state] = store.useStore();
  console.log("Footer updated");

  return (
    <footer>
      <p>Footer</p>
      <p>Status: {state.status}</p>
    </footer>
  );
}; Now run the app with and hit the button with an open console. yarn dev Update Shares From App You will see that all of our components are updated. In , we will read from the unmodified store, and this will always return . Footer status active But the problem is we didn’t update any values in because we got an updated object that rerendered the component. To avoid rerendering, we will create a selector and read the store from the hook . Here’s how to do that: Footer useSelector const status = useSelector((state) => state.status); The hook will use the function selector to get the current state from our store. Update components Now, let’s create our remaining components. In each component, we’re gonna add to the name of that component. An alternative solution is to use Google Chrome with React Developer Tools. console.log Here’s what that looks like: Now, will use from the created store. Footer.jsx useSelector import { useSelector } from "../../store";

export const Footer = () => {
  console.log("Footer updated");
  const status = useSelector((state) => state.status);

  return (
    <footer>
      <p>Footer</p>
      <p>Name: {status}</p>
    </footer>
  );
}; For the , we’re gonna only use from store. Header setState import { setState }  from "../../store";

export const Header = () => {
  console.log("Header updated");

  return (
    <header>
      <p>Header</p>
      <button
        onClick={() =>
            setState((prevStore) => {
            return {
              ...prevStore,
              name: "Michael",
              age: 99,
            };
          })
        }
      >
        Update Name And Age from Header
      </button>
    </header>
  );
}; And for the , we’re gonna use both functions to update and read the store. Body import { useSelector, setState } from "../../store";

export const Body = () => {
  const name = useSelector((state) => state.name);
  const age = useSelector((state) => state.age);

  console.log("Body updated");

  return (
    <div className="body">
      <h1>Body</h1>
      <p>Name: {name}</p>
      <p>Age: {age}</p>
      <button
        onClick={() =>
          setState((prevStore) => {
            return {
              ...prevStore,
              name: "Michael",
              age: 99,
            };
          })
        }
      >
        Update Name And Age from Body
      </button>
    </div>
  );
}; And the last section, , will use the store to read data. Shares import { useSelector } from "../../store";

export const Shares = () => {
  const { shares } = useSelector((state) => state.details);

  console.log("Shares updated")

  return (
    <div className="shares">
      <h1>Shares</h1>
      <ul>
        {shares.map(({ symbol, price }) => {
          return (
            <li key={price + symbol}>
              {symbol} : {price}
            </li>
          );
        })}
      </ul>
    </div>
  );
}; Finally, to wrap them all in one application, let’s put the components into . To check the component’s render as well, we’ll use the function. App.jsx App setState import "./App.css";
import { Header } from "./components/Header/index.jsx";
import { Body } from "./components/Body/index.jsx";
import { Shares } from "./components/Shares/index.jsx";
import { Footer } from "./components/Footer/index.jsx";
import { setState } from "./store/index.js";

function App() {
  console.log("App updated");

  return (
    <div>
      <Header />
      <Body />
      <Shares />
      <button
        onClick={() =>
          setState((prevStore) => {
            const newShare = {
              symbol: "XRP",
              price: 1.27472,
            };
            const share = prevStore.details.shares.find(
              (share) => share.symbol === newShare.symbol
            );
            if (!share) {
              return {
                ...prevStore,
                details: {
                  ...prevStore.details,
                  shares: [...prevStore.details.shares, newShare],
                },
              };
            } else {
              return prevStore;
            }
          })
        }
      >
        Update Shares From App
      </button>
      <Footer />
    </div>
  );
}

export default App; To highlight our components, let’s use to add borders. App.css header, footer, .body, .shares {
  border: 1px solid #2c2c2c;
} Store and Listeners To prevent unnecessary redrawing, we need to create a function. This will improve ’s implementation with . notifies React about store changes. Inside , let’s create the function with . useSelector createStore subscribe Subscribe createStore.js subscribe listeners function createStore() {
  let state = initialState;
  const listeners = new Set();

  const subscribe = (listener) => {
    listeners.add(listener);
    return () => listeners.delete(listener);
  };
  // ... With this technic, we can subscribe to our store and notify React about changes. As you can see, this function will also return and allow us to unsubscribe. This technic came from the which lets you subscribe and unsubscribe for changes. To receive notifications about changes, we must create another function, . listeners.delete publisher-subscriber pattern setState const subscribe = (listener) => {
    listeners.add(listener);
    return () => listeners.delete(listener);
  };

return {
  setState(callback) {
    state = callback(state);
    listeners.forEach((listener) => listener(state));
  }
} The listener is always gonna get the current state and set it to . listeners And the last part, the function, uses the hook and lets us get all the changes from our store. createStore useSelector useSelector(selector) {
  return selector(state)
}, But in this case, we are not gonna be able to get updated data because we are not subscribed to our changes from the state. To fix that, we have to apply the function to the hook from React. subscribe useSyncExternalStore This hook takes three arguments: , , and to render on the server side. subscribe getSnapshot getServerSnapshot useSelector(selector) {
  return useSyncExternalStore(
    subscribe,
    () => selector(state)
  );
} The function will register a callback to notify us about store changes. And combining and will return our store’s current state. In this case, we won’t be using server-side rendering for a while. subscribe () => selector(state) getSnapshot import { useSyncExternalStore } from "react";
import { initialState } from "./initialState.js";

function createStore() {
  let state = initialState;
  const listeners = new Set();

  const subscribe = (listener) => {
    listeners.add(listener);
    return () => listeners.delete(listener);
  };

  return {
    setState(callback) {
      state = callback(state);
      listeners.forEach((listener) => listener(state));
    },
    useSelector(selector) {
      return useSyncExternalStore(subscribe, () => selector(state));
    },
  };
}

const store = createStore();

export const { setState, useSelector } = store; Now, let’s run our server and check how the components will re-render. You will see something like this: yarn dev By clicking on the button, , the store’s data will update. This data is used only in , and that’s the only component that has to be rerendered because other components didn’t receive updates. Update Shares From App Shares.jsx Now, click on , and you will see that updates only happen in . And if you click again, nothing is gonna rerender because the data is the same. This is absolutely fine. Update Name And Age from Header Body.jsx What About Server-Side Rendering To sync the server-side data and store, we need to improve the function. To test that, I suggest you create a application and apply our created components to the view. While you’re at it, add the function to provide additional changes to the store’s data. createStore Next JS index getServerSideProps export async function getServerSideProps() {
  return {
    props: {
      initialState: {
        ...initialState,
        name: "Black",
      },
    },
  };
} To apply new store data from our view, we have to initialize our store with server data from . props export default function Home(props) {
  console.log("Home updated");
  store.init(props.initialState);

  return (
    <div>
      <Header />
      <Body />
      <Shares />
      <Footer />
    </div>
  );
} The function should get a new state and apply that to our current state. Here’s what that looks like: init import { useSyncExternalStore } from "react";
import { initialState } from "./initialState.js";

function createStore() {
  let state = initialState;
  let listeners = new Set();
  let isInitialized = false;

  // ...

  return {
    init: (initState) => {
      if (!isInitialized) {
        state = initState;
      }
    },
    // ...
  };
}

const store = createStore();

export default store;
export const { setState, useSelector } = store; The assignment will happen only once for the . view Conclusion It’s fascinating! With one function, we solved the global state management problem without any boilerplate code or unnecessary re-rendering. The hook helps us synchronize our store with our React application’s state. Just one function can connect our global store’s values across the entire application. useSyncExternalStore Resources GitHub Repo: https://github.com/antonkalik/global-store Also published here.

Hacking Dependency Free React State Management 

This is our final post in our three-part series demonstrating how to use the Salesforce Mobile SDK to build an Android app that works with the Salesforce platform. , we showed you how to connect to your org. showed you how to edit and add data to your org from your app. This post will show you how to synchronize data from your Salesforce org to your mobile device and handle scenarios such as network loss. Let’s get right into it! In our first post Our second post Working with Mobile Sync One of the hardest aspects of mobile development is dealing with data synchronization. How do you handle the situation when you need to add a new broker, but you’re offline? Or what if two agents are updating the same broker—how can you handle the merging of those two changes? With the Salesforce Mobile SDK, these real-world issues are handled for you by a system called . Mobile Sync has you map your phone’s local data to the data in Salesforce; it also requires you to define operations for fetching and pushing data—what it calls and . Mobile Sync syncDown syncUp Define the shape of data to be synced To get started with Mobile Sync, create a file in called : res/raw brokerstore.json {
 "soups": [
   {
     "soupName": "brokers",
     "indexes": [
       { "path": "Id", "type": "string"},
       { "path": "Name", "type": "string"},
       { "path": "Title__c", "type": "string"},
       { "path": "Phone__c", "type": "string"},
       { "path": "Mobile_Phone__c", "type": "string"},
       { "path": "Email__c", "type": "string"},
       { "path": "Picture__c", "type": "string"},
       { "path": "__local__", "type": "string"},
       { "path": "__locally_created__", "type": "string"},
       { "path": "__locally_updated__", "type": "string"},
       { "path": "__locally_deleted__", "type": "string"},
       { "path": "__sync_id__", "type": "integer"}
     ]
   }
 ]
} This file defines the shape of the data on your phone, as well as some additional metadata that’s necessary for the sync. Next, create a file called : brokersync.json {
 "syncs": [
   {
     "syncName": "syncDownBrokers",
     "syncType": "syncDown",
     "soupName": "brokers",
     "target": {"type":"soql", "query":"SELECT Name, Title__c, Phone__c, Mobile_Phone__c, Email__c, Picture__c FROM Broker__c LIMIT 10000"},
     "options": {"mergeMode":"OVERWRITE"}
   },
   {
     "syncName": "syncUpBrokers",
     "syncType": "syncUp",
     "soupName": "brokers",
     "target": {"createFieldlist":["Name", "Title__c", "Phone__c", "Mobile_Phone__c", "Email__c", "Picture__c"]},
     "options": {"fieldlist":["Id", "Name", "Title__c", "Phone__c", "Mobile_Phone__c", "Email__c", "Picture__c"], "mergeMode":"LEAVE_IF_CHANGED"}
   }
 ]
} These are the operations that Mobile Sync will use when syncing data down and up. The code to complete the Mobile Sync process depends on several factors, such as when you want to perform a synchronization, as well as hooking into the Android event cycle when a device loses (and regains) connectivity. The following code samples will show you a complete example of what needs to happen to get synchronization working, but they should be considered high-level concepts, and not necessarily production-ready enterprise-grade code. Set up periodic sync With that said, let’s take a look at how to implement synchronization. First, add this line to the end of our method in : onResume(client: RestClient) MainActivity.kt setupPeriodicSync(); Next, we’ll add a new variable and a new function to the class: MainActivity private val SYNC_CONTENT_AUTHORITY =
   "com.salesforce.samples.mobilesyncexplorer.sync.brokersyncadapter"

private fun setupPeriodicSync() {
   val account = MobileSyncSDKManager.getInstance().userAccountManager.currentAccount

   ContentResolver.setSyncAutomatically(account, SYNC_CONTENT_AUTHORITY, true)
   ContentResolver.addPeriodicSync(
       account, SYNC_CONTENT_AUTHORITY,
       Bundle.EMPTY, 10
   )
} Since we’re using in our function, let’s make sure to import it by adding this line alongside the other import statements near the top of : ContentResolver MainActivity.kt import.android.content.ContentResolver We have defined two methods that trigger synchronization. will run a sync every seconds. This is much too frequent for a production environment, but we’ll set it this way for demonstration purposes. setupPeriodicSync 10 Mapping sync operations to our data and UI We will show the next few code samples all at once, and discuss what they’re doing afterward. In , create a new file called and paste these lines into it: app/java/com.example.sfdc BrokerSyncAdapter.kt package com.example.sfdc

import android.accounts.Account
import android.content.AbstractThreadedSyncAdapter
import android.content.ContentProviderClient
import android.content.Context
import android.content.SyncResult
import android.os.Bundle
import com.salesforce.androidsdk.accounts.UserAccount
import com.salesforce.androidsdk.accounts.UserAccountManager
import com.salesforce.androidsdk.app.SalesforceSDKManager
import com.example.sfdc.BrokerListLoader

class BrokerSyncAdapter
   (
   context: Context?, autoInitialize: Boolean,
   allowParallelSyncs: Boolean
) :
   AbstractThreadedSyncAdapter(context, autoInitialize, allowParallelSyncs) {
   override fun onPerformSync(
       account: Account, extras: Bundle, authority: String,
       provider: ContentProviderClient, syncResult: SyncResult
   ) {
       val syncDownOnly = extras.getBoolean(SYNC_DOWN_ONLY, false)
       val sdkManager = SalesforceSDKManager.getInstance()
       val accManager = sdkManager.userAccountManager
       if (sdkManager.isLoggingOut || accManager.authenticatedUsers == null) {
           return
       }
       if (account != null) {
           val user = sdkManager.userAccountManager.buildUserAccount(account)
           val contactLoader = BrokerListLoader(context, user)
           if (syncDownOnly) {
               contactLoader.syncDown()
           } else {
               contactLoader.syncUp() // does a sync up followed by a sync down
           }
       }
   }

   companion object {
       // Key for extras bundle
       const val SYNC_DOWN_ONLY = "syncDownOnly"
   }
} Now, in that same folder, create with these lines: BrokerListLoader.kt package com.example.sfdc

import android.content.AsyncTaskLoader
import android.content.Context
import android.content.Intent
import android.util.Log
import com.salesforce.androidsdk.accounts.UserAccount
import com.salesforce.androidsdk.app.SalesforceSDKManager
import com.salesforce.androidsdk.mobilesync.app.MobileSyncSDKManager
import com.salesforce.androidsdk.mobilesync.manager.SyncManager
import com.salesforce.androidsdk.mobilesync.manager.SyncManager.MobileSyncException
import com.salesforce.androidsdk.mobilesync.manager.SyncManager.SyncUpdateCallback
import com.salesforce.androidsdk.mobilesync.util.SyncState
import com.salesforce.androidsdk.smartstore.store.QuerySpec
import com.salesforce.androidsdk.smartstore.store.SmartSqlHelper.SmartSqlException
import com.salesforce.androidsdk.smartstore.store.SmartStore
import org.json.JSONArray
import org.json.JSONException
import java.util.ArrayList

class BrokerListLoader(context: Context?, account: UserAccount?) :
   AsyncTaskLoader<List<String>?>(context) {
   private val smartStore: SmartStore
   private val syncMgr: SyncManager
   override fun loadInBackground(): List<String>? {
       if (!smartStore.hasSoup(BROKER_SOUP)) {
           return null
       }
       val querySpec = QuerySpec.buildAllQuerySpec(
           BROKER_SOUP,
           "Name", QuerySpec.Order.ascending, LIMIT
       )
       val results: JSONArray
       val brokers: MutableList<String> = ArrayList<String>()
       try {
           results = smartStore.query(querySpec, 0)
           for (i in 0 until results.length()) {
               brokers.add(results.getJSONObject(i).getString("Name"))
           }
       } catch (e: JSONException) {
           Log.e(TAG, "JSONException occurred while parsing", e)
       } catch (e: SmartSqlException) {
           Log.e(TAG, "SmartSqlException occurred while fetching data", e)
       }
       return brokers
   }

   @Synchronized
   fun syncUp() {
       try {
           syncMgr.reSync(
               SYNC_UP_NAME
           ) { sync ->
               if (SyncState.Status.DONE == sync.status) {
                   syncDown()
               }
           }
       } catch (e: JSONException) {
           Log.e(TAG, "JSONException occurred while parsing", e)
       } catch (e: MobileSyncException) {
           Log.e(TAG, "MobileSyncException occurred while attempting to sync up", e)
       }
   }

   /**
    * Pulls the latest records from the server.
    */
   @Synchronized
   fun syncDown() {
       try {
           syncMgr.reSync(
               SYNC_DOWN_NAME
           ) { sync ->
               if (SyncState.Status.DONE == sync.status) {
                   fireLoadCompleteIntent()
               }
           }
       } catch (e: JSONException) {
           Log.e(TAG, "JSONException occurred while parsing", e)
       } catch (e: MobileSyncException) {
           Log.e(TAG, "MobileSyncException occurred while attempting to sync down", e)
       }
   }

   private fun fireLoadCompleteIntent() {
       val intent = Intent(LOAD_COMPLETE_INTENT_ACTION)
       SalesforceSDKManager.getInstance().appContext.sendBroadcast(intent)
   }

   companion object {
       const val BROKER_SOUP = "brokers"
       const val LOAD_COMPLETE_INTENT_ACTION =
           "com.salesforce.samples.mobilesyncexplorer.loaders.LIST_LOAD_COMPLETE"
       private const val TAG = "BrokerListLoader"
       private const val SYNC_DOWN_NAME = "syncDownBrokers"
       private const val SYNC_UP_NAME = "syncUpBrokers"
       private const val LIMIT = 10000
   }

   init {
       val sdkManager = MobileSyncSDKManager.getInstance()
       smartStore = sdkManager.getSmartStore(account)
       syncMgr = SyncManager.getInstance(account)
       // Setup schema if needed
       sdkManager.setupUserStoreFromDefaultConfig()
       // Setup syncs if needed
       sdkManager.setupUserSyncsFromDefaultConfig()
   }
} What did we just do? Each file has a specific role, and while the objects and fields will certainly be different for your app, the functions and philosophies of these classes are the same: is responsible for mapping the sync operations you defined in with the Kotlin code that will actually perform the work. Notice that there are and methods that use the Mobile SDK’s to load the JSON files and communicate back and forth with Salesforce. BrokerListLoader brokersync.json syncUp syncDown SyncManager can perhaps best be thought of as the code that’s responsible for scheduling the synchronization. That is, it’s the entry point for , and can be called by UI elements (such as during a refresh button click) or Android system events (such as connectivity loss). BrokerSyncAdapter BrokerListLoader Lastly, we need to add one line to our file (in ). Our new sync functionality will need special Android permissions, which we ask the user to allow upon app installation at runtime. Add the following line with to the end of your manifest: AndroidManifest.xml app/manifests WRITE_SYNC_SETTINGS <uses-permission android:name="com.example.sfdc.C2D_MESSAGE" />
  <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS" />
</manifest> Testing sync Our last step is to test that mobile sync works. With the emulator running, you should be logged in and see a list of brokers. This list should mirror the broker list that you see in your web browser on your local machine. In your web browser, edit one of the broker names, and save that change. Then, in your emulator, you can power off the phone or switch to another application and then switch back to your . You should see your list of broker names updated with the change you made in your browser: sfdc-mobile-app And that’s all! Again, this is just a foundational building block for you to learn from. In just about 150 lines of code, we’ve devised a solution for a rather complicated series of moving parts: Mapping Salesforce custom objects to JSON Setting up a timer to periodically sync data back and forth between a Salesforce org and a mobile device Handling errors (and recovering from issues) around network connectivity Conclusion The Salesforce Mobile SDK makes it tremendously easy to connect mobile devices with Salesforce data. In this post, you learned how to query and manipulate data from your phone, and saw the results reflected instantaneously on Salesforce. You also learned about Mobile Sync and its role in anticipating issues with connectivity. And yet, with all of this information, there’s still that the Salesforce Mobile SDK can do. Take a look at the on working with the SDK. Or, if you prefer to do more coding, there are to keep you busy. We can’t wait to see what you build! so much more complete documentation plenty of Trailhead tutorials

Building a Kotlin Mobile App with the Salesforce SDK: Synchronizing Data

Some of you must have a range of indices being published on the bulletin and newspapers to help investors in making decisions. While some still cannot wrap their heads around the strange list of numbers that are being read on TV. Whatever the category of people you belong, it is important to understand what it is, how it works and how vital it is for your investment and management decisions. Thus, Ezzat Daniel Nesseim is here to walk you through what the Australian share market All ordinaries is all about. Read on! What is The All ordinaries index? Fondly referred to as All Ords, All Ordinaries is the summary of the measure of the largest 500 companies listed on the Australian stock exchange market. It was developed in 1980 and it is the oldest official share price index in Australia. It is considered as the standard upon which the overall sharemarket performance and trends are determined. In the economic context, it provides information on and serves as an indicator of how people react to situations and events. market trends When it was established, All Ords was given a base value index of 500 points. this means if the current index value is at 5000 points, Australian Share Market Today in All Ords has grown tenfold. The All Ords was restructured to include 500 corporations baes on market capitalization on the 3rd of April, 200o. In March 2019, it accounted for 92% of the value of all the shares on the Australian Stock Exchange (ASX). However, with the introduction of a new benchmark index such as ASX 200, this premiered index has lost significant value. What is The ASX 200? Many investors prefer to use different indices because it covers 200 largest companies-, unlike all ordinaries 500. As the name suggests, ASX 200 is a benchmark index that tracks the performance of 200 companies based on floated-adjusted market capitalization. The value used to measure the performance of their shares is  313.3. ASX 200 was started on March 31, 2000, and it is widely referred to as the leading stock exchange index in Australia. What about the dividend? The dividend paid to shareholders is not inclusive in the All Ordinaries index. Hence, it is not a complete reflection of all the total returns made by investors during the period. The All Ordinaries Total Return Index (XAOA), unlike all ordinaries, includes all cash dividend reinvested from the ex-dividend dates. It, therefore, provides a complete reflection of the return made on the investment. However, XAOA is not an index used on a daily basis and it is used as a guide for long term investment. What are the requirements for All-Ordinaries Index Inclusion? To be a part of the 500 biggest company on all ordinances index, a company must have a market value of at least 0.2 percent. The average turn over rate on ASX must be at least 0.5 percent which must be maintained every month.  The average daily market from 6 months will be considered and it must meet the minimum benchmark index set by ASX The ranking of the members on the Australian Securities Exchange (ASX) is based on market capitalization. All ordinaries have does not consider liquidity. The above criteria are for inclusion and do not extend to the continuity of the membership. If a company is removed from being a member, the company has to wait until the next rebalance which is conducted annually in March. To ensure that the companies included do not fall below the requirements, updates of the portfolio are conducted every month. How is the All Ordinaries index calculated? As stated earlier, the All Ordinaries weighted index is on market capitalization. To calculate the market cap of a company, the total number of shares issued by a company is multiplied by the current share price. This value will now stand as the parameter of the percentage weight of that company. Investors and wealth planners prefer to use other indexes such as the All Accumulation index. This is because this includes dividends and there are not many stocks to be considered. “if you are looking to have a good return on your investment, share market indices will provide a good guide.” says, , a successful investor with an-depth knowledge of wealth management of leading Australia’s banks. Ezzat Daniel Nesseim Compare the longer-term price movements and get a clearer picture of the trends, the economic situation and how your investments are holding up- Ezzat Daniel Nesseim advises.

SHARESMART

sharesmart.ca

-- employees

Since n.d.

COMPANY RANKING

SHARESMART

EVERGREEN INDEX #9802

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

ShareSmart WIKI

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

SHARESMART

sharesmart.ca

-- employees

Since n.d.

COMPANY RANKING

SHARESMART

EVERGREEN INDEX #9802

RELATED COMPANIESRANK

STORIES ABOUT SHARESMART

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

ShareSmart WIKI

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