Charles Osgood, the longtime anchor of "CBS Sunday Morning," known for his signature bow ties has died at 91.

Former 'CBS Sunday Morning' host Charles Osgood dies at 91 following battle with dementia

Charles Osgood, who spent 22 years anchoring the CBS-TV staple “Sunday Morning” and decades as a radio commentator, and who carved a distinct place for himself in broadcasting by occasionally presenting the news in wry doggerel, died Jan. 23 at his home in Upper Saddle River, N.J. He was 91.

Charles Osgood, wry stalwart of CBS’s ‘Sunday Morning,’ dies at 91 - The Washington Post

Osgood was best known as the Sunday Morning anchor who helmed the show from 1994 to 2016. He succeeded original host Charles Kuralt and ultimately served a longer tenure of 22 years to Kuralt's 15. He was also the voice of The Osgood File, a daily news commentary series for CBS News Radio.

Charles Osgood dead: 'CBS Sunday Morning' host was 91

Often referred to as CBS News' poet-in-residence, the Emmy- and Peabody Award-winner also wrote and anchored "The Osgood File," his daily radio show which ran for more than four decades.

Charles Osgood, veteran CBS newsman and longtime host of "Sunday Morning," dies at 91 - CBS News

Anchoris in the Finance-Accounting Tech Industry

Anchor

How to Mint Solana NFTs Using Anchor and Metaplex

Blockchain is an immutable public ledger that securely stores data or information, making it less susceptible to hacking or modification. It is a decentralized/distributed digital transaction ledger devoid of central governance or a third party. It protects data by distributing it across all nodes in its ecosystem. When blockchain came to the limelight in 2008, it started as a decentralized P2P public database of transactions; this earliest form of the blockchain is known as Blockchain 1.0. As developers keep exploring more use cases of the blockchain technology with a robust framework and more utilities, they successfully developed another version of the blockchain, the Blockchain 2.0. Blockchain 2.0 incorporates the earliest version of the blockchain and added more features like transparency, improved security, and smart contract. The advent of smart contracts in blockchain technology is genuine in all these features. What is Smart Contract? A smart contract is a self-executing digital term of agreement embedded in strings of codes to be executed when the specified conditions have been met. It is the trusted tool between two anonymous parties that enables them to transact with each other without concern. It is accurate, efficient, secure, and transparent. Blockchains that supports smart contract have the edge over those that don't. This is because smart contract broadens the use cases of blockchain technology. For example, smart contracts allow for the development of several crypto tokens on a single blockchain, i.e., a single blockchain can be a host to multiple tokens, including the native cryptocurrency of such blockchain. Another use case of the smart contract in blockchain technology is that it enables the minting of Non-fungible tokens—NFTs. These use cases, and many more are the drives behind blockchains with smart contracts such that non-smart contract-based blockchains are seeking ways to include it in their blockchain network. Such an example is the recent Bitcoin soft-fork, themed "Taproot." One of the blockchain networks that support the smart contract is Solana. What is Solana? Solana is a public blockchain that runs on a BFT—Byzantine Fault Tolerance—themed Tower Consensus. The Tower consensus leverages the Proof-of-History consensus mechanism. As one of the fastest blockchain networks, Solana can process about 710,000 TPS. Solana was created by a former executive of Qualcomm, Anatoly Yakovenko, in 2017. It supports the smart contract and Dapps creation alongside DeFi platforms and NFT marketplaces. The native cryptocurrency of the Solana network is SOL which is used to offset transaction fees on the network and is also traded on the crypto market. All applications or solutions of the Solana network were possible because of the smart contract it supports. How to Write Smart Contract in Solana Using the Anchor Software An Anchor is a software tool for Solana's Sealevel runtime providing handy development tools like: Interface Definition Language–IDL–specification Rust crates and eDSL–embedded Domain Specific Language–for writing Solana programs TypeScript package to generate clients from IDL CLI and workspace management to develop complete applications. Generally, the Anchor incredibly makes creating smart contracts easy on the Solana network.
Before delving into the nitty-gritty of this subject, let's familiarize ourselves with some terms : Rust is a remarkable multi-purpose programming language that will be used to develop this smart contract. Rust : This includes the command-line interface–CLI. Solana Tool Suite Now, let's proceed. To start with, we need to create a new anchor project: anchor init counterapp You should see the following files and folders in the project structure: : This is the directory or location of the Smart contract program : The javascript test code is found here test : The launch script migrations : The frontend will be built here app Now, let’s find file from the program directory lib.rs declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

#[program]
pub mod counterapp {
    use super::*;
    pub fn initialize(ctx: Context<Initialize>) -> ProgramResult {       
        Ok(())
    }
}
#[derive(Accounts)]
pub struct Initialize {} This is the most straightforward CLI program. It has a function initialize that, when called, successfully executes. The "initialize struct" defines the context of the "initialize" function. After setting up our project, the next is to create our counter application. To achieve that, we must first set up an account to save our data. In case you're wondering what the account's purpose is, accounts are means for Solana Sealevel users to store and retrieve data. Recall that we’ve defined two structs: the struct is our which comprises variables that will store our count. CounterAccount Account #[derive(Accounts)]
pub struct Create<'info> {
    
    #[account(init, payer=user, space = 16+16)]
    pub counter_account: Account<'info, CounterAccount>,
    
    #[account(mut)]
    pub user: Signer<'info>,
    
    pub system_program: Program<'info, System>,
}
#[account]
pub struct CounterAccount {
    pub count: u64,
} The struct is the instruction struct that defines the context for creating an account. Create The defines the instructions and constraints for Anchor’s pre-processing while building context. # [account (…) ] Next is to create our function: pub fn create(ctx: Context<Create>) -> ProgramResult {
    let counter_account = &mut ctx.accounts.counter_account;
    counter_account.count = 0;
    Ok(())
} The the function will be our RPC request handler which takes the context previously created with struct. create Create Now that we’re done, let’s write the test function and launch our smart contract. import * as anchor from '@project-serum/anchor';
import { Program } from '@project-serum/anchor';
import { Counterapp } from '../target/types/counterapp';describe('counterapp', () => {    const provider = anchor.Provider.env()
    anchor.setProvider(provider);    const program = anchor.workspace.Counterapp as Program<Counterapp>;    const counterAccount = anchor.web3.Keypair.generate();    it('Is initialized!', async () => {
        await program.rpc.create({
            accounts: {
                counterAccount: counterAccount.publicKey,
                user: provider.wallet.publicKey,
                systemProgram: anchor.web3.SystemProgram.programId,
            },
            signers: [counterAccount]
        } as any)
    });    it("Increment counter", async () => {
        await program.rpc.increment({
            accounts: {
                counterAccount: counterAccount.publicKey
            }
        } as any)
    })    it("Fetch account", async () => {
        const account: any = await
        program.account.counterAccount.fetch(counterAccount.publicKey)
        console.log(account.count)
    })
}); Now, run the test. anchor test We can now launch the program after the test passes. Ensure that the is running. solana-test-validator anchor deploy

How to Create Smart Contracts in Solana Using Anchor

As we add more and more features to (we’re currently at a breakneck pace of approximately one huge new update every week), we’ve been receiving lots of requests for a single tutorial or walkthrough of everything that’s possible to do with Anchor’s many innovative features. Anchor So here it is… the definitive list of all the cool and crazy things you could never do before, that you can now do with Anchor. Right from your phone! 1. Record and broadcast your voice in seconds. Anchor’s easiest way to capture your voice, period. Try recording yourself, a conversation with friends, or the world around you. Here’s a few of the ways we make this a breeze: the Just hold the phone up to your ear to record! Just lift the phone up to your ear like you’re talking on the phone. It’ll start recording automatically and end when you lower it. Telephone mode: Swipe up from the recording button to lock it into place, so you can record hands-free. Hands-free recording: If you need to pause while you’re recording (either to gather your thoughts, or if a large truck happens to go by), just stop recording. You’ll be able to pick right back up where you left off. Segmented recording: 2. Share any full-length track from Apple Music or Spotify. Thanks to our integrations with Apple Music and Spotify, you can add any song from their libraries to your Anchor station. By default, listeners will hear a 30 second preview; anyone with a premium account with one of those services can hear the full length song. We’re seeing people use songs as transitions, create entire radio shows where they DJ playlists, and add songs in between music commentary. A couple stand-out examples: Add any song you can think of to your Anchor station. , where a duo of doctors examine medical lyrics in rap and hip hop songs and reveal how accurate they are. Medicine Remixed’s “Audiotopsy” series “Damn son, where’d you find this?” recurring feature, in which Bay Area rapper Frak breaks down the origins of famously sampled beats. The Beatbox’s shares his favorite songs, along with insider commentary and stories about the bands who made them. Veteran music journalist Jonah Bayer 3. Interview anyone, wherever they are — even if they don’t have Anchor. Co-hosting a show or conducting an interview has literally never been easier. You can call anyone from the Anchor app (all you need is their phone number; all they need is to answer), record the conversation, and add it right into your Anchor station. Some fun facts about Interviews: Interview anyone you want, even if they don’t have Anchor! The recipient does need to opt in (they’ll hear instructions to press 1 when they’re ready to record), so don’t worry — it can’t be used to surprise people who don’t know they’re being recorded. Unlike normal segments on Anchor, interviews don’t have a time limit, so you don’t need to worry about getting cut off. If you want to edit your Interview before posting it (or if you just want to keep the original audio file), we’ll email you the file so you can do whatever you want! We’ve seen a ton of really creative Interviews done on Anchor; one of our favorites in recent weeks was when and got to ask him about the cult-like culture of modern businesses. MADE From Scratch called Noam Chomsky 4. Take call-ins from friends or listeners. Anchor makes audio social in a lot of ways; one is that anyone who hears your show can call in with their thoughts, questions, and suggestions. It’s incredibly easy; they tap a button, record up to 1 minute of audio, and send it your way. If you like what they had to say, you can add their call-in to your station with one tap so your listeners can hear it too! Because you can also export your call-ins, we’ve seen a lot of podcasters take advantage of Anchor as a way to interact with their existing listeners — something which before now just wasn’t possible. Here’s a few examples of stations doing creative things with call-ins: Take call-ins from listeners of your Anchor station! answers questions and gives advice about sex and love to her listeners. Shan Boody uses call-ins to conduct live, audio-only games of Magic: The Gathering (“Mental Magic”) every Monday. 10 Minutes of Magic uses call-ins with her YouTube audience, who previously didn’t have a way to talk to her directly. Sara Dietschy regularly answers support questions and responds to feature requests. Maya from Team Anchor 5. Share or embed audio wherever you want. Your station can be as long as you want it to be (it’s made up of individual segments), but each segment in Anchor is limited to 5 minutes. The great thing about this is it forces each segment to have its own topic, and when it’s shared on social media it’s much more likely to convert to listeners because they can get straight to the part that’s relevant. With Anchor, you have a couple options for sharing your audio outside of the app: Share a segment link to Twitter; it’ll play right in the app as an audio card. Share your station link to Twitter or Facebook; it’ll show a nice custom card with your station information and link to your station. Existing Anchor users will be able to deeplink right into your station in the Anchor app; everyone else will be taken to your web profile so they can listen without needing to install the app. You can also or a specific segment at any time; just grab the embed code from the web player of that audio. embed your station 6. Transcribe your audio and share it as an animated video. Generate an automatic transcription for any of your segments and export it as a video, which will autoplay on social media and which is a very eye-catching way to get your stuff heard. Here’s some more info about , right from your phone. how to create your own videos 7. Upload pre-existing audio from your desktop. If you have existing audio (like a podcast, a captured conversation, a song you recorded, etc), you can upload it to your station by visiting on your desktop. If you want to bypass the 5 minute segment limit, one trick is that you can upload a longer piece of audio here. We’ll still chop it up into 5 minute chunks so it’ll work natively in the Anchor app, but it’ll play through seamlessly for anyone listening. anchor.fm/clip The Anchor Clipper at anchor.fm/clip 8. Create audio that disappears in 24 hours, audio that lasts forever, or a traditional podcast. With Anchor, you have unprecedented flexibility with the format of your audio: Turn your segments into permanent episodes at any time. By default, any audio you add into your expires in 24 hours. This means your listeners always hear your most recent, most relevant content; a side effect is that it also takes the pressure off when you just feel like sharing casual audio. station At any point, you can turn any audio in your station into a permanent . People can listen to it whenever they want, and if you share or embed the episode link it’ll last forever. episode You can also turn your Anchor episodes into a , with a single tap on your phone ( ). We’ll handle all the details of publishing for you, and once it’s set up, any episodes you create in Anchor will be automatically synced to your podcast in places like Apple Podcasts and Google Play Music, so people have even more ways to discover and hear your audio! podcast really For an example of a podcast that was created entirely on Anchor, check out . (You may remember NLB from it’s successful a few years back; we — and all its fans — are very happy we were able to help bring it back to life!) Newest Latest Best in Apple Podcasts Kickstarter campaign 9. Get your voice heard in people’s cars with Apple CarPlay and Android Auto. Your voice, in cars everywhere. If you have an Anchor station, people can automatically listen to whatever you have to say right in their car with our integrations for Apple CarPlay and Android Auto. Your radio DJ dreams are finally coming true. Read more , or launch Anchor in your car now to try it out! here 10. Get realtime data on your audio. As soon as you add audio to your station, we start tracking (and reporting) how many people are listening, who they are, and even which parts of your audio they’re enjoying. If you have a podcast set up, we import your listeners from there too — so you’ll always have an up to date understanding of exactly how many people are hearing you and reacting. This is just the tip of the iceberg with Anchor; we hope you’ll try it out if you haven’t already, and discover all the incredible things you can do with audio on our platform. If you want one more shining example of a station that we think consistently takes advantage of these features, check out . all The Great Everything If you ever have any questions, feature requests, or suggestions, let us know! You can always reach us by email at or on Twitter at . support@anchor.fm @anchor

The many ways to make audio with Anchor

It’s not you, it’s me but that doesn’t mean we have to spilt up The first time I saw Twitter I knew it was special, I didn’t really know how or why just that there was something different about it, an overwhelming sense of potential just waiting for a use case to release it. I had a very similar feeling on discovering Anchor, the network for voice. It’s tag line is “radio by the people” but I feel it goes much deeper than that. Radio is predominantly a broadcast medium, one way traffic often used as the background soundtrack to our lives – turn it on, find a station and just let it fill the awkward silence. Not so Anchor. If you wanted to use a radio metaphor then you would have to opt for a phone-in station where anyone listening could, at any time, begin their own show and field calls but even this doesn’t do it justice. Anchor feels like the early days of Twitter: fresh, different, exciting; a new twist on what we all do every day – talk to people. Like Twitter it is public and you can chime in on conversations from anyone, anywhere and about anything. Being an introvert, there is the struggle with recording my voice for public consumption but Anchor gradually removes the pressures associated with producing a podcast and builds confidence in sharing (and hearing) your own voice – two minutes at a time. Communicating by voice is so much more personal and powerful than text (no doubt the the root of insecurity about sharing it) and this is Anchor’s double-edged sword: what you gain in connection, authenticity and expression you lose in convenience – it is far easier to consume and produce small snippets of text than voice updates and replies. This can be quite frustrating but isn’t always a bad thing. I struggle to find both the time and opportunity to record and interact on Anchor but, if I have the problem, then so will others. We can fire off a tweet about anything in a matter of seconds, often without thinking, but recording a wave requires a degree of consideration and contemplation leading to a less fractious environment in which to communicate. I had considered dropping Anchor as a network of choice but, because of that gut feeling I have about it and it’s potential, in the same way that I first felt about Twitter, I think I have to stick with it.

Weighing the Anchor

First, you will require installing all Solana stuff and the framework for the backend anchor. You can find the installation guide , also there are some basic examples and other useful stuff. here The working repository can be found . here Open the terminal in the folder you prefer to create the program and simply run the next command. It will create the project structure with all the required things. anchor init crowdfunding-program
cd crowdfunding-program The main executable code is stored in (all changes need to be done there): programs/crowdfunding-program/src/lib.rs First things first you need some account (it is actually like a wallet) for the program. solana-keygen new -o id.json Terminal then print the pubkey: <ACCOUNT_ADDRESS> Change the location of the wallet to "./id.json" in ‘Anchor.toml’ file. wallet = "./id.json" Before deployment, you need some amount of Sol to do that. Request some money to your new account. solana airdrop 2 <ACCOUNT_ADDRESS> --url devnet Now you can deploy the application. anchor deploy You will find new folders in your solution after deployment is completed. Basically, we need to obtain the program address and replace it with the automatically generated address by anchor. solana address -k ./target/deploy/crowdfunding_program-keypair.json This address will be the program ID. In the ‘lib.rs’ file and also in ‘Anchor.toml’ replace the program ID that you generated with what is inside these files. The application will support 3 major functions: - create a campaign with the ‘name’, ‘description’, and ‘target_amount’; create - donate the particular amount to the campaign; donate - withdraw the particular amount of money from the campaign account to the user’s wallet. withdraw In the body of the function I’m simply assigning all parameters to the campaign account. create pub fn create(ctx: Context<Create>, name: String, description: String, target_amount: u64) -> Result<()> {
        let campaign = &mut ctx.accounts.campaign;
        campaign.name = name;
        campaign.description = description;
        campaign.amount_donated = 0;
        campaign.target_amount = target_amount;
        // * - means dereferencing
        campaign.owner = *ctx.accounts.user.key;
        Ok(())
    } The is a structure of the current function context accounts, that must include a campaign account, and a signer who creates the campaign. <Create> #[derive(Accounts)]
pub struct Create<'info> {
    // init means to create campaign account
    // bump to use unique address for campaign account
    #[account(init, payer=user, space=9000, seeds=[b"campaign_demo".as_ref(), user.key().as_ref()], bump)]
    pub campaign: Account<'info, Campaign>,
    // mut makes it changeble (mutable)
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
} #[account]
pub struct Campaign {
    pub owner: Pubkey,
    pub name: String,
    pub description: String,
    pub amount_donated: u64,
    pub target_amount: u64,
} The donate functionality requires transferring a specific amount of money to the campaign account. The instruction describes from what account to what account the Sols’ will be transferred. At the I also increasing the counter of donated Sols’ . campaign.amount_donated += amount pub fn donate(ctx: Context<Donate>, amount: u64) -> Result<()> {
        let instruction = anchor_lang::solana_program::system_instruction::transfer(
            &ctx.accounts.user.key(),
            &ctx.accounts.campaign.key(),
            amount
        );
        anchor_lang::solana_program::program::invoke(
            &instruction,
            &[
                ctx.accounts.user.to_account_info(),
                ctx.accounts.campaign.to_account_info(),
            ]
        );
        let campaign = &mut ctx.accounts.campaign;
        campaign.amount_donated += amount;
        Ok(())
} The structure of the accounts context is close to the , but here I don’t need to initialize the campaign itself, I just use the campaign that users selected. <Donate> <Create> #[derive(Accounts)]
pub struct Donate<'info> {
    #[account(mut)]
    pub campaign: Account<'info, Campaign>,
    // mut makes it changeble (mutable)
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
} In the function besides transferring all funds to the user’s wallet I need to check if the amount of money is sufficient for transferring and if the user is the owner of this particular campaign. withdraw pub fn withdraw(ctx: Context<Withdraw>, amount: u64) -> Result<()> {
        let campaign = &mut ctx.accounts.campaign;
        let user = &mut ctx.accounts.user;
        if campaign.owner != *user.key {
            return Err(ErrorCode::InvalidOwner.into());
        }
        // Rent balance depends on data size
        let rent_balance = Rent::get()?.minimum_balance(campaign.to_account_info().data_len());
        if **campaign.to_account_info().lamports.borrow() - rent_balance < amount {
            return Err(ErrorCode::InvalidWithdrawAmount.into());
        }
        **campaign.to_account_info().try_borrow_mut_lamports()? -= amount;
        **user.to_account_info().try_borrow_mut_lamports()? += amount;
        Ok(())
} #[derive(Accounts)]
pub struct Withdraw<'info> {
    #[account(mut)]
    pub campaign: Account<'info, Campaign>,
    // mut makes it changeble (mutable)
    #[account(mut)]
    pub user: Signer<'info>,
} As you can see in the method, I throw errors if the User is not the owner of the campaign and if the balance is insufficient. The error messages actually represented in an enum called . withdraw ErrorCode #[error_code]
pub enum ErrorCode {
    #[msg("The user is not the owner of the campaign.")]
    InvalidOwner,
    #[msg("Insufficient amount to withdraw.")]
    InvalidWithdrawAmount,
} If you are done with all changes in your code, you need to build and deploy your program to the network. anchor build And deploy the program to the preferred network that you will work this, for example, ‘devnet’. In the root directory, there is file ‘Anchor.toml’, change the value of cluster to ‘devnet’. cluster = "devnet" The number 2 is some kind of constraint on the ‘devnet’. And finally, deploy it. anchor deploy After creating the main functionality it will be nice to cover it with tests. You can find tests in the repository, they are more or less similar to what you will have on the UI. Then let’s move forward and create the frontend part. After you have done the backend part you can move to the frontend part and initialize react application via . create-react-app npx create-react-app crowdfunding-ui --template typescript Change directory: cd crowdfunding-ui And install packages for the UI npm i @solana/wallet-adapter-react @solana/wallet-adapter-react-ui @solana/wallet-adapter-wallets @solana/web3.js @project-serum/anchor react-bootstrap The library is for styling only. react-bootstrap But it is not enough to properly build and run the UI application. There are some dependencies in the anchor package and some features in Solana libraries if you use react-scripts. npm i --save-dev react-app-rewired source-map-loader The problem is in some modules that don’t maintain the webpack 5. So create the file ‘config-overrides.js’ in the root of your UI application and copy the next code. /* 
* To build solana dependencies properly
*/
const { ProvidePlugin } = require('webpack');

module.exports = function (config, env) {
    return {
        ...config,
        module: {
            ...config.module,
            rules: [
                ...config.module.rules,
                {
                    test: /\.(m?js|ts)$/,
                    enforce: 'pre',
                    use: ['source-map-loader'],
                },
            ],
        },
        plugins: [
            ...config.plugins,
            new ProvidePlugin({
                process: 'process/browser',
            }),
        ],
        resolve: {
            ...config.resolve,
            fallback: {
                assert: require.resolve('assert'),
                buffer: require.resolve('buffer'),
                stream: require.resolve('stream-browserify'),
                crypto: require.resolve('crypto-browserify'),
            },
        },
        ignoreWarnings: [/Failed to parse source map/],
    };
}; As in the example of the Solana library, it is better to create a separate ‘wrapper’ or ‘provider’ to connect and work with the wallet. const supportedWallets = [ new PhantomWalletAdapter() ];

const WalletWrapper: React.FC<WalletWrapperProps> = ({ children, network }) => {
    return (
        <ConnectionProvider endpoint={network}>
            <WalletProvider wallets={supportedWallets} autoConnect>
                <WalletModalProvider>
                   {children}
                </WalletModalProvider>
            </WalletProvider>
        </ConnectionProvider>
    );
}; And basically, wrap the whole App in it. const App: React.FC<AppProps> = () => {
    return (
        <WalletWrapper network={network}>
            <CompaingsView network={network}/>
        </WalletWrapper>
    );
} From the Anchor program you created, we need one file → crowdfunding_program.json.  Copy it to the UI src folder. This file contains a description of how to communicate with your program, with all types that you defined. cp ./target/idl/crowdfunding_program.json ../crowdfunding-ui/src/idl.json To be able to send and receive data, you require to create the Program class, where you put copied , and . It will be in the CampaignsView component. Idl programId provider const getProgram = () => {
        /* create the provider and return it to the caller */ 
        const connection = new Connection(network, opts.preflightCommitment);
        const provider = new AnchorProvider(connection, wallet as any, opts);
        /* create the program interface combining the idl, program ID, and provider */
        const program = new Program(idl as Idl, programId, provider);
        return program;
    };

const program = getProgram(); This Program class will be responsible to communicate with the crowdfunding program. And to create the first campaign you need some amount of Sols on your wallet and of course wallet itself. I used a wallet, so install the extension to the browser if you haven’t done it yet. Change the network to ‘devnet’ in the settings of the wallet, after airdrop to your wallet. Phantom The create functionality is covered by the method. It basically uses values from inputs like: name, description, targetAmount. And signer here is a User’s wallet. At the end CampaignsView will look like this: createCampaign import React, { ChangeEvent, useState } from 'react';
import {
    AnchorProvider,
    BN,
    Idl,
    Program,
    utils,
    web3,
} from '@project-serum/anchor';
import { useWallet } from '@solana/wallet-adapter-react';
import { WalletMultiButton } from '@solana/wallet-adapter-react-ui';
import { Commitment, Connection, PublicKey } from '@solana/web3.js';
import idl from '../idl.json';
import { Button, FloatingLabel, Form } from 'react-bootstrap';
import CampaignsTable from '../components/campaigns-table';

const opts: { preflightCommitment: Commitment } = {
    preflightCommitment: 'processed',
};

const programId = new PublicKey(idl.metadata.address);

interface CampaignsViewProps {
    network: string;
}

export const CampaignsView: React.FC<CampaignsViewProps> = ({ network }) => {
    const wallet = useWallet();
    const [name, setName] = useState('');
    const [description, setDescription] = useState('');
    const [targetAmount, setTargetAmount] = useState<number>(1);

    const getProgram = () => {
        /* create the provider and return it to the caller */ 
        const connection = new Connection(network, opts.preflightCommitment);
        const provider = new AnchorProvider(connection, wallet as any, opts);
        /* create the program interface combining the idl, program ID, and provider */
        const program = new Program(idl as Idl, programId, provider);
        return program;
    };

    const program = getProgram();

    const onNameChange = (e: ChangeEvent<any>) => {
        setName(e.target.value);
    };
    const onDescriptionChange = (e: ChangeEvent<any>) => {
        setDescription(e.target.value);
    };
    const onTargetAmountChange = (e: ChangeEvent<any>) => {
        setTargetAmount(e.target.value);
    };

    const createCampaign = async () => {
        const [campaign] = await PublicKey.findProgramAddress(
            [
                utils.bytes.utf8.encode('campaign_demo'),
                wallet.publicKey!.toBuffer(),
            ],
            program.programId,
        );
        await program.methods
            .create(name, description, new BN(targetAmount))
            .accounts({
                campaign: campaign,
                user: wallet.publicKey!,
                systemProgram: web3.SystemProgram.programId,
            })
            .rpc();
    };

    return (
        <div className='campaigns-view p-5'>
            {!wallet.connected && <WalletMultiButton />}
            <Form>
                <Form.Group className='mb-3'>
                    <FloatingLabel controlId='name' label='Name'>
                        <Form.Control
                            type='text'
                            placeholder='Name of the campaign'
                            value={name}
                            onChange={onNameChange}
                        />
                    </FloatingLabel>
                </Form.Group>
                <Form.Group className='mb-3'>
                    <FloatingLabel controlId='description' label='Description'>
                        <Form.Control
                            as='textarea'
                            placeholder='Description of the campaign'
                            style={{ height: '150px' }}
                            value={description}
                            onChange={onDescriptionChange}
                        />
                    </FloatingLabel>
                </Form.Group>
                <Form.Group className='mb-3'>
                    <FloatingLabel
                        controlId='targetAmount'
                        label='Target Amount'
                        className='mb-3'
                    >
                        <Form.Control
                            as='input'
                            type='number'
                            placeholder='Targemt amount that need to be reached'
                            value={targetAmount}
                            onChange={onTargetAmountChange}
                        />
                    </FloatingLabel>
                </Form.Group>
                <Form.Group className='mb-3'>
                    <Button variant='primary' onClick={createCampaign}>
                        Create Campaign
                    </Button>
                </Form.Group>
            </Form>
            {wallet.connected && <CampaignsTable  walletKey={wallet.publicKey!} program={program}/>}
        </div>
    );
};

export default CampaignsView; At least the user must have the ability to see all campaigns, then add a list with all of the created campaign accounts. In the program, there is no specific functionality for that. It’s because such functionality is inside the framework. For each account, there is the extension method called ‘all’, you need to call it like . Anchor program.account.campaign.all() const [campaigns, setCampaigns] = useState<ProgramAccount[]>([]);

    const getAllCampaigns = async () => {
        const campaigns = await program.account.campaign.all();
        setCampaigns(campaigns);
    }; The value for donation and withdrawal are hardcoded, but they can be input like for campaign creation. Otherwise and functions are using to invoke specific methods. For each program method invocation Phantom wallet will ask you to approve or decline the transaction. But the call of the particular function is pretty easy. donate withdraw program import React, { useEffect, useState } from 'react';
import { BN, Program, ProgramAccount, web3 } from '@project-serum/anchor';
import { PublicKey } from '@solana/web3.js';
import { Button, Table } from 'react-bootstrap';

interface CampaignsTableProps {
    program: Program;
    walletKey: PublicKey;
}

export const CampaignsTable: React.FC<CampaignsTableProps> = ({
    program,
    walletKey,
}) => {
    const [campaigns, setCampaigns] = useState<ProgramAccount[]>([]);

    const getAllCampaigns = async () => {
        const campaigns = await program.account.campaign.all();
        setCampaigns(campaigns);
    };

    useEffect(() => {
        getAllCampaigns();
    }, [walletKey]);

    const donate = async (campaignKey: PublicKey) => {
        try {
            await program.methods
                .donate(new BN(0.2 * web3.LAMPORTS_PER_SOL))
                .accounts({
                    campaign: campaignKey,
                    user: walletKey,
                    systemProgram: web3.SystemProgram.programId,
                })
                .rpc();
            await getAllCampaigns();
        } catch (err) {
            console.error('Donate transaction error: ', err);
        }
    };

    const withdraw = async (campaignKey: PublicKey) => {
        try {
            await program.methods
                .withdraw(new BN(0.2 * web3.LAMPORTS_PER_SOL))
                .accounts({
                    campaign: campaignKey,
                    user: walletKey,
                })
                .rpc();
        } catch (err) {
            console.error('Withdraw transaction error: ', err);
        }
    };

    const allCampaigns: () => JSX.Element[] = () => {
        return campaigns.map((c, i) => {
            const key = c.publicKey.toBase58();

            return (
                <tr key={key}>
                    <td>{i + 1}</td>
                    <td>{c.account.name}</td>
                    <td>{c.account.description}</td>
                    <td>{c.account.targetAmount.toString()}</td>
                    <td>{(c.account.amountDonated / web3.LAMPORTS_PER_SOL).toString()}</td>
                    <td>
                        <Button
                            className='m-1'
                            variant='primary'
                            onClick={() => donate(c.publicKey)}
                        >
                            Donate
                        </Button>
                        <Button
                            disabled={c.account.owner.toBase58() !== walletKey.toBase58()}
                            className='m-1'
                            variant='danger'
                            onClick={() => withdraw(c.publicKey)}
                        >
                            Withdraw
                        </Button>
                    </td>
                </tr>
            );
        });
    };

    return (
        <>
            <div>Campaigns</div>
            <Table>
                <thead>
                    <tr>
                        <th>#</th>
                        <th>Name</th>
                        <th>Description</th>
                        <th>Target Amount</th>
                        <th>Donated</th>
                        <th></th>
                    </tr>
                </thead>
                <tbody>{allCampaigns()}</tbody>
            </Table>
        </>
    );
};

export default CampaignsTable; Now you can run your program and enjoy it. npm start All data is stored in the blockchain, brilliant.

Build a Solana Crowdfunding App using React

Authors:
(1) Jongmin Lee, Department of Mathematical Science, Seoul National University;
(2) Ernest K. Ryu, Department of Mathematical Science, Seoul National University and Interdisciplinary Program in Artificial Intelligence, Seoul National University. Abstract and 1 Introduction 1.1 Notations and preliminaries 1.2 Prior works 2 Anchored Value Iteration 2.1 Accelerated rate for Bellman consistency operator 2.2 Accelerated rate for Bellman optimality opera 3 Convergence when y=1 4 Complexity lower bound 5 Approximate Anchored Value Iteration 6 Gauss–Seidel Anchored Value Iteration 7 Conclusion, Acknowledgments and Disclosure of Funding and References A Preliminaries B Omitted proofs in Section 2 C Omitted proofs in Section 3 D Omitted proofs in Section 4 E Omitted proofs in Section 5 F Omitted proofs in Section 6 G Broader Impacts H Limitations 6 Gauss–Seidel Anchored Value Iteration This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Jongmin Lee, Department of Mathematical Science, Seoul National University; (2) Ernest K. Ryu, Department of Mathematical Science, Seoul National University and Interdisciplinary Program in Artificial Intelligence, Seoul National University. Authors: Authors: (1) Jongmin Lee, Department of Mathematical Science, Seoul National University; (2) Ernest K. Ryu, Department of Mathematical Science, Seoul National University and Interdisciplinary Program in Artificial Intelligence, Seoul National University. Abstract and 1 Introduction Abstract and 1 Introduction 1.1 Notations and preliminaries 1.1 Notations and preliminaries 1.2 Prior works 1.2 Prior works 2 Anchored Value Iteration 2 Anchored Value Iteration 2.1 Accelerated rate for Bellman consistency operator 2.1 Accelerated rate for Bellman consistency operator 2.2 Accelerated rate for Bellman optimality opera 2.2 Accelerated rate for Bellman optimality opera 3 Convergence when y=1 3 Convergence when y=1 4 Complexity lower bound 4 Complexity lower bound 5 Approximate Anchored Value Iteration 5 Approximate Anchored Value Iteration 6 Gauss–Seidel Anchored Value Iteration 6 Gauss–Seidel Anchored Value Iteration 7 Conclusion, Acknowledgments and Disclosure of Funding and References 7 Conclusion, Acknowledgments and Disclosure of Funding and References A Preliminaries A Preliminaries B Omitted proofs in Section 2 B Omitted proofs in Section 2 C Omitted proofs in Section 3 C Omitted proofs in Section 3 D Omitted proofs in Section 4 D Omitted proofs in Section 4 E Omitted proofs in Section 5 E Omitted proofs in Section 5 F Omitted proofs in Section 6 F Omitted proofs in Section 6 G Broader Impacts G Broader Impacts H Limitations H Limitations 6 Gauss–Seidel Anchored Value Iteration This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

Gauss-Seidel Anchored Value Iteration and Its Benefits

Authors:
(1) Jongmin Lee, Department of Mathematical Science, Seoul National University;
(2) Ernest K. Ryu, Department of Mathematical Science, Seoul National University and Interdisciplinary Program in Artificial Intelligence, Seoul National University. Abstract and 1 Introduction 1.1 Notations and preliminaries 1.2 Prior works 2 Anchored Value Iteration 2.1 Accelerated rate for Bellman consistency operator 2.2 Accelerated rate for Bellman optimality opera 3 Convergence when y=1 4 Complexity lower bound 5 Approximate Anchored Value Iteration 6 Gauss–Seidel Anchored Value Iteration 7 Conclusion, Acknowledgments and Disclosure of Funding and References A Preliminaries B Omitted proofs in Section 2 C Omitted proofs in Section 3 D Omitted proofs in Section 4 E Omitted proofs in Section 5 F Omitted proofs in Section 6 G Broader Impacts H Limitations 5 Approximate Anchored Value Iteration In this section, we show that the anchoring mechanism is robust against evaluation errors of the Bellman operator, just as much as the standard approximate VI. This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Jongmin Lee, Department of Mathematical Science, Seoul National University; (2) Ernest K. Ryu, Department of Mathematical Science, Seoul National University and Interdisciplinary Program in Artificial Intelligence, Seoul National University. Authors: Authors: (1) Jongmin Lee, Department of Mathematical Science, Seoul National University; (2) Ernest K. Ryu, Department of Mathematical Science, Seoul National University and Interdisciplinary Program in Artificial Intelligence, Seoul National University. Abstract and 1 Introduction Abstract and 1 Introduction 1.1 Notations and preliminaries 1.1 Notations and preliminaries 1.2 Prior works 1.2 Prior works 2 Anchored Value Iteration 2 Anchored Value Iteration 2.1 Accelerated rate for Bellman consistency operator 2.1 Accelerated rate for Bellman consistency operator 2.2 Accelerated rate for Bellman optimality opera 2.2 Accelerated rate for Bellman optimality opera 3 Convergence when y=1 3 Convergence when y=1 4 Complexity lower bound 4 Complexity lower bound 5 Approximate Anchored Value Iteration 5 Approximate Anchored Value Iteration 6 Gauss–Seidel Anchored Value Iteration 6 Gauss–Seidel Anchored Value Iteration 7 Conclusion, Acknowledgments and Disclosure of Funding and References 7 Conclusion, Acknowledgments and Disclosure of Funding and References A Preliminaries A Preliminaries B Omitted proofs in Section 2 B Omitted proofs in Section 2 C Omitted proofs in Section 3 C Omitted proofs in Section 3 D Omitted proofs in Section 4 D Omitted proofs in Section 4 E Omitted proofs in Section 5 E Omitted proofs in Section 5 F Omitted proofs in Section 6 F Omitted proofs in Section 6 G Broader Impacts G Broader Impacts H Limitations H Limitations 5 Approximate Anchored Value Iteration In this section, we show that the anchoring mechanism is robust against evaluation errors of the Bellman operator, just as much as the standard approximate VI. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

How Approximate Anchored Value Iteration Handles Errors in Decision-Making Models

Authors:
(1) Jongmin Lee, Department of Mathematical Science, Seoul National University;
(2) Ernest K. Ryu, Department of Mathematical Science, Seoul National University and Interdisciplinary Program in Artificial Intelligence, Seoul National University. Abstract and 1 Introduction 1.1 Notations and preliminaries 1.2 Prior works 2 Anchored Value Iteration 2.1 Accelerated rate for Bellman consistency operator 2.2 Accelerated rate for Bellman optimality opera 3 Convergence when y=1 4 Complexity lower bound 5 Approximate Anchored Value Iteration 6 Gauss–Seidel Anchored Value Iteration 7 Conclusion, Acknowledgments and Disclosure of Funding and References A Preliminaries B Omitted proofs in Section 2 C Omitted proofs in Section 3 D Omitted proofs in Section 4 E Omitted proofs in Section 5 F Omitted proofs in Section 6 G Broader Impacts H Limitations 2 Anchored Value Iteration The accelerated rate of Anc-VI for the Bellman optimality operator is more technically challenging and is, in our view, the stronger contribution. However, we start by presenting the result for the Bellman consistency operator because it is commonly studied in the prior RL theory literature on accelerating value iteration [1, 31, 37, 38] and because the analysis in the Bellman consistency setup will serve as a good conceptual stepping stone towards the analysis in the Bellman optimality setup. This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Jongmin Lee, Department of Mathematical Science, Seoul National University; (2) Ernest K. Ryu, Department of Mathematical Science, Seoul National University and Interdisciplinary Program in Artificial Intelligence, Seoul National University. Authors: Authors: (1) Jongmin Lee, Department of Mathematical Science, Seoul National University; (2) Ernest K. Ryu, Department of Mathematical Science, Seoul National University and Interdisciplinary Program in Artificial Intelligence, Seoul National University. Abstract and 1 Introduction Abstract and 1 Introduction 1.1 Notations and preliminaries 1.1 Notations and preliminaries 1.2 Prior works 1.2 Prior works 2 Anchored Value Iteration 2 Anchored Value Iteration 2.1 Accelerated rate for Bellman consistency operator 2.1 Accelerated rate for Bellman consistency operator 2.2 Accelerated rate for Bellman optimality opera 2.2 Accelerated rate for Bellman optimality opera 3 Convergence when y=1 3 Convergence when y=1 4 Complexity lower bound 4 Complexity lower bound 5 Approximate Anchored Value Iteration 5 Approximate Anchored Value Iteration 6 Gauss–Seidel Anchored Value Iteration 6 Gauss–Seidel Anchored Value Iteration 7 Conclusion, Acknowledgments and Disclosure of Funding and References 7 Conclusion, Acknowledgments and Disclosure of Funding and References A Preliminaries A Preliminaries B Omitted proofs in Section 2 B Omitted proofs in Section 2 C Omitted proofs in Section 3 C Omitted proofs in Section 3 D Omitted proofs in Section 4 D Omitted proofs in Section 4 E Omitted proofs in Section 5 E Omitted proofs in Section 5 F Omitted proofs in Section 6 F Omitted proofs in Section 6 G Broader Impacts G Broader Impacts H Limitations H Limitations 2 Anchored Value Iteration The accelerated rate of Anc-VI for the Bellman optimality operator is more technically challenging and is, in our view, the stronger contribution. However, we start by presenting the result for the Bellman consistency operator because it is commonly studied in the prior RL theory literature on accelerating value iteration [1, 31, 37, 38] and because the analysis in the Bellman consistency setup will serve as a good conceptual stepping stone towards the analysis in the Bellman optimality setup. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

ANCHOR

sayanchor.com

-- employees

Since n.d.

COMPANY RANKING

ANCHOR

EVERGREEN INDEX #3417

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

Anchor WIKI

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

ANCHOR

sayanchor.com

-- employees

Since n.d.

COMPANY RANKING

ANCHOR

EVERGREEN INDEX #3417

RELATED COMPANIESRANK

STORIES ABOUT ANCHOR

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

Anchor WIKI

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