Move is an executable bytecode language used to implement custom transactions and smart contracts. 

Move

Traditionally, users engaging with decentralized aplications (dApps) face a common hurdle: gas fees. These Sui gas fees in our case, required to execute transactions on the blockchain, often deter new users from fully embracing the potential of Web3. However, Sui innovative sponsored transaction feature eliminates this obstacle, empowering builders to cover the gas fees for their app transactions. This revolutionary functionality paves the way for a seamless user experience, encouraging broader adoption of decentralized applications.

- TheMoveDev [GitHub](https://github.com/the-move-dev);
- SuiQL [GitHub Repository](https://github.com/the-move-dev/suiql);

If you have any questions, you can ask them [here](https://move.peeranha.io/tutorials).

# Sponsored Transaction Workflow
Sui's sponsored transaction workflow is a well-orchestrated process that ensures smooth and gas fee-free transactions for end-users. Here's a breakdown of the steps involved.

![](https://ipfs-cdn.peeranha.io/QmSBR48GM2TPhWLsdUMJ2b96AxJSKQoU7rfEm881npbB98)   

### User Initiates an Action
The process kicks off when a user initializes a `GasLessTransactionData` transaction, indicating their intent to perform a specific action within a dApp.
### dApp Creates a Sui Transaction Block
At the heart of the sponsored transaction workflow lies the dApp's ability to create a Transaction Block. This block encapsulates all the necessary data, including the user's intent, the action to be performed, and any associated parameters.
### Transmission of `GasLessTransactionData`
The `GasLessTransactionData` is sent to the sponsor, a key participant in the sponsored transaction framework, with a signature request. This data serves as the foundation for the upcoming transaction.
### Validation and Transaction Data Construction
The sponsor validates the received transaction and constructs `TransactionData`, incorporating the necessary gas fees. This step ensures that the transaction is properly funded for execution on the Sui blockchain.
### Transaction Signing
The sponsor signs the `TransactionData`, indicating their approval and commitment to the transaction. The private key required for this signature is securely stored in AWS Secrets Manager, ensuring the utmost security.
### Verification and Dual Signing by the User
The signed `TransactionData`, along with the sponsor's signature, is sent back to the user. The user verifies the transaction details and signs the `TransactionData` once more, creating a dual-signed transaction ready for execution.
### Transaction Execution on Sui
The dual-signed transaction is submitted to the Sui network via a Sui node (full node) or the sponsor. Sui processes the transaction, executing the specified action within the dApp, all without requiring the user to pay any gas fees.
### User Notification
Finally, the user is notified by a dApp that the transaction is sponsored and sent. 
## Implementing Sui Sponsored Transactions: A Developer's Perspective
To implement sponsored transactions, developers interact with the Sui API or Sponsored Transaction API, making use of the `sui-sign-sponsored-transaction` Lambda function. Here's a glimpse of the client-side code that facilitates this process:

```js
const response = await fetch('http://localhost:5000/blockchain/sui-sign-sponsored-transaction', {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    sender: wallet.address,
    module: libName,
    action,
    arguments: data,
  }),
});

const sponsorSignedTransaction = await response.json();
const transactionBlock = TransactionBlock.from(sponsorSignedTransaction?.transactionBlockBytes);

const senderSignedTransaction = await wallet.signTransactionBlock({
  transactionBlock,
});

const executeResponse = await provider.executeTransactionBlock({
  transactionBlock: sponsorSignedTransaction?.transactionBlockBytes,
  signature: [sponsorSignedTransaction?.signatureBytes, senderSignedTransaction.signature],
  options: { showEffects: true },
  requestType: 'WaitForLocalExecution',
});

```

This client-side code acts as a bridge between the user, the sponsor, and the Sui blockchain, enabling the seamless execution of gas fee-free transactions.
## Conclusion
Sui's sponsored transaction feature represents a paradigm shift in the world of decentralized applications, removing a significant barrier to entry for users. Through our exploration of this innovative functionality, we've gained valuable insights that have shaped our approach to building user-friendly dApps.

Feel free to leave your questions [here](https://move.peeranha.io/tutorials).

Sui Sponsored Transactions - Basic Integrations Examples

For businesses and developers, integrating with chains like Sui offers a unique opportunity to innovate and create transformative solutions. In this series, we delve into our journey of building on Sui, shedding light on the intricacies of integrations, focusing on event listeners and webhooks, which have been integral components of TheMoveDev and SuiQL, Sui indexing GraphQL Event API made by Peeranha.

- TheMoveDev [GitHub](https://github.com/the-move-dev);
- SuiQL [GitHub Repository](https://github.com/the-move-dev/suiql);

If you have any questions, you can ask them [here](https://move.peeranha.io/).

The code is implemented in TypeScript and runs within the AWS Cloud environment using serverless technologies. [Serverless ](https://www.serverless.com/) is used for deployments. [Serverless Offline](https://www.serverless.com/plugins/serverless-offline) is used to run the code locally.  

# Sui Events Listeners and Webhooks: A Brief Overview
Blockchain networks are inherently decentralized, making real-time data integration a challenging feat. This is where event listeners and webhooks come into play. **Event Listeners** are mechanisms that constantly monitor blockchain activity, identifying and capturing specific events of interest. **Webhooks**, on the other hand, are HTTP callbacks triggered by these events, allowing seamless communication between different applications.  

![](https://ipfs-cdn.peeranha.io/QmTKCXT272jeaLxT26LZHarcCC1vqsBnzjr768eCG6iQUf)

## The Sui Integration Architecture
Our integration journey with Sui involved a comprehensive architecture comprising several key components.

### Events Listener
The **Events Listener**, a robust ECS Fargate task, plays a pivotal role in our integration setup. It continuously polls new events from the Sui nodes (Sui full node), ensuring that our system stays up-to-date with the latest blockchain activities.  

### Sui Events Listener Queue
Events identified by the **Events Listener** are added to the **Sui Listener Queue**, a FIFO SQS queue. This queue acts as an intermediary storage, enabling efficient event processing and management.  

### Webhook Invoker
Responsible for invoking webhooks, the **Webhook Invoker** is a Lambda function that ensures seamless communication between our system and external applications. It acts as a bridge, facilitating the transmission of event data to the designated endpoints.

### Event Bridge
The **Event Bridge**, a pivotal component of our architecture, invokes the **Webhook Invoker** Lambda whenever new items are added to the **Sui Listener Queue**. This real-time triggering mechanism ensures prompt webhook invocations.

### Webhook
The **Webhook**, implemented as an AWS Lambda function, processes individual events received from the Sui blockchain. This component plays a crucial role in interpreting the event data and executing specific actions based on the event type.

## Workflow: How It All Comes Together
Understanding the workflow is essential to grasp the seamless operation of our integration architecture.

### Events Listener Operation

- The Events Listener operates in a continuous loop, making RPC API calls to `suix_queryEvents` to retrieve new events associated with a configured package ID.
- The Events Listener maintains a cursor value in DynamoDB, ensuring it reads events chronologically.
### Adding Events to Sui Listener Queue

- Whenever the Events Listener identifies new events, it adds them to the Sui Listener Queue for further processing.
### Event Bridge Trigger

- The AWS Event Bridge monitors the Sui Listener Queue and triggers the Webhook Invoker Lambda as soon as new items are added. This ensures real-time event processing.

### Webhook Invocation

- The Webhook Invoker, once triggered, invokes the Webhook Lambda function for each event present in the queue.

## Running Locally - Dev Playground

- Serverless offline plugin is used to run the solution locally. Listener runs in ECS task in the cloud. ECS is not available for serverless offline. For that reason, uncomment the `sui-events-listener` lambda function in serverless.yml. This function will read new events from the blockchain once per minute.
- Install dependencies:

```
npm install

```

- Install DynamoDb:

```
npm run dynamodb:install
```

If you are getting an error `Error getting DynamoDb local latest tar.gz location undefined: 403` on this step then it means that there is still a known issue in serverless-dynamodb-local. It is discussed [here](https://github.com/99x/serverless-dynamodb-local/issues/294) or you can leave your question on [Sui Move Q&A](https://move.peeranha.io/).

- In `node_modules/dynamodb-localhost/dynamodb/config.json URL to https://s3.us-west-2.amazonaws.com/dynamodb-local/dynamodb_local_latest.tar.gz` (add s to `http`);
- In `node_modules/dynamodb-localhost/dynamodb/installer.j `change `http` to `https`;
- To start services run:

```
npm run dev

```

## Event Listener Deployment to AWS

1. Install AWS CLI;
2. Configure AWS CLI;

```
aws configure
```

1. Modify values in `stages\test.yml` and `stages\prod.yml`;
2. Start deployment;

```
npm run deploy:test
```

or

```
npm run deploy:prod
```

### To be continued...
In this first part of our series on Sui integrations, we've explored the foundational concepts of event listeners and webhooks, unraveling the intricate architecture behind our integration with the Sui blockchain. Stay tuned for the upcoming parts, where we'll delve deeper into our journey, sharing insights, challenges, and innovative solutions that have shaped our experience.

Feel free to leave your questions [here](https://move.peeranha.io/).

Sui Move Events Listeners and Webhooks - Basic Integrations Examples

The InterPlanetary File System (IPFS) is a protocol, hypermedia and file sharing peer-to-peer network for storing and sharing data in a distributed file system.

IPFS

Sui is a Layer 1 protocol blockchain designed as the first internet-scale programmable blockchain platform.

I'm working on a project using Sui.js and I need to connect to a custom RPC URL instead of using the default testnetConnection. How can I achieve this? I've seen a lot about connecting via testnetConnection, but I need guidance on using a custom setup for my RPC endpoint.

How to switch from testnetConnection to custom RPC in Sui.js?

I'm working on a smart contract and I'm struggling to send SUI tokens to a specific wallet address. I have used the `transfer::public_transfer` function as suggested in the Sui framework but didn't succeed. Here's what I tried, but I encountered errors. What could be wrong and how can I fix it?

How to send SUI to a wallet address in a smart contract?

I'm working with the Move language and I want to create a function that retrieves the amount of SUI coins held by a specific address. Is there an existing module or function in Move that can help me achieve this?

How to get the amount of SUI coins using Move language?

I'm working on a website and I need to display the current market cap and price of our coin. I've found an API related to our coin, but I'm unsure how to use it. Could someone guide me on how I can get this information through the API?

How to use API endpoint for coin data on a website?

I'm trying to reduce the number of user clicks in my application process. Currently, I have two separate actions: deploying a contract and sending a PTB. I'm looking for a way to merge these into a single action to make things simpler for the users. Is it possible to deploy a contract and simultaneously call some of its functions within a single PTB?

Can deploying and calling a contract be done in one step?

I'm developing a game where users constantly input data that modifies an NFT. I want to minimize user friction by automating transactions without requiring user signatures for each step. Is there a way to handle this, maybe using session tokens or similar methods to submit transactions from a user's wallet without signing each one?

Can I automate user transactions on Sui without signing?

How can I correctly implement the transfer of SUI to a specific wallet address using smart contract code?

SUI transfer in Smart Contract code

What might be causing the VMVerificationOrDeserializationError in the fund_ido function of the Sui Move contract?

 VMVerificationError in Move IDO contract

Is there a ternary operator in the Move programming language?

What is the 'native' keyword in Move?

Is there a function or module in Move to get coin balances from a specific SUI address?

Discussion

Share your thoughts.

Posts

New Identity.