Interaction with JARJAR AI Oracle

Let's build a smart contract that interact with JarJar Oracle

This example show how to generate inference with DALLE-3

jarjar_ai_oracle = "0xf74a927c2fe57604e0dd07907a9f62d74d7b5b1b466381abdbcd0ee18683d125"

As you see your smart contract will need to implement only two function to generate AI

One that need to send prompt and generation data, and the other one (callback function) that will receive the inference result

Let's deep dive in generate function of a dummy smart contract:

To generate and IA inference with your smart contract you need to provide three dynamic field:

• prompt_data

• callback_data

• model_name

All this variable are string, but prompt_data and callback_data are stringified JSON object that the validator will parse to accommodate to the requirement of every model and to bring versatility to the smart contract

You also need 2 non dynamic fields:

• price_model :

  0x44415a725e21bd01933568e26c37e9d73573abe5279af5445df6b0a68b3ccbf3

• ownerCap:

  0xa6176e30e26d392111d8ed3552f342116273b402ed512e811e631b90118aa11b

public fun generate(
        prompt_data: String,
        callback_data: String,
        model_name: String,
        mut payment: Coin<SUI>,
        price_model: &mut price_model::PriceModel,
        ownerCap: &mut jarjar_ai_oracle::OwnerCap,
        ctx: &mut TxContext
        ) {
        let value: u64 = coin::value(&payment);
        let inferenceCost = price_model::get_price(price_model, &model_name);
        assert!(value == inferenceCost, ERROR_INSUFFICIENT_FUNDS);

        let inference_coin = coin::take(coin::balance_mut(&mut payment), inferenceCost, ctx);
        jarjar_ai_oracle::generate(prompt_data, callback_data, model_name, inference_coin, price_model, ownerCap,ctx);

        let to = jarjar_ai_oracle::get_owner_cap_address(ownerCap);
        transfer::public_transfer(payment, to);
    }

Let's see how to call this generate function from TypeScript now:

• Stringify your prompt

    const prompt_data = tx.pure.string(
      JSON.stringify({
        prompt: "A cute dog",
        size: "1024x1024",
      }),
    );

• Stringify your callback_data (callback_data are the parameter that the validator will add when calling your function after generation)

    const callback_data = tx.pure.string(
      JSON.stringify([
        "A dog",
        "Desc of a dog",
      ]),
    );

• Model name

const model_name = tx.pure.string("dalle_3");

• payment

  const [coin] = tx.splitCoins(tx.gas, [100000000]);

• price_model

  const price_model = tx.object(0x44415a725e21bd01933568e26c37e9d73573abe5279af5445df6b0a68b3ccbf3);

• ownercap

  const ownercap = tx.object(0xa6176e30e26d392111d8ed3552f342116273b402ed512e811e631b90118aa11b);

Let's call the generation function from our smart contract with all this data now

tx.moveCall({
      arguments: [
        prompt_data, // prompt_data: String,
        callback_data, // callback_data: String,
        model_name, // model_name: String,
        coin, // mut payment: Coin<SUI>,
        price_model, // price_model: &mut PriceModel,
        ownercap, // ownerCap: &mut jarjar_ai_oracle::OwnerCap,
      ],
      target: `${import.meta.env.VITE_MINT_PACKAGE_ID}::${import.meta.env.VITE_MODULE_NAME}::${import.meta.env.VITE_MODULE_FUNCTION}`,
    });

Here it is, you just writed your first onchain smart contact inference 🎉

But how the validator will return you the data ??

The Callback

async buildCallbackTx(
    prompt_result: string,
    sender: string,
    packageId: string,
    moduleId: string,
    callback_data: string,
  ) {
    const tx = new Transaction();
    const parsed_callback_data = JSON.parse(callback_data).map((item) =>
      tx.pure.string(item),
    );

    const ownercap = tx.object(process.env.ORACLE_OWNER_CAP_ADDR);
    tx.moveCall({
      arguments: [
        tx.pure.string(prompt_result),
        tx.pure.address(sender),
        ...parsed_callback_data,
        ownercap,
      ],
      target: `${packageId}::${moduleId}::callback`,
    });
    return tx;
  }

Here is the validator code that build the callback transaction, as you can see you need in your smart contract a function called callback as this is the one the validator will send the request

Here is an example of Move code to receive the validator callback call

public fun callback(ai_gen_result:String, sender: address, name:String, description:String, ownerCap: &mut jarjar_ai_oracle::OwnerCap, ctx: &mut TxContext) { 
     assert!(tx_context::sender(ctx) == jarjar_ai_oracle::get_owner_cap_address(ownerCap), ERROR_NOT_ENOUGHT_PERMISSION);

     let id = object::new(ctx);
     let nft = JarJarNFT { id, name, image_url:ai_gen_result, description };
     transfer::public_transfer(nft, sender);
}

Fisrt this function check that it was called by the owner of the validator to ensure no random people is calling it

Then it simply build and NFT with the callback data and send it back to the user that requested the inference, this is only an example and you could do whatever you want with this data :)