PayStand

paystand

Startups of The Year 2023 Winners: North America 

In October 2020, Stripe (an American financial service and software as a service company headquartered in San Francisco) acquired Paystack for a rumoured amount of about $200M. Paystack is a technology company solving payments problems for ambitious businesses. Their mission is to help businesses in Africa become profitable, envied, and loved. In this episode of , I sit down with the CTO of Paystack, Ezra Olubi to discuss his background, his work before Paystack, the experiences acquired through the years and more. He shares how Paystack started, why he said Yes to the idea, how Paystack raised money and eventually got acquired; his biggest life lessons and favourite failures and even talks about his personal style. It’s one for the books. #FoundersConnect Learn From the CTO of Paystack https://www.youtube.com/watch?v=MA2OLvxT4oU Video timestamps 0:23 - How would you describe Ezra? 1:16 - How was growing up for you? What experiences shaped you? 3:53 - From childhood till now, what has changed about your views on Religion? 4:50 - What was it about the Paystack idea that gave him the confidence to build it, and with Shola? 9:54 - The ways in which Ezra and Shola complement each other. 11:48 - How do you manage all the people and teams in Paystack? 13:02 - Biggest lesson and favourite failure as a CTO? 15:15 - What mistakes did you make? 17:37 - How hard was it raising money in 2016 vs now? 22:19 - If you were going to do it all over again, what is one thing you will do differently? 23:28 - What friendships have had the most impact on you? 24:39 - How would you describe your style? 25:47 - Have you had any struggles with how people perceive you, and your style? 27:50 - Do you have a lot of male friends? 28:32 - Were you always androgynous? 28:56 - Do you think your style would evolve? 30:04 - Fun questions, bucket list, social media, cereal, favourite city, etc. 32:14 - What should one look for in a technical cofounder if they want to start a company?

Interview with Ezra Olubi, CTO of Paystack, on Getting Acquired by Stripe

Event Time Processing with Flink and Beam - Power of Real time Analytics

How Blockchain APIs and RPC Nodes Work

Data plays a crucial role in crypto, serving as a tool to monitor real-time changes in prices, markets, and various other information. For many crypto professionals, data is the lifeblood of their work. Before we explore the different types of crypto APIs available, let's first break down what an API is and how it works. What Are APIs? API stands for Application Programming Interface, and it's a software intermediary that allows applications to communicate seamlessly with each other, It serves as the messenger between two applications. You as the engineer will send a request, and the API will take your request to the provider and deliver back a response. API communication could be two servers going back and forth, or an application communicating with an operating system. Users interact with APIs almost every day, through social media, email, and more. APIs serve a broad purpose, it all depends on use cases. Some companies' whole business models are based on providing APIs for developers to build products with; companies as Twilio, Sendbird, Stripe, PayStack, and Anchor. These services created the "API Economy" which allows developers to easily integrate the features these services offer into their products, often for profit. Stripe for payment integration, Sendbird for email integration, Anchor for Financial systems, and more. Other providers can use APIs for tasks as basic as interacting with databases. Developers on the other hand often don't have to create from scratch, the reusability of APIs enables developers to make complex code reusable, cutting out repetition and up-ing development time for more efficient processes. Thanks to APIs, developers don't have to reinvent the wheel, and can easily get complex processes done with fewer lines of code each time they want to create a project. How Exactly Do APIs Work? APIs typically sit between the application and the server. When the developer or user tells the API to perform an action, the application uses the API to send a request that carries specific instructions for the intended action. Assume you're in a restaurant to make an order for food or drink. You tell the waiter (the API) what you want. The waiter relays that order(API call) to the kitchen or chefs at the back(server). You save a lot of time by getting your meal without having to cook it, you are less concerned with the inner workings of the kitchen (server), all you need to know is how to order it, and in the process, you are saving a boat load of time. This is a simple analogy to help you understand just what is going on with APIs. The application knows little about the server, and its inner workings, it just understands how to work with the data it receives from the server. It is important to know that APIs aren't limited to the web alone, practically every machine out there makes use of one API or the other, either commercially or internally within companies. Exploring Crypto APIs Crypto APIs allow developers to access market data, transactions, and blockchains. These APIs enable the creation of applications with tightly integrated features, providing seamless access to vital information and functionality. Cryptocurrency APIs are also extremely important because they save the developers a lot of time, without them, developers would have to manually gather the data which is hard work. These APIs have led to a new wave of crypto-related services that has helped increase adoption globally. Types of Cryptocurrency APIs Of course, there is a wide variety of crypto APIs, each with unique features. However, these are the most common types of crypto APIs. Price APIs: This is the most common type of API, as they provide real-time data on cryptocurrency prices. These APIs can be used by developers for regular users to keep their eyes glued to the market movements of their favorite crypto projects.


Transaction APIs: The whole essence of blockchain is openness and trust, this is why transactions need to be documented. Transaction APIs make it easy to keep a record of every transaction that occurs on a specific blockchain for record purposes.


Blockchain APIs: These APIs provide access to the blockchain itself for developers to build upon. Basic functionality of Crypto Data APIs When we talk about data APIs, we are primarily talking about price. Now that we've explored the basics of crypto APIs and the types. We can elaborate on the functionalities of these crypto data APIs. Data APIs provide real-time price updates and historical data, allowing users to make informed decisions about buying, selling, and trading cryptocurrencies. The APIs are designed to be fast, reliable, and easy to use with a variety of endpoints and parameters to customize the data returned. It would include support for multiple exchanges, coins, tokens, and most importantly trading data. Features of Crypto Data APIs These are the features that a proper data API needs to have: Real-Time Price Update: This is the most critical feature, real-time price update has to be available. The crypto market is extremely volatile, so the price changes have to happen in real-time to allow users to make important decisions on the fly. Historical Data: Historical data is extremely important for analysis purposes. Each coin requires historical data from its launch till data for so many patterns and trends to be drawn. Data Aggregation: A crypto data API often aggregates data from multiple exchanges, making sure users have comprehensive data to study the market progression. Traders especially value this feature for study and comparison purposes. Popular Crypto Data APIs CoinGecko: The CoinGecko data market APIs are a set of robust APIs that deliver several data such as price, volume, market cap, and exchange data. CoinMarketCap: The CoinMarketCap API is an enterprise-grade cryptocurrency API for all crypto data use cases. The API architecture implements RESTful JSON endpoints that allow data scientists, and enterprise business platforms. CoinAPI: Similar to the above two it offers market data through unified data APIs, although less robust. Who is the king of the (Crypto Data API) hill? For me, CoinGecko edges it mainly due to its extensive coverage and trusted reputation. Tracking over 2.4 million cryptocurrencies across 140 networks and 1,000 DEXes, CoinGecko provides comprehensive data that meets the needs of any developer. It’s no wonder industry leaders like Metamask, Etherscan, Chainlink, and many others rely on CoinGecko for accurate and reliable market data. Conclusion The crypto APIs are pivotal to the whole Web3 ecosystem, they allow developers to create applications that interact with different blockchain networks. However, it is important to consider security, pricing, and the available features if you're planning to use any of these APIs in your crypto project. Data plays a crucial role in crypto , serving as a tool to monitor real-time changes in prices, markets, and various other information. For many crypto professionals, data is the lifeblood of their work. crypto Before we explore the different types of crypto APIs available, let's first break down what an API is and how it works. What Are APIs? API stands for Application Programming Interface, and it's a software intermediary that allows applications to communicate seamlessly with each other, It serves as the messenger between two applications. You as the engineer will send a request, and the API will take your request to the provider and deliver back a response. API API communication could be two servers going back and forth, or an application communicating with an operating system. Users interact with APIs almost every day, through social media, email, and more. APIs serve a broad purpose, it all depends on use cases. Some companies' whole business models are based on providing APIs for developers to build products with; companies as Twilio , Sendbird , Stripe , PayStack , and Anchor . These services created the "API Economy" which allows developers to easily integrate the features these services offer into their products, often for profit. Stripe for payment integration, Sendbird for email integration, Anchor for Financial systems, and more. Twilio Sendbird Stripe PayStack Anchor Other providers can use APIs for tasks as basic as interacting with databases. Other providers can use APIs for tasks as basic as interacting with databases. Developers on the other hand often don't have to create from scratch, the reusability of APIs enables developers to make complex code reusable, cutting out repetition and up-ing development time for more efficient processes. Thanks to APIs, developers don't have to reinvent the wheel, and can easily get complex processes done with fewer lines of code each time they want to create a project. How Exactly Do APIs Work? APIs typically sit between the application and the server. When the developer or user tells the API to perform an action, the application uses the API to send a request that carries specific instructions for the intended action. Assume you're in a restaurant to make an order for food or drink. You tell the waiter (the API) what you want. The waiter relays that order(API call) to the kitchen or chefs at the back(server). You save a lot of time by getting your meal without having to cook it, you are less concerned with the inner workings of the kitchen (server), all you need to know is how to order it, and in the process, you are saving a boat load of time. This is a simple analogy to help you understand just what is going on with APIs. The application knows little about the server, and its inner workings, it just understands how to work with the data it receives from the server. It is important to know that APIs aren't limited to the web alone, practically every machine out there makes use of one API or the other, either commercially or internally within companies. It is important to know that APIs aren't limited to the web alone, practically every machine out there makes use of one API or the other, either commercially or internally within companies. Exploring Crypto APIs Crypto APIs allow developers to access market data, transactions, and blockchains. These APIs enable the creation of applications with tightly integrated features, providing seamless access to vital information and functionality. Cryptocurrency APIs are also extremely important because they save the developers a lot of time, without them, developers would have to manually gather the data which is hard work. These APIs have led to a new wave of crypto-related services that has helped increase adoption globally. Types of Cryptocurrency APIs Of course, there is a wide variety of crypto APIs, each with unique features. However, these are the most common types of crypto APIs. Price APIs: This is the most common type of API, as they provide real-time data on cryptocurrency prices. These APIs can be used by developers for regular users to keep their eyes glued to the market movements of their favorite crypto projects. Transaction APIs: The whole essence of blockchain is openness and trust, this is why transactions need to be documented. Transaction APIs make it easy to keep a record of every transaction that occurs on a specific blockchain for record purposes. Blockchain APIs: These APIs provide access to the blockchain itself for developers to build upon. Price APIs: This is the most common type of API, as they provide real-time data on cryptocurrency prices. These APIs can be used by developers for regular users to keep their eyes glued to the market movements of their favorite crypto projects. Price APIs : This is the most common type of API, as they provide real-time data on cryptocurrency prices. These APIs can be used by developers for regular users to keep their eyes glued to the market movements of their favorite crypto projects. Price APIs Transaction APIs: The whole essence of blockchain is openness and trust, this is why transactions need to be documented. Transaction APIs make it easy to keep a record of every transaction that occurs on a specific blockchain for record purposes. Transaction APIs : The whole essence of blockchain is openness and trust, this is why transactions need to be documented. Transaction APIs make it easy to keep a record of every transaction that occurs on a specific blockchain for record purposes. Transaction APIs Blockchain APIs: These APIs provide access to the blockchain itself for developers to build upon. Blockchain APIs : These APIs provide access to the blockchain itself for developers to build upon. Blockchain APIs Basic functionality of Crypto Data APIs When we talk about data APIs, we are primarily talking about price. Now that we've explored the basics of crypto APIs and the types. We can elaborate on the functionalities of these crypto data APIs. Data APIs provide real-time price updates and historical data, allowing users to make informed decisions about buying, selling, and trading cryptocurrencies. The APIs are designed to be fast, reliable, and easy to use with a variety of endpoints and parameters to customize the data returned. It would include support for multiple exchanges, coins, tokens, and most importantly trading data. Features of Crypto Data APIs These are the features that a proper data API needs to have: These are the features that a proper data API needs to have: Real-Time Price Update: This is the most critical feature, real-time price update has to be available. The crypto market is extremely volatile, so the price changes have to happen in real-time to allow users to make important decisions on the fly. Real-Time Price Update : This is the most critical feature, real-time price update has to be available. The crypto market is extremely volatile, so the price changes have to happen in real-time to allow users to make important decisions on the fly. Real-Time Price Update Historical Data: Historical data is extremely important for analysis purposes. Each coin requires historical data from its launch till data for so many patterns and trends to be drawn. Historical Data : Historical data is extremely important for analysis purposes. Each coin requires historical data from its launch till data for so many patterns and trends to be drawn. Historical Data Data Aggregation: A crypto data API often aggregates data from multiple exchanges, making sure users have comprehensive data to study the market progression. Traders especially value this feature for study and comparison purposes. Data Aggregation : A crypto data API often aggregates data from multiple exchanges, making sure users have comprehensive data to study the market progression. Traders especially value this feature for study and comparison purposes. Data Aggregation Popular Crypto Data APIs CoinGecko: The CoinGecko data market APIs are a set of robust APIs that deliver several data such as price, volume, market cap, and exchange data. CoinGecko : The CoinGecko data market APIs are a set of robust APIs that deliver several data such as price, volume, market cap, and exchange data. CoinGecko CoinMarketCap: The CoinMarketCap API is an enterprise-grade cryptocurrency API for all crypto data use cases. The API architecture implements RESTful JSON endpoints that allow data scientists, and enterprise business platforms. CoinMarketCap : The CoinMarketCap API is an enterprise-grade cryptocurrency API for all crypto data use cases. The API architecture implements RESTful JSON endpoints that allow data scientists, and enterprise business platforms. CoinMarketCap CoinAPI: Similar to the above two it offers market data through unified data APIs, although less robust. CoinAPI : Similar to the above two it offers market data through unified data APIs, although less robust. CoinAPI Who is the king of the (Crypto Data API) hill? For me, CoinGecko edges it mainly due to its extensive coverage and trusted reputation. Tracking over 2.4 million cryptocurrencies across 140 networks and 1,000 DEXes, CoinGecko provides comprehensive data that meets the needs of any developer. It’s no wonder industry leaders like Metamask, Etherscan, Chainlink, and many others rely on CoinGecko for accurate and reliable market data. Conclusion The crypto APIs are pivotal to the whole Web3 ecosystem, they allow developers to create applications that interact with different blockchain networks. However, it is important to consider security, pricing, and the available features if you're planning to use any of these APIs in your crypto project.

Crypto Data APIs: The Invisible Force Driving Market Intelligence 

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Z. Jennings, Astrophysics Group, Keele University, Staffordshire, ST5 5BG, UK (E-mail: z.jennings@keele.ac.uk);
(2) J. Southworth, Astrophysics Group, Keele University, Staffordshire, ST5 5BG, UK;
(3) K. Pavlovski, Department of Physics, Faculty of Science, University of Zagreb, 10000 Zagreb, Croatia;
(4) T. Van Reeth, Institute of Astronomy, KU Leuven, Celestijnenlaan 200D, B-3001 Leuven, Belgium. Table of Links Abstract and Intro
Observation
Orbital Ephemeris
Radial Velocity Analysis
Spectral Analysis
Analysis of the Light Curve
Physical Properties
Asteroseismic Analysis
Discussion
Conclusion, Data Availability, Acknowledgments, and References
Appendix A: Ephemeris Determination
Appendix B: Iteratively Prewhitened Frequencies
Appendix C: Detected Tidally Perturbed Pulsations 6 ANALYSIS OF THE LIGHT CURVE The components of KIC 9841944 are close to each other and thus have a significant tidal deformation. We therefore sought to model the light curve using a code that is based on Roche geometry. We selected the Wilson-Devinney (WD) code (Wilson & Devinney 1971; Wilson 1979) for this, and used the 2004 version of the code driven using the JKTWD wrapper (Southworth et al. 2011). The user guide which accompanies the WD code (Wilson & Van Hamme 2004) includes a description of all input and output quantities discussed below. The WD code is computationally expensive and is not suited to the analysis of the full 500 000 short-cadence datapoints in one step. We therefore used the orbital ephemeris determined in Section 3 to convert the datapoints to orbital phase, and then binned them into a much smaller number of points. We chose a bin size of 0.001 orbital phases during the eclipses and 0.005 outside the eclipses, resulting in a total of 456 phase-binned datapoints suitable for analysis with the WD code. Through a process of trying a large number of different fits with a range of fixed and fitted parameters, we arrived at a good solution to the light curve. We adopt this as the default solution, plot it in Fig. 9, and give the fitted parameters in Table 6. It was obtained in Mode = 0 with the following fitted parameters: the light contributions of the two stars; their potentials; their gravity darkening coefficients; the linear coefficients of the logarithmic LD law; and the orbital inclination. We fixed the mass ratio at the spectroscopic value, the orbital eccentricity to zero, the albedos to 1.1, the logarithmic coefficients of LD to values from Van Hamme (1993), third light to zero, and the rotation rates to synchronous. We adopted the maximum numerical precision values of N1 = N2 = 60 and N1L = N2L = 60, the simple treatment of reflection, and the Cousins R-band as a proxy for the Kepler passband. This solution gives a light ratio in excellent agreement with the spectroscopic values in Table 4. The fractional radii in Table 6 are volume-equivalent values calculated by the LC component of the WD code. For the determination of the uncertainties of the fitted parameters we ran a wide range of solutions with a large number of different possible approaches to modelling the light curve (see Southworth 2020). We calculated the errorbar for each parameter by adding in quadrature the contribution from every model choice, which in turn was taken to be the amount that parameter changed by versus the default solution. The following different approaches were explored. (i) We varied the amount of binning prior to the WD solution, finding that it had a negligible effect on the fitted parameters. (ii) We changed the numerical precision to N1 = N2 = N1L = N2L = 50. This modified the fractional radii by a maximum of 0.5%. (iii) We tried the detailed reflection effect and found almost identical results. (iv) Attempts to fit for mass ratio returned a value very close to the spectroscopic one and almost no change in the other parameters. (v) Fitting for the rotation rates of the stars yielded values close to and consistent with synchronous rotation and little change in the other parameters. (vi) Fitting for albedo gave a poorer fit but again very little change in the other parameters. (vii) Allowing for third light gave very similar parameters and a very small amount of third light consistent with zero. (viii) Fitting for one of the temperatures of the stars instead of the two light contributions directly (namely Mode = 2) changed the fractional radii by 0.2%. (ix) Fixing the limb darkening coefficients to theoretical values changed the fractional radii by 0.5%. (x) Using the square-root instead of logarithmic limb darkening law had a negligible effect. The best-fitting parameters were highly robust against all these experiments. The only significantly discrepant fit (neglecting our original exploratory ones) was when we used the Cousins I-band instead of the R-band. However, we are able to reject this fit as it is not consistent with the spectroscopic light ratio. The calculated uncertainties are given in Table 6. Fig. 9 shows that the best fit is extremely good, with an r.m.s. of 0.20 mmag, but that there are systematics remaining in the residuals. We attribute these to the WD numerical integration for points during the eclipses, and residual pulsations for points outside eclipse. Our approach of phase-binning the data gives a light curve practially without Poisson noise, so makes any imperfections in the fit easily noticable. We note that the systematics in the residuals of the fits we found to the data are too small to show up in plots of unbinned data, so may well be present in previous work on this object. This paper is available on arxiv under CC 4.0 license. Authors: (1) Z. Jennings, Astrophysics Group, Keele University, Staffordshire, ST5 5BG, UK (E-mail: z.jennings@keele.ac.uk); (2) J. Southworth, Astrophysics Group, Keele University, Staffordshire, ST5 5BG, UK; (3) K. Pavlovski, Department of Physics, Faculty of Science, University of Zagreb, 10000 Zagreb, Croatia; (4) T. Van Reeth, Institute of Astronomy, KU Leuven, Celestijnenlaan 200D, B-3001 Leuven, Belgium. This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) Z. Jennings, Astrophysics Group, Keele University, Staffordshire, ST5 5BG, UK (E-mail: z.jennings@keele.ac.uk); (2) J. Southworth, Astrophysics Group, Keele University, Staffordshire, ST5 5BG, UK; (3) K. Pavlovski, Department of Physics, Faculty of Science, University of Zagreb, 10000 Zagreb, Croatia; (4) T. Van Reeth, Institute of Astronomy, KU Leuven, Celestijnenlaan 200D, B-3001 Leuven, Belgium. Table of Links Abstract and Intro Observation Orbital Ephemeris Radial Velocity Analysis Spectral Analysis Analysis of the Light Curve Physical Properties Asteroseismic Analysis Discussion Conclusion, Data Availability, Acknowledgments, and References Appendix A: Ephemeris Determination Appendix B: Iteratively Prewhitened Frequencies Appendix C: Detected Tidally Perturbed Pulsations Abstract and Intro Abstract and Intro Observation Observation Orbital Ephemeris Orbital Ephemeris Radial Velocity Analysis Radial Velocity Analysis Spectral Analysis Spectral Analysis Analysis of the Light Curve Analysis of the Light Curve Physical Properties Physical Properties Asteroseismic Analysis Asteroseismic Analysis Discussion Discussion Conclusion, Data Availability, Acknowledgments, and References Conclusion, Data Availability, Acknowledgments, and References Appendix A: Ephemeris Determination Appendix A: Ephemeris Determination Appendix B: Iteratively Prewhitened Frequencies Appendix B: Iteratively Prewhitened Frequencies Appendix C: Detected Tidally Perturbed Pulsations Appendix C: Detected Tidally Perturbed Pulsations 6 ANALYSIS OF THE LIGHT CURVE The components of KIC 9841944 are close to each other and thus have a significant tidal deformation. We therefore sought to model the light curve using a code that is based on Roche geometry. We selected the Wilson-Devinney (WD) code (Wilson & Devinney 1971; Wilson 1979) for this, and used the 2004 version of the code driven using the JKTWD wrapper (Southworth et al. 2011). The user guide which accompanies the WD code (Wilson & Van Hamme 2004) includes a description of all input and output quantities discussed below. The WD code is computationally expensive and is not suited to the analysis of the full 500 000 short-cadence datapoints in one step. We therefore used the orbital ephemeris determined in Section 3 to convert the datapoints to orbital phase, and then binned them into a much smaller number of points. We chose a bin size of 0.001 orbital phases during the eclipses and 0.005 outside the eclipses, resulting in a total of 456 phase-binned datapoints suitable for analysis with the WD code. Through a process of trying a large number of different fits with a range of fixed and fitted parameters, we arrived at a good solution to the light curve. We adopt this as the default solution, plot it in Fig. 9, and give the fitted parameters in Table 6. It was obtained in Mode = 0 with the following fitted parameters: the light contributions of the two stars; their potentials; their gravity darkening coefficients; the linear coefficients of the logarithmic LD law; and the orbital inclination. We fixed the mass ratio at the spectroscopic value, the orbital eccentricity to zero, the albedos to 1.1, the logarithmic coefficients of LD to values from Van Hamme (1993), third light to zero, and the rotation rates to synchronous. We adopted the maximum numerical precision values of N1 = N2 = 60 and N1L = N2L = 60, the simple treatment of reflection, and the Cousins R-band as a proxy for the Kepler passband. This solution gives a light ratio in excellent agreement with the spectroscopic values in Table 4. The fractional radii in Table 6 are volume-equivalent values calculated by the LC component of the WD code. For the determination of the uncertainties of the fitted parameters we ran a wide range of solutions with a large number of different possible approaches to modelling the light curve (see Southworth 2020). We calculated the errorbar for each parameter by adding in quadrature the contribution from every model choice, which in turn was taken to be the amount that parameter changed by versus the default solution. The following different approaches were explored. (i) We varied the amount of binning prior to the WD solution, finding that it had a negligible effect on the fitted parameters. (ii) We changed the numerical precision to N1 = N2 = N1L = N2L = 50. This modified the fractional radii by a maximum of 0.5%. (iii) We tried the detailed reflection effect and found almost identical results. (iv) Attempts to fit for mass ratio returned a value very close to the spectroscopic one and almost no change in the other parameters. (v) Fitting for the rotation rates of the stars yielded values close to and consistent with synchronous rotation and little change in the other parameters. (vi) Fitting for albedo gave a poorer fit but again very little change in the other parameters. (vii) Allowing for third light gave very similar parameters and a very small amount of third light consistent with zero. (viii) Fitting for one of the temperatures of the stars instead of the two light contributions directly (namely Mode = 2) changed the fractional radii by 0.2%. (ix) Fixing the limb darkening coefficients to theoretical values changed the fractional radii by 0.5%. (x) Using the square-root instead of logarithmic limb darkening law had a negligible effect. The best-fitting parameters were highly robust against all these experiments. The only significantly discrepant fit (neglecting our original exploratory ones) was when we used the Cousins I -band instead of the R -band. However, we are able to reject this fit as it is not consistent with the spectroscopic light ratio. The calculated uncertainties are given in Table 6. I R Fig. 9 shows that the best fit is extremely good, with an r.m.s. of 0.20 mmag, but that there are systematics remaining in the residuals. We attribute these to the WD numerical integration for points during the eclipses, and residual pulsations for points outside eclipse. Our approach of phase-binning the data gives a light curve practially without Poisson noise, so makes any imperfections in the fit easily noticable. We note that the systematics in the residuals of the fits we found to the data are too small to show up in plots of unbinned data, so may well be present in previous work on this object.

Physical Properties of the Eclipsing Binary KIC 9851944: Analysis of the Light Curve

Read the first part of this article here: Unveiling a 35-Year-Old Vulnerability in nix libX11: Part 1 My team recently discovered two security vulnerabilities in X.Org libX11, the widely popular graphics library – (with a high NVD severity ). These vulnerabilities cause a denial-of-service and remote code execution. X11’s latest versions contain fixes for these vulnerabilities. CVE-2023-43786 and CVE-2023-43787 CVSS 7.8 The team constantly monitors open-source projects to find new vulnerabilities and malicious packages and shares them with the wider community to help improve their overall security posture. This 2-part blog series provides details of the inner workings of the vulnerable Xpm file format and deep-dives into exploiting these vulnerabilities. This post provides a walkthrough for achieving code execution by exploiting CVE-2023-43787 on a Debian machine. RCE vulnerability – CVE-2023-43787 CVE-2023-43787 is a heap-based buffer overflow vulnerability that occurs when parsing a malformed XPM image, which can be exploited to achieve remote code execution. Fix commit: The vulnerability was fixed in libX11 version 1.8.7, in commit . 7916869d Technical analysis The root cause of CVE-2023-43787 lies in , a libX11 function that is used to create an object, representing an off-screen image that can be manipulated and displayed on the screen. With , developers can efficiently manage off-screen images in X11 applications, specifying parameters like width, height, depth, and format to customize image attributes. XCreateImage XImage XCreateImage package org.example;

import java.io.IOException;
import org.yaml.snakeyaml.LoaderOptions;
import org.yaml.snakeyaml.constructor.*;
import org.yaml.snakeyaml.Yaml;

public class Main {
    public static void main(String[] args) throws IOException {
        LoaderOptions options = new LoaderOptions();
        Yaml yaml = new Yaml(new Constructor(options));
        String strYaml = Files.readString(args[0]); 
        String parsed = yaml.load(strYaml);
    }
} XImage *XCreateImage (
    register Display *dpy,
    register Visual *visual,
    unsigned int depth,
    int format,
    int offset,
    char *data,
    unsigned int width,
    unsigned int height,
    int xpad,
    int image_bytes_per_line)
        /*How many bytes between a pixel on one line and the pixel with the same X coordinate on the next line? 0 means 	  XCreateImage can calculate it.*/
{
    register XImage *image;
    int bits_per_pixel = 1;
    int min_bytes_per_line;


    .......
    if (format == ZPixmap)
    {
       bits_per_pixel = _XGetBitsPerPixel(dpy, (int) depth); [1]
    }

    image->xoffset = offset;
    image->bitmap_pad = xpad;
    image->depth = depth;
    image->data = data;
    /*
     * compute per line accelerator.
     */
    {
    if (format == ZPixmap)
        min_bytes_per_line =                              [2]
           ROUNDUP((bits_per_pixel * width), image->bitmap_pad);
    else
        min_bytes_per_line =
            ROUNDUP((width + offset), image->bitmap_pad);
    }
     if (image_bytes_per_line == 0) {
        image->bytes_per_line = min_bytes_per_line;
    } else if (image_bytes_per_line < min_bytes_per_line) { Xfree(image); return NULL; } else { image->bytes_per_line = image_bytes_per_line;     [3]
    }
    ....... When the format is it calculates [1], and then uses the result to calculate the [2]. ZPixmap bits_per_pixel min_bytes_per_line It is then set to the attribute of the XImage [3]. bytes_per_line There is no validation on the of the image, and so the calculation [2] exceeds the capacity of (a 4-byte integer), causing an overflow. width min_bytes_per_line is called from libXpm’s function, defined in : XCreateImage CreateXImage create.c /*
 * Create an XImage with its data
 */
static int
CreateXImage(
    Display	 *display,
    Visual	 *visual,
    unsigned int  depth,
    int		  format,
    unsigned int  width,
    unsigned int  height,
    XImage	**image_return)
{
    ...

    /* then create the XImage with data = NULL and bytes_per_line = 0 */
    *image_return = XCreateImage(display, visual, depth, format, 0, 0,
                     width, height, bitmap_pad, 0);                       [1]
    if (!*image_return)
    return (XpmNoMemory);

#if !defined(FOR_MSW) && !defined(AMIGA)
    if (height != 0 && (*image_return)->bytes_per_line >= INT_MAX / height) {
        XDestroyImage(*image_return);
        *image_return = NULL;
        return XpmNoMemory;
    }
    /* now that bytes_per_line must have been set properly alloc data */
    if((*image_return)->bytes_per_line == 0 ||  height == 0) {
        XDestroyImage(*image_return);
        *image_return = NULL;
        return XpmNoMemory;
    }
    (*image_return)->data =
        (char *) XpmMalloc((*image_return)->bytes_per_line * height);     [2]

    ...
} On [1] there’s the call to the vulnerable function that calculates the size needed to be allocated. XCreateImage On [2] there’s an allocation that uses the overflown property of the XImage, which will then proceed to allocate a smaller buffer than needed. bytes_per_line is called from the function [1], triggered when libXPM is asked to parse an XPM file: CreateXImage xpmParseDataAndCreate /*
 * This function parses an Xpm file or data and directly create an XImage
 */
int
xpmParseDataAndCreate(
    Display		 *display,
    xpmData		 *data,
    XImage		**image_return,
    XImage		**shapeimage_return,
    XpmImage		 *image,
    XpmInfo		 *info,
    XpmAttributes	 *attributes)
{
    


   .....

    /*
     * parse the header
     */
    ErrorStatus = xpmParseHeader(data);
    if (ErrorStatus != XpmSuccess)
        return (ErrorStatus);

    /*
     * read values
     */
    ErrorStatus = xpmParseValues(data, &width, &height, &ncolors, &cpp,
                 &x_hotspot, &y_hotspot, &hotspot,
                 &extensions);
    if (ErrorStatus != XpmSuccess)
        return (ErrorStatus);

   .........

    /* now create the ximage */
    if (image_return) {
        ErrorStatus = CreateXImage(display, visual, depth,
                       (depth == 1 ? bitmap_format : ZPixmap),
                       width, height, &ximage);                       [1]
    if (ErrorStatus != XpmSuccess)
        RETURN(ErrorStatus);
        ......... Exploiting CVE-2023-43787 to achieve code execution Let’s discuss all the basic exploitation pieces before moving on to code execution. Piece 1 – Controlling the allocation size The size of the allocation that is overflown, is decided from the width of the Xpm image. As we discussed in the previous blog post, the width can be easily manipulated by modifying this information in the Xpm header. So, we have control over the allocation size (heap bin size). We now want to find out how to control the overflown data. Piece 2 – Controlling the overflowed buffer data The overflown data is , which is the pointer to the image data. ximage->data Piece 3 – Controlling the overflow size Controlling the size of the overflow itself (anything that comes after the allocated buffer). This is easily achieved as Xpm reads the image pixels from the file as long as there are pixels to read. The function calls the function with the ximage object [1]: xpmParseDataAndCreate ParseAndPutPixels .....
    /*
     * read pixels and put them in the XImage
     */
    ErrorStatus = ParseAndPutPixels(
#ifdef FOR_MSW
                    display,
#endif
                    data, width, height, ncolors, cpp,
                    colorTable, &hashtable,
                    ximage, image_pixels,                      [1]
                    shapeimage, mask_pixels);
..... The ParseAndPutPixels function loops over the image pixels and fills the ximage->data: .....
        for (x = 0; x < width; x++) {                                  [1]
            int c = xpmGetC(data);                                      [2]
..... On [1], we can see the loop reads data according to , which is very big (as we needed to overflow the size). On [2], a call to the macro is made: width xpmGetC #define xpmGetC(mdata) \
    ((!mdata->type || mdata->type == XPMBUFFER) ? \
    (*mdata->cptr++) : (getc(mdata->stream.file))) Multiple Avenues of Exploitation After going over the basic exploitation pieces, let’s see which primitives can be triggered by overwriting different heap chunks. Specifically, we will examine the case of exploitation when the vulnerability is triggered through the CLI utility (for example, using the simple command-line . These exploitation avenues can be extrapolated to other vulnerable cases as well (ex. exploiting code that uses the library’s vulnerable functions) – sxpm sxpm attacker_image.xpm) Option #1 – Function pointer overwrite – Code Execution #1 Due to time constraints, we opted to switch from a 64-bit binary to 32-bit for this exploitation (which would have required more research into the pixel data). Exploitation with Option #1 will focus on Debian 12 32-bit, but the ideas apply similarly to 64-bit. If we set our overflown bin to 428 bytes ( bin), something interesting happens. 0x1b0 (Display) pointer, which is later used when freeing the XPM colors. We managed to overwrite the dpy The structure size is 2,412 bytes – allocated on the large bin. Display 0x970 Specifically, we overwrite the pointer in this structure: lock_fns struct _XLockPtrs *lock_fns; /* pointers to threads functions */ The libX11 code dereferences this pointer and jumps to the address inside it – int
XFreeColors(
    register Display *dpy,
    Colormap cmap,
    unsigned long *pixels, /* LISTofCARD32 */
    int npixels,
    unsigned long planes) /* CARD32 */
{
    register xFreeColorsReq *req;
    register long nbytes;

    LockDisplay(dpy);                                                          [1]
    GetReq(FreeColors, req);
    req->cmap = cmap;
    req->planeMask = planes;

    /* on the VAX, each pixel is a 32-bit (unsigned) integer */
    req->length += npixels;

    nbytes = npixels << 2;		/* watch out for macros... */
    Data32 (dpy, (long *) pixels, nbytes);
    UnlockDisplay(dpy);
    SyncHandle();
    return 1;
} on [1] is a macro: LockDisplay /* used everywhere, so must be fast if not using threads */
#define LockDisplay(d)	     if ((d)->lock_fns) (*(d)->lock_fns->lock_display)(d) As can be seen from the macro, when we overwrite the pointer, it will be dereferenced twice and run the resulting pointer, leading to code execution. dpy After checking the offset of in our payload, and setting its pointer to a predictable address in the 32-bit memory space of (e.g. ), we have total control over EIP. dpy->lock_fns sxpm 0x409774 Option #2 – Limited Write-What-Where Another possible primitive is to overwrite a pointer to the File Descriptor (in an structure). This happens when we allocate 136 bytes (on the fastbin). xpmData 0x90 Inside the loop that reads each character from the XMP file, it uses it and reads a character. The structure: xpmData This is a limited relative write-what-where. We can write 4 bytes (3 controlled bytes + 1 byte fixed ’00’), into a relative address like 0x5555{00414243}. This can be seen here in [1] and [2]: static int
ParseAndPutPixels(
#ifdef FOR_MSW
    Display		*dc,
#endif
    xpmData		*data,
    unsigned int	 width,
    unsigned int	 height,
    unsigned int	 ncolors,
    unsigned int	 cpp,
    XpmColor		*colorTable,
    xpmHashTable	*hashtable,
    XImage		*image,
    Pixel		*image_pixels,
    XImage		*shapeimage,
    Pixel		*shape_pixels)
{
    unsigned int a, x, y;

    switch (cpp) {

    case (1):				/* Optimize for single character
                     * colors */
    {
        unsigned short colidx[256];
#ifdef FOR_MSW
        HDC shapedc;
        HBITMAP obm, sobm;

        if ( shapeimage ) {
            shapedc = CreateCompatibleDC(*dc);
            sobm = SelectObject(shapedc, shapeimage->bitmap);
        } else {
            shapedc = NULL;
        }
        obm = SelectObject(*dc, image->bitmap);
#endif
        if (ncolors > 256)
            return (XpmFileInvalid);
        bzero((char *)colidx, 256 * sizeof(short));
        for (a = 0; a < ncolors; a++) {
            colidx[(unsigned char)colorTable[a].string[0]] = a + 1;
        }

        for (y = 0; y < height; y++) {
            xpmNextString(data);
            for (x = 0; x < width; x++) { int c = xpmGetC(data); [1] if (c > 0 && c < 256 && colidx[c] != 0) {
#ifndef FOR_MSW
                    XPutPixel(image, x, y, image_pixels[colidx[c] - 1]); [2]
                    if (shapeimage) {
                        XPutPixel(shapeimage, x, y,
                            shape_pixels[colidx[c] - 1]);
                    }
#else
                    SetPixel(*dc, x, y, image_pixels[colidx[c] - 1]);
                    if (shapedc) {
                        SetPixel(shapedc, x, y, shape_pixels[colidx[c] - 1]);
                    }
#endif
                }else {
                    return (XpmFileInvalid);
                }
            }
        }
        ...... Option #3 – Code Execution Alternative When allocating a chunk of 136 bytes (which gets allocated on the 0x90 heap fastbin), we can overwrite an object: _XLockInfo The object: structure is 192 bytes long, so it gets allocated on the bin. _XLockInfo dpy->lock 0xd0 As can be seen from the backtrace, we overwrote the that gets used in the function, which then gets accessed at the start of the function (using the register): mutex __pthread_mutex_lock rdi int
__pthread_mutex_lock (pthread_mutex_t *mutex)
{
  unsigned int type = PTHREAD_MUTEX_TYPE_ELISION (mutex);
  .....
}


#define PTHREAD_MUTEX_TYPE_ELISION(m) \
  ((m)->__data.__kind & (127|PTHREAD_MUTEX_ELISION_NP)) This is called when freeing the colors structure in , which calls the function. xpmParseDataAndCreate XFreeColors After the Mutex is accessed, the data is then used in the function: _XDisplayLockWait static void _XDisplayLockWait(
    Display *dpy)
{
    xthread_t self;

    while (dpy->lock->locking_level > 0) {
        self = xthread_self();
        if (xthread_equal(dpy->lock->locking_thread, self))
            break;
        ConditionWait(dpy, dpy->lock->cv);
    }
} The is a macro: ConditionWait #define ConditionWait(d,c) if ((d)->lock) \
    (*(d)->lock->condition_wait)(c, (d)->lock->mutex) It dereferences the lock object and then . executes it as a function This can be used as another code execution primitive. Option #4 – Another Write-What-Where (dead end in the case of sxpm) Another primitive will overwrite the structure (which is 136 bytes long – bin). XImage 0x90 This is when allocating a chunk of 16 bytes (on the fastbin). 0x20 Our image data ( ) is allocated just before the contents, and so we overwrite the pointer with our data to create this primitive. ximage->data XImage ximage->data This can be an absolute write-what-where primitive. Again, switching from a 64-bit binary to 32-bit. The rest of the exploitation will focus on Debian 12 32-bit. The structure on 32-bit is 88 bytes long. Let’s try changing the size of our overflowing buffer to 88: Contrary to the 64-bit primitive, on 32-bit our overflowing buffer is allocated after the target object. XImage XImage The allocation will be adjacent to the structure, but in the reverse order (a bit after the address). ximage->data XImage XImage Therefore – our overflown buffer will not be behind our target XImage structure, and our exploitation won’t work. Using debug prints: Now, let’s groom the heap using an allocation primitive. There are 4 pixel allocations using the following calculation: sizeof(Pixel) * ncolors On 32-bit, equals 4. sizeof(Pixel) Let’s change the file to have only 22 colors, to achieve our needed 88 bytes (22*4). Changing to 22 colors will still not help us overwrite the XImage object. Using debug prints: In the case of , this led us to a dead-end (It would be better to create a new exploitation primitive) however this chain of primitives might be relevant in different exploitation scenarios. sxpm In which cases can CVE-2023-43787 be triggered? Any application or library that uses libXPM to parse externally-supplied XPM images, can trigger CVE-2023-43787 with the use of the following vulnerable libXPM exported functions: XpmCreateImageFromXpmImage
XpmCreateImageFromBuffer
XpmCreateImageFromData
XpmCreatePixmapFromXpmImage
XpmCreatePixmapFromBuffer
XpmCreatePixmapFromData
XpmReadFileToImage
XpmReadFileToPixmap For example, is a CLI utility that is used to display XPM images on the screen. The vulnerability can be triggered via with a simple command line – sxpm sxpm sxpm attacker_image.xpm This utility calls the vulnerable libXpm function, which then calls the vulnerable libX11 functions then . xpmCreatePixmapFromImage XPutImage PutSubImage

Uncovering and Exploiting a 35-Year-Old Vulnerability, *nix libX11: Part 2 

123 Stories To Learn About Youtube Transcripts

Let's learn about via these 55 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Peace Itimi /Learn Repo 1. #FoundersConnect: Mariam Jimoh, CEO & Founder of Oja (Ethnic Grocery Delivery Startup) Peace speaks with Mariam about her grocery startup for afrocarribean people living in the diaspora. 2. #FoundersConnect: Interview with Hanu Agbodje, the Founder and the CEO of Patricia In this episode, Peace Itimi interviews Hanu Agbodje, CEO of Patricia, on his journey as a tech entrepreneur and 3. #FoundersConnect: Abdul Hassan, CEO & Founder of Mono, Backed by Ycombinator #FoundersConnect: Abdul Hassan, CEO & Founder of Mono, Backed by Ycombinator 4. #FoundersConnect: Chimezie Emewulu, Co-Founder and MD of Seamfix Limited. Conversation with an OG Founder, Chimezie Emewulu, Co-founder and CEO of Seamfix. 5. The co-CEOs of Printivo, Temitope Ekundayo and Ibukun Oloyede on How to Run a Company Peace interviews co-CEOs of Temitope Ekundayo and Ibukun Oloyede or Printivo, a solution enabling small and medium enterprises to print items seamlessly. 6. #FoundersConnect: Interview with Chijioke Dozie, the CEO of Carbon Peace interviews Chijioke Dozie, CEO of $15.8 million VC-backed company, Carbon on his journey as a tech entrepreneur. 7. #FoundersConnect: Interview with Nadayar Enegesi, CEO of Eden Life & Co-founder of Andela Peace interviews Nadayar Enegesi, the Co-founder and CEO of Eden Life a tech-enabled service that puts its users' home chores on autopilot. 8. #FoundersConnect (Music): Rebecca Inyang Junaid Founder of JustJoJo (Music Publishing) A conversation with Rebecca Inyang Junaid, Founder of JustJojo Entertainment, a music agency based in the UK on career, life and experiences. 9. #FoundersConnect: How Erika Brodnock, Founder of Kami, Uses Tech to Improve the Lives of Families Peace speaks with Erika Brodnock, Founder of Kami app. 10. #FoundersConnect: An Interview With Bernard Parah, CEO of Bitnob Bernard Parah, CEO of Bitnob, a Bitcoin centred payment service shares his love for cryptocurrency and the plans for his growing Startup with me. 11. Ayo Akindele, Founder and CEO of Kyshi Interview with Ayo Akindele, of Kyshi, a payment startup for transnational money transactions. 12. #FoundersConnect - Bayo ‘Lion’ Adedeji: CEO, Wakanow & Founder, Dundu Nation & Wave Beach In this interview I have a conversation with Bayo Adedeji concerning how work at Wakanow and his extensive journey as an entrepreneur. 13. #FoundersConnect: Kay Akinwunmi, Co-Founder & CEO of Zazuu, A Transborder Payment Company Kay, Co-founder and CEO of Zazuu, speaks to me about his platform that allows money transfers across border with ease, his background and journey. 14. Adewale Yusuf, Co-founder TalentQL, on Helping Young Africans Launch Their Tech Careers Peace interviews Adewale Yusuf, serial entrepreneur with a demonstrated history in EdTech,  with building Talent QL, Techpoint Africa and AltSchool. 15. #FoundersConnect: Interview with Musty Mustapha, Co-Founder & CTO of Kuda Peace Interviews Co-Founder of Kuda Bank, Musty Mustapha on his journey as a tech entrepreneur, experiences and lessons. 16. #FoundersConnect: Douglas Kendyson of Selar on Hitting Huge Revenue Milestones Peace sits with Douglas Kendyson, CEO and founder of Selar for a fun and elucidating interview on his journey and his company. 17. #FoundersConnect: Interview with Yinka Adewale, the CEO of Kudi Peace interviews Yinka Adewale, CEO of Kudi, a Start-up that offers seamless banking services to communities in Africa. 18. #FoundersConnect: How Kemi Olawoye Is Building BabyMigo, Nigeria's Largest Parenting Community Kemi shares her journey building Babymigo, Nigeria's largest Parenting Community 19. #FoundersConnect: Interview with Michael 'Trojan' Okoh - Co-founder and CTO, ThePeer 22-year old Founder of ThePeer, Michael Trojan Okoh, shares his story with me. 20. #FoundersConnect: Interview with Yanmo Omorogbe, Co-Founder of Invest Bamboo Peace interviews Yanmo Omorogbe, Co-founder of Invest Bamboo, on her "accidental" journey into entrepreneurship, running Bamboo and biggest wins and lessons. 21. Interview with Ezra Olubi, CTO of Paystack, on Getting Acquired by Stripe Peace interviews Ezra Olubi, co-founder and CTO of Paystack as he shares the Paystack story. 22. #FoundersConnect: Njoku Emmanuel, the 19-year-old CEO & Co-founder of Lazerpay Interview with Lazerpay co-founder & CEO, Njoku Emmanuel. 23. #FoundersConnect: Duncan Muchangi, Principal @ Unicorn Growth, Former MD, Jumia Group & Antler E.A Interview with Kenyan VC, Duncan Muchangi and founder of Unicorn Growth Capital. 24. #FoundersConnect: How Preston Ideh is building Africa's Largest Intelligence Startup, Stears. Interview with Preston Ideh, CEO and Co-founder of Stears. 25. #FoundersConnect: Wale Adetula, Co-Founder of TNC Africa Interview with Wale Adetula, the Founder of one of Nigeria's pioneer Media companies, TNC Africa. 26. #FoundersConnect: Peter Bunor Jr., From Nollywood Child Actor, to Co-Founder of Field Intelligence Peace interviews Nollywood Child Actor turned Founder, Peter Bunor of Field Intelligence. 27. #FoundersConnect (Music): Interview with Toba Adeyanju, CEO of Ejoya Music I sit with Toba Adeyanju, CEO of Ejoya Music, a startup music company, on his journey, insights and plans for the future. 28. FoundersConnect: Interview with Kelvin Umechukwu, CEO and co-Founder of Bumpa Kelvin Umechukwu, CEO of Bumpa,  shares his journey into entrepreneurship and the role of community in effecting change. 29. Interview with the Founder of Money Africa: Financial Education, Investing, and More Peace interviews Oluwatosin Olaseinde, founder of Money Africa and Ladda on her journey as a startup founder, biggest life lessons and future plans. 30. #FoundersConnect: Interview with Onyeka Akumah, CEO Farmcrowdy & Co-founder CrowdyVest, PlentyWaka Peace interviews Onyeka Akumah, CEO of Farmcrowdy, and co-founder at Plentywaka, Crowdyvest and Rent Smallsmall on his journey as a tech entrepreneur. 31. Yele Bademosi, Founder of Bundle Africa, Talks About Tech Entrepreneurship Peace speaks with Yele Bademosi, founder of Bundle Africa, Microtraction and co-Founder of Nestcoin, in a lengthy and elucidating interview. 32. Interview with Atsu Davoh, Founder of Bitsika, on Creating a Payment App in Africa Peace sits down with Atsu Davoh, Founder & CEO of Bitsika. Bitsika is a payments app for making transactions. 33. The Founder & CEO of Kudigo Talks About Tech Startups in Ghana Peace interviews Kingsley Abrokwah, serial entrepreneur and founder of Kudigo, a software solution for retail businesses in Africa. 34. #FoundersConnect: Odun Eweniyi, Co-Founder of Piggyvest, Africa's Top Savings App Odun Eweniyi, coFounder of Piggyvest, FirstCheck Africa and the Feminist Coalition shares her journey with me. 35. #FoundersConnect: Eyitayo Ogunmola, Founder of Utiva, an African Ed-tech Startup I speak with Eyitayo Ogunmola, the CEO of Utiva, an education service for Africans and people of colour entering the tech industry. 36. #FoundersConnect - Ized Uanikhehi, CEO of Loose Media, and Her Advice for Tech Marketers Peace interviews Ized Uanikhehi, Media professional and CEO of Loose Media on her journey, experiences and advice. 37. #FoundersConnect: Tosin Faniro-Dada, MD /CEO of Endeavor (Nigeria) Peace has a conversation with Tosin Faniro-Dada, the MD & CEO of Endeavor in Nigeria, about her career and her passion for helping entrepreneurs. 38. #FoundersConnect: Moe Odele - Tech Lawyer, Human Rights Advocate & Travel Enthusiast Peace speaks to Moe "Moechievous" Odele, about her life and career, growing up in a polygamous family, studying law and finding tech law. 39. #FoundersConnect: Babajide Duroshola, General Manager at M-KOPA & ex-Country Director, SafeBoda (NG) I speak with Babajide Duroshola, the General Manager at M-Kopa with years of experience managing startups about his journey and work. 40. #FoundersConnect: Ben Lyon, CEO and CoFounder of Stax, an Offline Payment App for Africans Conversation with Ben Lyon of Hover Developer Services, the parent company of Stax, a simple way to carry out payment services without internet or USSD codes. 41. #FoundersConnect: Bunmi Akinyemiju, Partner at GreenHouse Capital, Former CEO Venture Garden Group I speak with Bunmi Akinyemiju, one of the biggest investors in the African startup space, and Founding Partner at GreenHouse Capital. 42. #FoundersConnect: Ijeoma Akwiwu, Lawyer, Developer, and Co-founder of Pivo, a Digital Bank Peace speaks with Ijeoma Akwiwu, the Co-founder and COO of Pivo, a bank for trade. 43. #FoundersConnect: Tomiwa Aladekomo, The Man behind Big Cabal Media (Techcabal & Zikoko) Peace speaks with Tomiwa Aladekomo, CEO of BigCabal, the parent company of Zikoko, a media company that creates content for African youth, and TechCabal. 44. #FoundersConnect: Adia Sowho, CMO of MTN Nigeria Peace speaks with Adia Sowho, CMO of MTN Nigeria, on her life and journey. This interview is one you definitely should not miss! 45. #FoundersConnect: Kennedy Ekezie-Joseph, CEO of Kippa, a Company Helping Small businesses Grow. I have a conversation with Kippa's CEO & Co-Founder, Kennedy Ekezie-Joseph. 46. #FoundersConnect: Koromone Koroye, Managing Editor of TechCabal Conversation with Koromone Koroye, Managing Editor of TechCabal on her interesting life experiences, thoughts of religion, work culture and more! 47. #FoundersConnect - Interview with Rodney Jackson-Cole, Cofounder and CTO at Prospa (YC W21) Rodney Jackson-Cole is the CTO of Prospa, a company set out to aid African entrepreneurs. Peace finds out more about his mission and journey in this episode. 48. #FoundersConnect: Ameyaw Debrah, the Founder of Ameyawdebrah.com | Ghanaian Celebrity Blogger Peace has a conversation with Ameyaw Debrah, Ghanaian celebrity blogger and founder of Ameyawdebrah.com, a lifestyle news blog about media, his life, and more. 49. #Founders Connect: Moses Enenwali, CEO & Co-founder of Topship (YC W 2022) Peace speaks with Moses Enenwali, the CEO and Co-founder of Topship, a fast-growing Logistics startup in Africa. 50. #FoundersConnect: Jude Dike, CoFounder and CEO of GetEquity Conversation with Jude Dike, co-Founder of GetEquity, a company democratizing access to startup investment in Africa. 51. #FoundersConnect: Marvin Coleby, Co-Founder and CEO of Raise Marvin Coleby is building Raise, an equity management platform with a vision for Panafrican unity. He shares his background, startup and experiences with me. 52. #FoundersConnect: Godwin Tom, Serial Entrepreneur, Music Business Mogul & CEO of iMANAGE AFRICA Conversation with Godwin Tom, an expert in music management and CEO of iMANAGE Africa on his journey, his work, and the future. 53. Interview with the Cofounder of Helicarrier (Formerly, Buycoins) on Crypto in Africa Peace interviews Tomiwa Lasebikan, co-founder and head of product at Helicarrier, a product dedicated to connecting Africans with financial solutions. 54. #FoundersConnect: Florence Githinji, Regional Marketing Manager at YellowCard Conversation with Florence Githinji, Regional Marketing Manager of Yellowcard. 55. #FoundersConnect: Interview with Lotanna Nwose, Co-founder of Investsika I sit with Investsika's Co-Founder, Lotanna Nwose and we discuss his passion for stock accessibility and entrepreneurship and desires to provide this in Ghana. Thank you for checking out the 55 most read stories about Peace Itimi on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

Stories, News & Mentions about PAYSTAND

Paystand’s Stories on HackerNoon