Sponsored Transaction TypeScript Tutorial

import { 
    Connection, 
    Ed25519Keypair, 
    JsonRpcProvider, 
    RawSigner, 
    TransactionBlock
} from "@mysten/sui.js";
import { rpcClient } from "typed-rpc";

// gas budget for our transactions, in MIST
const GAS_BUDGET = 5000000;

// Shinami Gas Station endpoint:
const SPONSOR_RPC_URL = "https://api.shinami.com/gas/v1/<GAS_ACCESS_KEY>";

// Shinami Sui Node endpoint:
const connection = new Connection({
    fullnode: 'https://api.shinami.com/node/v1/<NODE_ACCESS_KEY>'
});
const suiProvider = new JsonRpcProvider(connection);

// The sui address of the initiator of the transaction
const SENDER_ADDRESS = "<SUI_ADDRESS>";

// We will need a keypair and signer for this SENDER_ADDRESS. You can do this in one of two ways:

// Create the sender's key pair from the sender's private key
const SENDER_PRIVATE_KEY = "<PRIVATE_KEY>";
const buf = Buffer.from(SENDER_PRIVATE_KEY, "base64");
const keyPair = Ed25519Keypair.fromSecretKey(buf.slice(1));

// Or create it from the sender's recovery phrase
const keyPair = Ed25519Keypair.deriveKeypair("<RECOVERY_PHRASE>");

// Create a signer for the sender's keypair
const signer = new RawSigner(keyPair, suiProvider);

// Setup for issuing json rpc calls to the gas station for sponsorship.
interface SponsoredTransaction {
    txBytes: string;
    txDigest: string;
    signature: string;
    expireAtTime: number;
    expireAfterEpoch: number;
}
type SponsoredTransactionStatus = "IN_FLIGHT" | "COMPLETE" | "INVALID";

interface SponsorRpc {
    gas_sponsorTransactionBlock(txBytes: string, sender: string, gasBudget: number): SponsoredTransaction;
    gas_getSponsoredTransactionBlockStatus(txDigest: string): SponsoredTransactionStatus;
}
const sponsor = rpcClient<SponsorRpc>(SPONSOR_RPC_URL);

// Create a programmable transaction block to send an object from the sender to the recipient
const progTxnTransfer = () => {
    // The receiver of a transaction
    const RECIPIENT_ADDRESS = "<SUI_ADDRESS>";

    // For transferring objects transaction
    const OBJECT_TO_SEND = "<OBJECT_ID>";

    const txb = new TransactionBlock();
    
    txb.transferObjects(
        [txb.object(OBJECT_TO_SEND)],
        txb.pure(RECIPIENT_ADDRESS)
    );
    return txb;
}

// Create a programmable transaction block to split a coin into different amounts
const progTxnSplit = () => {
    const COIN_TO_SPLIT = "<COIN_OBJECT_ID>";

    const txb = new TransactionBlock();
    
    // Split two new coins out of COIN_TO_SPLIT, one with 10000 balance, and the other with 20000
    const [coin1, coin2] = txb.splitCoins(
        txb.object(COIN_TO_SPLIT),
        [txb.pure(10000), txb.pure(20000)]
    );
    // Each new object created in a transaction must have an owner
    txb.transferObjects(
        [coin1, coin2],
        txb.pure(SENDER_ADDRESS)
    );
    return txb;
}

// Create a programmable transaction block to merge two coins into a target coin
const progTxnMerge = () => {
    const COIN_TARGET = "<COIN_OBJECT_ID>";
    const COIN_SOURCE1 = "<COIN_OBJECT_ID>";
    const COIN_SOURCE2 = "<COIN_OBJECT_ID>";
    const txb = new TransactionBlock();
    txb.mergeCoins(txb.object(COIN_TARGET), [txb.object(COIN_SOURCE1), txb.object(COIN_SOURCE2)]);
    return txb;
}

// Create a programmable transaction block to issue a move call
const progTxnMoveCall = () => {
    const txb = new TransactionBlock();
    txb.moveCall({
        target: "<PACKAGE_ADDRESS>::<MODULE_NAME>::<METHOD_NAME>",
        arguments: [
            // these are args custom to your move call
            txb.pure(<PURE_VALUE>),
            txb.pure(<PURE_VALUE>),
            txb.object("<OBJECT_ID>")
            ...
        ]
    });
    return txb;
}

const sponsorTransactionE2E = async() => {
    // Get the gasless TransactionBlock for the desired programmable transaction
    const gaslessTxb = progTxnTransfer();
    //const gaslessTxb = progTxnSplit();
    //const gaslessTxb = progTxnMerge();
    //const gaslessTxb = progTxnMoveCall();

    // generate the bcs serialized transaction data without any gas object data
    const gaslessPayloadBytes = await gaslessTxb.build({ provider: suiProvider, onlyTransactionKind: true});

    // convert the byte array to a base64 encoded string
    const gaslessPayloadBase64 = btoa(
        gaslessPayloadBytes
            .reduce((data, byte) => data + String.fromCharCode(byte), '')
    );

    // Send the gasless programmable payload to Shinami Gas Station for sponsorship, along with the sender and budget
    const sponsoredResponse = await sponsor.gas_sponsorTransactionBlock(gaslessPayloadBase64, SENDER_ADDRESS, GAS_BUDGET);

    // The transaction should be sponsored now, so its status will be "IN_FLIGHT"
    const sponsoredStatus = await sponsor.gas_getSponsoredTransactionBlockStatus(sponsoredResponse.txDigest);
    console.log("Sponsorship Status:", sponsoredStatus);

    ...

        ...

    // Sign the full transaction payload with the sender's key.
    const senderSig = await signer.signTransactionBlock({transactionBlock: TransactionBlock.from(sponsoredResponse.txBytes)});
    
    // If you prefer not to use the sui typescript sdk, the signer also supports signing over the bytes
    //const senderSig = await signer.signTransactionBlock({ transactionBlock: Uint8Array.from(atob(sponsoredResponse.txBytes), c => c.charCodeAt(0)) });

    // Send the full transaction payload, along with the gas owner and sender's signatures for execution on the Sui blockchain
    const executeResponse = await suiProvider.executeTransactionBlock(
        {
            transactionBlock: sponsoredResponse.txBytes,
            signature: [senderSig.signature, sponsoredResponse.signature],
            options: {showEffects: true},
            requestType: 'WaitForLocalExecution'
        }
    );
    console.log("Execution Status:", executeResponse.effects?.status.status);
}

// Run the end-to-end sponsorship and execution of the transaction.
sponsorTransactionE2E();