Help with TestNet behavior (works on devnet, but not testnet).

[bwmx]

Hello,

I am in the process of learning reach and getting to grips with it. I have created a simple program that allows a user to list an NFT for sale and then for a buyer to interact with it, which will then send all the funds to the creator of the contract (as one would expect the behaviour to be).

My program works on my local ALGO devnet reach instance. However when I go to deploy my program and test on the algo testnet, the "Buyer" participant does not behave as expected when the Buyer partipant interacts with the contract. Is it expected that it will send the given funds to the contract (price of the nft) and then receive the NFT itself. Below I have attached the error, some teal logic ofc! (hard for me to read this and work out where in my reach code this is being thrown).

Below is how I can calling my code on the front-end, after the creator deploys the contract in a different step. the contractInfo prop is a base64 string of the BigNumber object returned from the .getInfo() call. The selectReachAccount as the name suggests is returning a handle to the currently connected reach account (user has connected their account in a previous step).

I am using the latest version of the reach js sdk ^0.1.12-rc.0 and have updated my reach docker instances to ensure everything is on the same verions. I am also forcing the algo testnet connectors!

If anyone can point out what I'm doing wrong it would be greatly, appreciated.

Regards,

A keen learner

const NFTBuyer = ({ contractInfo }: NFTBuyerProps) => {
  const account = useAppSelector(selectReachAccount);

  const [ctc, setCtc] = useState<any>();

  const [nftId, setNftId] = useState();
  const [price, setPrice] = useState();
  const [creatorAddress, setCreatorAddress] = useState("");

  useEffect(() => {
    const init= async () => {
      const ctcBuyer = account.contract(
        backend,
        JSON.parse(atob(contractInfo))
      );

      const targetNftId = await ctcBuyer.unsafeViews.nftId();
      const targetPrice = await ctcBuyer.unsafeViews.price();
      const creator = await ctcBuyer.unsafeViews.creator();

      // set the contract, we'll use it in the buy step
      setCtc(ctcBuyer);

      setNftId(reach.bigNumberToNumber(targetNftId));
      setPrice(reach.bigNumberToNumber(targetPrice));
      setCreatorAddress(reach.formatAddress(creator));
    };

    if (account) {
      init();
    }
  }, [account]);

  const doBuy = async () => {
    await account.tokenAccept(nftId);

    await backend.Buyer(ctc, {
      onCompleted: async () => {
        console.log(`Sale has been completed, Buyer now owns the NFT.`);
      },
    });
  };

  return (
    <Card elevation={0} background="tint2" padding={minorScale(2)}>
      {nftId && <p>Asset Id: {nftId}</p>}
      {price && <p>Price: {fmt(price)}</p>}
      {creatorAddress && <p>Creator Address: {creatorAddress}</p>}
      <Button onClick={doBuy}>Buy NFT</Button>
    </Card>
  );
};

index.mjs

import * as backend from "./build/index.main.mjs";
const stdlib = loadStdlib(process.env);

// another
const fmt = (x) => stdlib.formatCurrency(x, 8);

// helper func to get balance
const getBalance = async (who) => fmt(await stdlib.balanceOf(who));

const startingBalance = stdlib.parseCurrency(100);

const accCreator = await stdlib.newTestAccount(startingBalance);
console.log("Creator test account created.");

const nft = await stdlib.launchToken(accCreator, "Jack Al", "JAL", {
  supply: stdlib.parseCurrency(1),
});

console.log("NFT created! ID: " + stdlib.bigNumberToNumber(nft.id));

console.log("Creator is launching contract...");
const ctcCreator = accCreator.contract(backend);

console.log("Starting backends...");

console.log("Creator balance before: " + (await getBalance(accCreator)));

const doBuyer = async (ctcInfo) => {
  const accBuyer = await stdlib.newTestAccount(startingBalance);

  console.log("Buyer balance before: " + (await getBalance(accBuyer)));

  const ctcBuyer = accBuyer.contract(backend, ctcInfo);

  const targetNftId = await ctcBuyer.unsafeViews.nftId();
  const targetPrice = await ctcBuyer.unsafeViews.price();
  const creatorAddress = await ctcBuyer.unsafeViews.creator();

  console.log("Target NFT ID: " + stdlib.bigNumberToNumber(targetNftId));
  console.log("Price: " + stdlib.bigNumberToNumber(targetPrice));
  console.log("Creator Addr: " + stdlib.formatAddress(creatorAddress));

  console.log("Sending buyer opt-in request...");
  await accBuyer.tokenAccept(targetNftId);

  await backend.Buyer(ctcBuyer, {
    onCompleted: async () => {
      console.log(`Sale has been completed, Buyer now owns the NFT.`);

      console.log("Buyer balance after: " + (await getBalance(accBuyer)));
    },
  });
};

await ctcCreator.participants.Creator({
  getParams: () => {
    return {
      nftId: nft.id,
      price: stdlib.parseCurrency(10), // 10 network tokens
    };
  },
  onReady: async (price) => {
    console.log(`NFT is for sale at ${fmt(price)} ${stdlib.standardUnit}`);
    console.log(`Contract ID: ${JSON.stringify(await ctcCreator.getInfo())}`);

    // make the buyer buy it now
    doBuyer(await ctcCreator.getInfo());
  },
});

console.log(
  "Creator balance after: " +
    (await getBalance(accCreator)) +
    " " +
    stdlib.standardUnit
);

console.log("Goodbye, Creator and Buyer!");

index.rsh

"reach 0.1";
"use strict";

const CreatorInterface = {
  getParams: Fun(
    [],
    Object({
      nftId: Token, // the nft we're putting up for sale
      price: UInt, // how many network tokens will this cost?
    })
  ),
  onReady: Fun([UInt], Null), // called when it has been created and ready for interaction with the buyer
};

const BuyerInterface = {
  onCompleted: Fun([], Null),
};

export const main = Reach.App(() => {
  const Creator = Participant("Creator", {
    ...CreatorInterface,
  });
  const Buyer = Participant("Buyer", {
    ...BuyerInterface,
  });

  // view
  const V = View({ nftId: Token, price: UInt, creator: Address });

  init();

  Creator.only(() => {
    const { nftId, price } = declassify(interact.getParams());
  });
  // The first one to publish deploys the contract
  Creator.publish(nftId, price);
  // set relevant variables for the view
  V.nftId.set(nftId);
  V.price.set(price);
  V.creator.set(Creator);
  commit();

  // creator sends nft to contract
  Creator.pay([[1, nftId]]);
  commit();

  // notify front-end contract is ready for buyer(s)
  Creator.interact.onReady(price);

  // check only 1 nft has been sent
  assert(balance(nftId) == 1, "NFT quantity can only be 1");

  // The second one to publish always attaches
  Buyer.publish();
  commit();

  // write your program here
  Buyer.pay(price);
  commit();

  Anybody.publish();

  // transfer nft to the buyer
  transfer(1, nftId).to(Buyer);
  // transfer entire balance to the creator (NFT sale amount + fund)
  transfer(balance()).to(Creator);

  commit();
  // notify buyer front-end
  Buyer.interact.onCompleted();
  exit();
});

[jeapostrophe]

Is index.mjs the program that works on DevNet, but then the first sample that says NFTBuyer is the one that is failing on the TestNet?

You should delete Buyer.publish(); and Anybody.publish(); from your program. They don't do anything useful and just cost money.

[bwmx]

Thanks Jay, removing both those calls fixed my program and now it behaves as predicted. I don't know why, but it did!

[jeapostrophe]

Weird!

[jeapostrophe]

My guess is that there was a race to be Anybody