Shinami

https://docs.shinami.com
Admin
Shinami provides developer tools and services, including API access, guides, and product overviews,...
Tokens:527,477
Snippets:2,580
Trust Score:7.1
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install Shinami Clients SDK

Source: https://docs.shinami.com/api-docs/aptos/node-service/graphql/overview

Installs the Shinami Clients SDK, which simplifies interacting with the Shinami API. This is a prerequisite for using the TypeScript examples.

```bash
npm install @shinami/clients
```

--------------------------------

### Get Gas Price with Shinami TypeScript SDK

Source: https://docs.shinami.com/api-docs/sui/node-service/json-rpc/overview

This example shows how to retrieve the reference gas price using the Shinami Clients TypeScript SDK. First, install the SDK using `npm install @shinami/clients`. The `createSuiClient` function initializes the client with your Shinami Node API Key.

```typescript
import { createSuiClient } from "@shinami/clients/sui";

const nodeClient = createSuiClient({{nodeTestnetAccessKey}}); 

const gasPrice = await nodeClient.getReferenceGasPrice();
```

--------------------------------

### cURL: Encode and Sponsor Transaction Example

Source: https://docs.shinami.com/api-docs/movement/gas-station/api

This cURL example shows a basic POST request to the Shinami Gas Station API for encoding and sponsoring a transaction. It includes the 'X-API-Key' header and a JSON body with the method 'gas_encodeAndSponsorTransaction' and placeholder parameters. This serves as a starting point for actual transaction requests.

```bash
curl https://api.us1.shinami.com/movement/gas/v1/ \
  -X POST \
  -H 'X-API-Key: {{gasStationAccessKey}}' \
  -H 'Content-Type: application/json' \
  -d '{
  "jsonrpc": "2.0",
      "method": "gas_encodeAndSponsorTransaction",
          "params": [{

```

--------------------------------

### Create or Retrieve zkLogin Wallet with Shinami TypeScript SDK

Source: https://docs.shinami.com/api-docs/sui/wallet-services/zklogin-wallet-api

This example shows how to use the Shinami Clients SDK for TypeScript to get or create a zkLogin wallet. It initializes the ZkWalletClient with an access key and then calls `getOrCreateZkLoginWallet` with the signed JWT. Ensure the JWT is prepared with the correct nonce as per zkLogin requirements.

```typescript
import { ZkWalletClient } from "@shinami/clients/sui";

// Obtain wallet access key from your Shinami web portal.
const zkWalletClient = new ZkWalletClient({{walletAccessKey}});

// Prepare a nonce according to the zkLogin requirements.
// Obtain a valid jwt with that nonce from a supported OpenID provider.

// Get zkLogin wallet salt.
const walletInfo = await zkWalletClient.getOrCreateZkLoginWallet({{jwt}});
```

--------------------------------

### Configure and Use Shinami with Sui CLI

Source: https://docs.shinami.com/api-docs/sui/node-service/json-rpc/overview

This guide explains how to set up and use the Sui CLI with a Shinami node. It involves creating a new environment (`new-env`) with Shinami's RPC and WebSocket URLs, aliasing it, and then switching to that environment (`switch`). Finally, it shows how to check your gas coins using the `sui client gas` command.

```bash
# Create a new env connecting to Shinami node service. It's tied to the
#  network (Testnet, Mainnet) that the API access key you use is tied to.
# Note that the faucet won't work with the Shinami URL set, so you may want
#  to ask for Testnet coins before switching to your Shinami env
sui client new-env \
  --alias shinami \
  --rpc https://api.us1.shinami.com:443/sui/node/v1/YOUR_NODE_API_KEY_WHICH_IS_TIED_TO_A_NETWORK \
  --ws wss://api.us1.shinami.com:443/sui/node/v1/YOUR_NODE_API_KEY_WHICH_IS_TIED_TO_A_NETWORK

# Activate the Shinami env
sui client switch --env shinami

# Ask for the gas coins owned by the address (with a suix_getOwnedObjects call to Shinami)
sui client gas
```

--------------------------------

### Get Sui Move Function Structure (TypeScript)

Source: https://docs.shinami.com/api-docs/sui/node-service/json-rpc/read-api-system-and-move-data

This TypeScript example utilizes the Shinami Clients SDK to fetch the normalized structure of a Move function. After installing the SDK, you can instantiate a Sui client and call the getNormalizedMoveFunction method with the required parameters. The function's details are then logged to the console.

```typescript
import { createSuiClient } from "@shinami/clients/sui";

const nodeClient = createSuiClient(NODE_SERVICE_API_KEY);

const resp = await nodeClient.getNormalizedMoveFunction({
    package: "0x64254dd3675459aae82e063ed6276f99fe23616f75fdb0b683f5d2c6024a0bd7",
    module: "bird_entries",
    function: "mineBird"
});

console.log(resp);
```

--------------------------------

### Build, Sponsor, Sign, and Submit Aptos Transaction with Shinami (TypeScript)

Source: https://docs.shinami.com/api-docs/movement/gas-station/api

This TypeScript example shows the complete process of building, signing, sponsoring, and submitting an Aptos transaction using Shinami's Gas Station and the Aptos TS SDK. It includes setting transaction expiration, handling fee payers, and offers two distinct methods for sponsorship and submission. Dependencies include `@shinami/clients/aptos` and `@aptos-labs/ts-sdk`.

```typescript
// 1. Import the required dependencies
import { GasStationClient } from "@shinami/clients/aptos";
import { Account, Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";

// 2. Create a Movement client 
const config = new AptosConfig({
    network: Network.CUSTOM,
    fullnode: 'https://testnet.movementnetwork.xyz/v1',
    faucet: 'https://faucet.testnet.movementnetwork.xyz/',
});
const movementClient = new Aptos(config);

// 3. Generate a sender. In production, you won't be using a newly generated account
//  each time. The sender will often be a wallet the user connected or an embedded
//  wallet you control for the user. This just makes for a shorter example.
const sender = Account.generate({});

// 4. Create a Shinami Gas Station client for sponsoring our transactions.
const SHINAMI_TESTNET_GAS_KEY = "{{MOVEMENT_TESTNET_GAS_STATION_ACCESS_KEY}}";
const gasStationClient = new GasStationClient(SHINAMI_TESTNET_GAS_KEY);

// 5. Build a transaction
// This transaction makes a function call to a module we've deployed on Testnet
// You may be able to use the SDK's default expiration (20 seconds at time of writing) 
// but you must set the expiration time less than 1 hour from now.
const FIVE_MINUTES_FROM_NOW_IN_SECONDS = Math.floor(Date.now() / 1000) + (5 * 60);
const transaction = await movementClient.transaction.build.simple({
    sender: sender.accountAddress,
    withFeePayer: true,
    data: {
        function: "0xe56b2729723446cd0836a7d1273809491030ccf2ec9935d598bfdf0bffee4486::message::set_message",
        functionArguments: ["test message"]
    },
    options: {
        expireTimestamp: FIVE_MINUTES_FROM_NOW_IN_SECONDS
    }
});

// 6. Obtain the sender's signature
const senderAuthenticator = movementClient.transaction.sign({
    signer: sender,
    transaction
});

//
// OPTION 1: SPONSOR AND SUBMIT IN ONE REQUEST
//

// 7a. Ask Shinami to sponsor and submit the transaction
//    To run this version, un-comment it and comment out the code for 7b and 7b.2
// const pendingTx = await gasStationClient.sponsorAndSubmitSignedTransaction(
//     transaction,
//     senderAuthenticator
// );

//
// OPTION 2: SPONSOR AND SUBMIT IN TWO REQUESTS
//

// 7b. Send the transaction to Shinami for sponsorship
const feePayerAuthenticator = await gasStationClient.sponsorTransaction(transaction);

// Note that our SDK updates the transaction's feePayer address on a successful sponsorship.
// The sender and any secondary signers can sign the transaction with the actual feePayer's
// address or with the special `0x0` feePayer address given when the feePayer transaction is
// built (which we do above). However, the transaction must be submitted with the actual
// feePayer's address. If you don't use our TS SDK, you must explictly set it with the
// `feePayer.address` value we return when you ask for a sponsorship.
console.log("transaction.feePayerAddress post-sponsorship:", transaction.feePayerAddress?.bcsToHex().toString());

// 7b.2. Submit the transaction to the Movement blockchain
const pendingTx = await movementClient.transaction.submit.simple({
    transaction,
    senderAuthenticator,
    feePayerAuthenticator,
});

// 8. Poll the Movemnent node until the transaction is finalized 
const executedTransaction = await movementClient.waitForTransaction({
    transactionHash: pendingTx.hash
});

```

--------------------------------

### Get Coin Metadata using Shinami TypeScript SDK

Source: https://docs.shinami.com/api-docs/sui/node-service/json-rpc/read-api-objects-coins

This example shows how to retrieve coin metadata using the Shinami Clients SDK for TypeScript. After installing the SDK, you can create a SUI client and call the getCoinMetadata method with the desired coin type. The response object contains detailed information about the coin.

```typescript
import { createSuiClient } from "@shinami/clients/sui";

const nodeClient = createSuiClient(NODE_SERVICE_API_KEY);

const resp = await nodeClient.getCoinMetadata({
    coinType: "0x2::sui::SUI"
});

console.log(resp);
```

--------------------------------

### Aptos Transaction Lifecycle with Shinami Sponsorship (TypeScript)

Source: https://docs.shinami.com/api-docs/aptos/gas-station/api

This snippet illustrates the complete process of building, signing, sponsoring, and submitting an Aptos transaction. It requires the Shinami Clients SDK and the Aptos TS SDK. The example shows how to set transaction options like expiration time and fee payer, and demonstrates two approaches for sponsorship and submission: a single request and a two-step process.

```typescript
// 1. Import the required dependencies
import { GasStationClient } from "@shinami/clients/aptos";
import { Account, Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";

// 2. Create an Aptos client and generate an account to act as the sender
const aptos = new Aptos(new AptosConfig({ network: Network.TESTNET }));

// 3. Generarte a sender. In production, you won't be using a newly generated account
//  each time. The sender will often be a wallet the user connected or an embedded
//  wallet you control for the user. This just makes for a shorter example.
const sender = Account.generate({});

// 4. Create a Shinami Gas Station client for sponsoring our transactions.
const SHINAMI_TESTNET_GAS_KEY = "{{APTOS_TESTNET_GAS_STATION_ACCESS_KEY}}";
const gasStationClient = new GasStationClient(SHINAMI_TESTNET_GAS_KEY);

// 5. Build a transaction
// This transaction makes a function call to a module we've deployed on Testnet
const FIVE_MINUTES_FROM_NOW_IN_SECONDS = Math.floor(Date.now() / 1000) + (5 * 60);
const transaction = await aptos.transaction.build.simple({
    sender: sender.accountAddress,
    withFeePayer: true,
    data: {
      function: "0xc13c3641ba3fc36e6a62f56e5a4b8a1f651dc5d9dc280bd349d5e4d0266d0817::message::set_message",
      functionArguments: ["test message"]
    },
    options: {
        expireTimestamp: FIVE_MINUTES_FROM_NOW_IN_SECONDS
    }
});

// 6. Obtain the sender's signature
const senderAuthenticator = aptos.transaction.sign({
        signer: sender,
        transaction
});

//
// OPTION 1: SPONSOR AND SUBMIT IN ONE REQUEST
//

// 7. Ask Shinami to sponsor and submit the transaction
const pendingTx = await gasStationClient.sponsorAndSubmitSignedTransaction(
    transaction,
    senderAuthenticator
);

//
// OPTION 2: SPONSOR AND SUBMIT IN TWO REQUESTS
//

// 7. Send the transaction to Shinami for sponsorship
const feePayerAuthenticator = await gasStationClient.sponsorTransaction(transaction);

// Note that our SDK updates the transaction's feePayer address on a successful sponsorship.
// The sender and any secondary signers can sign the transaction with the actual feePayer's
// address or with the special `0x0` feePayer address given when the feePayer transaction is
// built (which we do above). However, the transaction must be submitted with the actual
// feePayer's address. If you don't use our TS SDK, you must explictly set it with the
// `feePayer.address` value we return when you ask for a sponsorship.
console.log("transaction.feePayerAddress post-sponsorship:", transaction.feePayerAddress);

// 8. Submit the transaction to the Aptos blockchain
const pendingTx = await aptos.transaction.submit.simple({
    transaction,
    senderAuthenticator,
    feePayerAuthenticator,
});

```

--------------------------------

### Get Total Transaction Blocks - cURL Response

Source: https://docs.shinami.com/api-docs/sui/node-service/json-rpc/read-api-events-transactions

An example JSON response from a cURL request to get the total number of transaction blocks. The result field contains the total count as a string.

```json
{
   "id" : 1,
   "jsonrpc" : "2.0",
   "result" : "971804907"
}
```

--------------------------------

### Fetch Documentation File using cURL

Source: https://docs.shinami.com/api-docs/movement/gas-station/api

This example shows how to fetch the 'llms.txt' documentation file from the Shinami documentation website using the cURL command-line tool. It targets a specific URL for the file.

```bash
curl https://docs.shinami.com/llms.txt
```

--------------------------------

### GET /websites/shinami

Source: https://docs.shinami.com/api-docs/aptos/node-service/rest-api/accounts/get_account_resource

Retrieves a paginated list of results. The 'start' parameter can be used to fetch subsequent pages.

```APIDOC
## GET /websites/shinami

### Description
Retrieves a paginated list of results. The `start` parameter can be used to fetch subsequent pages.

### Method
GET

### Endpoint
/websites/shinami

### Parameters
#### Query Parameters
- **start** (string) - Required - The starting point for pagination. Pass this to the `start` field of the endpoint on the next call to get the next page of results.

### Request Example
```json
{
  "example": ""
}
```

### Response
#### Success Response (200)
- **pagination** (object) - Contains pagination information, including the `start` cursor for the next page.

#### Response Example
```json
{
  "example": {
    "data": [
      {
        "field1": "value1"
      }
    ],
    "pagination": {
      "start": "next_page_cursor"
    }
  }
}
```

#### Error Responses
- **400 Bad Request**: Returned for invalid requests.
- **403 Forbidden**: Returned if the request is not authorized.
- **404 Not Found**: Returned if the requested resource does not exist.
```

--------------------------------

### Initialize Shinami Wallet On-Chain (TypeScript SDK)

Source: https://docs.shinami.com/api-docs/movement/wallet-services/invisible-wallet-api

This TypeScript example uses the Shinami Clients SDK to initialize an Invisible Wallet on the Movement network. It first creates a session token using the KeyClient and then calls 'initializeWalletOnChain' on the WalletClient.

```typescript
import { KeyClient, WalletClient } from "@shinami/clients/aptos";

const walletClient = new WalletClient({{walletServicesAccessKey}});
const keyClient = new KeyClient({{walletServicesAccessKey}});

let sessionToken = await keyClient.createSession({{walletSecret}});

const accountAddress = await walletClient.initializeWalletOnChain(
  {{walletID}},
  sessionToken
);

```

--------------------------------

### Initialize Shinami Sui Client SDK

Source: https://docs.shinami.com/api-docs/sui/node-service/json-rpc/websockets

This TypeScript example demonstrates how to initialize the Shinami Sui client using the `createSuiClient` function. It requires a node access key and imports necessary types.

```typescript
import { createSuiClient } from "@shinami/clients/sui";
import { TransactionEffects } from "@mysten/sui.js";

const provider = createSuiClient({{nodeAccessKey}}); 

// simple example to print the digest of the transaction associated with the event

```

--------------------------------

### Get Account Transactions

Source: https://docs.shinami.com/api-docs/aptos/node-service/rest-api/transactions/get_account_transactions

Retrieves on-chain committed sequence-number based transactions from an account. This endpoint does not retrieve orderless transactions sent from the account. If the start version is too far in the past, a 410 will be returned. If no start version is given, it will start at version 0. To retrieve a pending transaction, use /transactions/by_hash.

```APIDOC
## GET /websites/shinami/transactions

### Description
Retrieves on-chain committed sequence-number based transactions from an account. Does not retrieve orderless transactions sent from the account. If the start version is too far in the past, a 410 will be returned. If no start version is given, it will start at version 0. To retrieve a pending transaction, use /transactions/by_hash.

### Method
GET

### Endpoint
/websites/shinami/transactions

### Parameters
#### Query Parameters
- **start_version** (integer) - Optional - The version number to start retrieving transactions from. Defaults to 0.

### Request Example
```json
{
  "start_version": 100
}
```

### Response
#### Success Response (200)
- **transactions** (array) - An array of transaction objects.
  - **version** (integer) - The version number of the transaction.
  - **hash** (string) - The hash of the transaction.
  - **state_root_hash** (string) - The state root hash after the transaction.
  - **gas_used** (integer) - The amount of gas used by the transaction.
  - **mempool_version** (integer) - The mempool version of the transaction.
  - **transaction** (object) - The transaction details.
    - **type** (string) - The type of the transaction.
    - **account** (string) - The account involved in the transaction.
    - **sequence_number** (integer) - The sequence number of the transaction.
    - **gas_price** (integer) - The gas price for the transaction.
    - **sender** (string) - The sender of the transaction.
    - **chain_id** (string) - The chain ID.
    - **payload** (object) - The transaction payload.
    - **gas_payment** (object) - The gas payment details.
    - **expiration_timestamp** (string) - The expiration timestamp of the transaction.

#### Error Response (410)
- **error** (string) - A message indicating that the start version is too far in the past.

### Response Example
```json
{
  "transactions": [
    {
      "version": 1,
      "hash": "abcdef1234567890",
      "state_root_hash": "fedcba0987654321",
      "gas_used": 1000,
      "mempool_version": 1,
      "transaction": {
        "type": "payment",
        "account": "0x123",
        "sequence_number": 1,
        "gas_price": 100,
        "sender": "0x456",
        "chain_id": "testnet",
        "payload": {},
        "gas_payment": {},
        "expiration_timestamp": "2023-10-27T10:00:00Z"
      }
    }
  ]
}
```
```

--------------------------------

### Connect and Subscribe to Transactions via WebSocket

Source: https://docs.shinami.com/api-docs/sui/node-service/json-rpc/websockets

This example shows how to connect to the Shinami service using wscat and subscribe to transactions using the `suix_subscribeTransaction` method with various filter parameters.

```bash
# connect to the service
% wscat -c wss://api.us1.shinami.com/sui/node/v1/{{nodeAccessKey}}

{"jsonrpc":"2.0", "id":1, "method": "suix_subscribeTransaction", "params": [ {{TransactionFilter}}]}
```

--------------------------------

### GET /transactions

Source: https://docs.shinami.com/api-docs/aptos/node-service/rest-api/transactions/get_transactions

Retrieve on-chain committed transactions. The page size and start ledger version can be provided to get a specific sequence of transactions. If the version has been pruned, then a 410 will be returned. To retrieve a pending transaction, use /transactions/by_hash.

```APIDOC
## GET /transactions

### Description
Retrieve on-chain committed transactions. The page size and start ledger version can be provided to get a specific sequence of transactions. If the version has been pruned, then a 410 will be returned. To retrieve a pending transaction, use /transactions/by_hash.

### Method
GET

### Endpoint
/transactions

### Parameters
#### Query Parameters
- **start** (U64) - Optional - Ledger version to start list of transactions. If not provided, defaults to showing the latest transactions
- **limit** (integer) - Optional - Max number of transactions to retrieve. If not provided, defaults to default page size

### Request Example
```json
{
  "example": "Not applicable for GET request"
}
```

### Response
#### Success Response (200)
- **Transactions** (array of Transaction) - List of transactions.

#### Headers
- **X-APTOS-CHAIN-ID** (integer) - Chain ID of the current chain
- **X-APTOS-LEDGER-VERSION** (integer) - Current ledger version of the chain
- **X-APTOS-LEDGER-OLDEST-VERSION** (integer) - Oldest non-pruned ledger version of the chain
- **X-APTOS-LEDGER-TIMESTAMPUSEC** (integer) - Current timestamp of the chain
- **X-APTOS-EPOCH** (integer) - Current epoch of the chain
- **X-APTOS-BLOCK-HEIGHT** (integer) - Current block height of the chain
- **X-APTOS-OLDEST-BLOCK-HEIGHT** (integer) - Oldest non-pruned block height of the chain
- **X-APTOS-GAS-USED** (integer) - The cost of the call in terms of gas
- **X-APTOS-CURSOR** (string) - Cursor to be used for endpoints that support cursor-based pagination. Pass this to the `start` field of the endpoint on the next call to get the next page of results.

#### Response Example
```json
{
  "example": "[ \n  {\n    \"version\": \"123456\",\n    \"hash\": \"0x1234...\",\n    \"state_change_hash\": \"0xabcde...\",\n    \"event_root_hash\": \"0xfedcb...\",\n    \"accumulator_root_hash\": \"0x13579...\",\n    \"signature\": {\n      \"type\": \"ed25519 signature\",\n      \"public_key\": \"0x...\",\n      \"signature\": \"0x...\"\n    },\n    \"check_sequence_number\": 0,\n    \"sender\": \"0x...\",\n    \"gas_used\": 1000,\n    \"status\": \"success\",\n    \"logs\": [\n      \"log message 1\",\n      \"log message 2\"\n    ],\n    \"block_height\": 100,\n    \"epoch\": 1,\n    \"timestamp\": 1678886400000000\n  }\n]"
}
```
```

--------------------------------

### GET /accounts/{address}/transactions

Source: https://docs.shinami.com/api-docs/aptos/node-service/rest-api/transactions/get_account_transactions

Retrieves on-chain committed sequence-number based transactions from an account. This endpoint does not retrieve orderless transactions sent from the account. If the start version is too far in the past, a 410 will be returned. If no start version is given, it will start at version 0. To retrieve a pending transaction, use /transactions/by_hash.

```APIDOC
## GET /accounts/{address}/transactions

### Description
Retrieves on-chain committed sequence-number based transactions from an account. Does not retrieve orderless transactions sent from the account. If the start version is too far in the past, a 410 will be returned. If no start version is given, it will start at version 0. To retrieve a pending transaction, use /transactions/by_hash.

### Method
GET

### Endpoint
/accounts/{address}/transactions

### Parameters
#### Path Parameters
- **address** (Address) - Required - Address of account with or without a `0x` prefix

#### Query Parameters
- **start** (U64) - Optional - Account sequence number to start list of transactions. If not provided, defaults to showing the latest transactions
- **limit** (integer, uint16) - Optional - Max number of transactions to retrieve. If not provided, defaults to default page size

### Request Example
```json
{
  "example": "request body"
}
```

### Response
#### Success Response (200)
- **items** (array of Transaction) - Description
- **X-APTOS-CHAIN-ID** (integer, uint8) - Chain ID of the current chain
- **X-APTOS-LEDGER-VERSION** (integer, uint64) - Current ledger version of the chain
- **X-APTOS-LEDGER-OLDEST-VERSION** (integer, uint64) - Oldest non-pruned ledger version of the chain
- **X-APTOS-LEDGER-TIMESTAMPUSEC** (integer, uint64) - Current timestamp of the chain
- **X-APTOS-EPOCH** (integer, uint64) - Current epoch of the chain
- **X-APTOS-BLOCK-HEIGHT** (integer, uint64) - Current block height of the chain
- **X-APTOS-OLDEST-BLOCK-HEIGHT** (integer, uint64) - Oldest non-pruned block height of the chain
- **X-APTOS-GAS-USED** (integer, uint64) - The cost of the call in terms of gas
- **X-APTOS-CURSOR** (string) - Description

#### Response Example
```json
{
  "example": "response body"
}
```
```

--------------------------------

### Aptos Python SDK - Transaction Preparation

Source: https://docs.shinami.com/api-docs/aptos/gas-station/api

Example code demonstrating how to prepare a `RawTransaction` and `AccountAuthenticator` using the Aptos Python SDK for submission via the Shinami Gas API.

```APIDOC
## Aptos Python SDK - Transaction Preparation

### Description
This section provides a Python code example using the Aptos SDK to prepare a transaction payload and construct the necessary components (`RawTransaction` and `AccountAuthenticator`) for submission through a service like the Shinami Gas API. It covers options for sending transaction data as byte arrays or hex strings.

### Method
N/A (Client-side SDK usage)

### Endpoint
N/A (Illustrative code for transaction preparation)

### Parameters
#### Imports
```python
from aptos_sdk.async_client import RestClient
from aptos_sdk.bcs import Serializer
from aptos_sdk.transactions import FeePayerRawTransaction
from aptos_sdk.account import Account
from aptos_sdk.transactions import TransactionPayload
```

#### Setup
```python
# Assume APTOS_TESTNET_NODE_URL and senderAccount are defined elsewhere
# rest_client = RestClient(APTOS_TESTNET_NODE_URL)
# txPayload: TransactionPayload
# senderAccount: Account
```

#### Transaction Payload and Sender Account
```python
## Set up your transaction payload (`txPayload`) of type `TransactionPayload`
## Also the `senderAccount`, which is of type `Account`

## ... (code to define txPayload and senderAccount)
```

#### RawTransaction Preparation
```python
rest_client = RestClient(APTOS_TESTNET_NODE_URL)

## RawTransaction
raw_transaction = await rest_client.create_bcs_transaction(senderAccount, txPayload)

# Option 1: send as an unsigned byte array
shinami_rawTransaction_bytes = list(raw_transaction.to_bytes())

# Option 2: send as a hex string
transaction_serializer = Serializer()
raw_transaction.serialize(transaction_serializer)
shinami_rawTransaction_hex = transaction_serializer.output().hex()
```

#### Sender's AccountAuthenticator Preparation
```python
## sender's AccountAuthenticator
# Build a fee payer transaction and have the sender sign it
fee_payer_transaction = FeePayerRawTransaction(raw_transaction, [], None) # Assuming no secondary signers
sender_authenticator = senderAccount.sign_transaction(fee_payer_transaction)

auth_serializer = Serializer()
sender_authenticator.serialize(auth_serializer)

# Option 1: send as an unsigned byte array
shinami_senderSignature_bytes = list(auth_serializer.to_bytes())

# Option 2: send as a hex string
shinami_senderSignature_hex = auth_serializer.output().hex()
```

### Request Example
```python
# Example of how you might use the prepared data with the Shinami API (conceptual)
# import requests
# 
# api_key = "{{gasStationAccessKey}}"
# api_url = "https://api.us1.shinami.com/aptos/gas/v1/"
# 
# payload = {
#     "jsonrpc": "2.0",
#     "method": "gas_sponsorAndSubmitSignedTransaction",
#     "params": [
#         shinami_rawTransaction_hex,  # or shinami_rawTransaction_bytes
#         shinami_senderSignature_hex, # or shinami_senderSignature_bytes
#         [] # Fee payer info if applicable
#     ],
#     "id": 1
# }
# 
# headers = {
#     "X-API-Key": api_key,
#     "Content-Type": "application/json"
# }
# 
# response = requests.post(api_url, json=payload, headers=headers)
# print(response.json())
```

### Response
N/A (This is a client-side preparation example)

```

--------------------------------

### Initialize Shinami Wallet on Aptos (Shinami TypeScript SDK)

Source: https://docs.shinami.com/api-docs/aptos/wallet-services/invisible-wallet-api

Initializes a Shinami Invisible Wallet on the Aptos network using the Shinami Clients SDK for TypeScript. This method requires a walletServicesAccessKey, walletSecret, and walletID. It first creates a session token and then calls the initializeWalletOnChain method.

```typescript
import { KeyClient, WalletClient } from "@shinami/clients/aptos";

const walletClient = new WalletClient({{walletServicesAccessKey}}); 
const keyClient = new KeyClient({{walletServicesAccessKey}}); 

let sessionToken = await keyClient.createSession({{walletSecret}}); 

const accountAddress = await walletClient.initializeWalletOnChain(
  {{walletID}},
  sessionToken
); 

```

--------------------------------

### Initialize Shinami Wallet On-Chain (TypeScript SDK with ShinamiWalletSigner)

Source: https://docs.shinami.com/api-docs/movement/wallet-services/invisible-wallet-api

This TypeScript example utilizes the ShinamiWalletSigner for initializing an Invisible Wallet on the Movement network. It abstracts the session token creation and directly calls 'tryInitializeOnChain' on the signer instance.

```typescript
import { WalletClient, KeyClient, ShinamiWalletSigner } from "@shinami/clients/aptos";

const walletClient = new WalletClient({{walletServicesAccessKey}});
const keyClient = new KeyClient({{walletServicesAccessKey}});

const signer = new ShinamiWalletSigner(
    {{walletId}},
    walletClient,
    {{walletSecret}},
    keyClient
);

const accountAddress = await signer.tryInitializeOnChain();

```

--------------------------------

### Select Gasless Transaction Function (TypeScript)

Source: https://docs.shinami.com/developer-guides/sui/tutorials/gas-station-backend-only

This code snippet shows how to select which gasless transaction function to execute within a larger example script. It involves uncommenting the desired function call, such as `clockMoveCallGaslessTransactionAlternateVersion`, to enable its execution when the script is run. This is part of the setup process before transpiling and running the TypeScript example.

```TypeScript
// 5. Generate the GaslessTransaction for sponsorship
  const gaslessTx =  await
    // clockMoveCallGaslessTransaction();
    clockMoveCallGaslessTransactionAlternateVersion();
    // clockMoveCallGaslessTransactionOfflineBuildManualBudget();
    // checkFundBalanceAndDepositIfNeeded(SUI_COIN_TO_DEPOSIT_ID);
    // splitCoinOwnedByGaslessTransaction(COIN_TO_SPLIT_FROM_ID, SENDER_ADDRESS);
    // mergeCoinsGaslessTransaction(COIN_TO_SPLIT_FROM_ID, COIN_TO_MERGE_ID);
    // transferObjectToRecipientGaslessTransaction(OBJ_ID_TO_TRANSFER, RECIPIENT_ADDRESS);
```

--------------------------------

### GET /websites/shinami/transactions

Source: https://docs.shinami.com/api-docs/aptos/node-service/rest-api/transactions/get_transactions

Retrieves a sequence of committed on-chain transactions. Supports pagination using page size and starting ledger version. Returns a 410 if the specified version has been pruned.

```APIDOC
## GET /websites/shinami/transactions

### Description
Retrieve on-chain committed transactions. The page size and start ledger version can be provided to get a specific sequence of transactions.
If the version has been pruned, then a 410 will be returned.
To retrieve a pending transaction, use /transactions/by_hash.

### Method
GET

### Endpoint
/websites/shinami/transactions

#### Query Parameters
- **pageSize** (integer) - Optional - The number of transactions to return per page.
- **startLedgerVersion** (integer) - Optional - The ledger version to start retrieving transactions from.

### Response
#### Success Response (200)
- **transactions** (array) - A list of committed transactions.
  - **hash** (string) - The hash of the transaction.
  - **ledgerVersion** (integer) - The ledger version in which the transaction was committed.
  - **timestamp** (string) - The timestamp of the transaction commitment.

#### Error Response (410)
- **error** (string) - "Version pruned"
```

--------------------------------

### Initialize Shinami Wallet on Aptos (cURL)

Source: https://docs.shinami.com/api-docs/aptos/wallet-services/invisible-wallet-api

Initializes a Shinami Invisible Wallet on the Aptos network using a cURL request. This method requires an access key with Node Service and Gas Station rights, and a session token generated via key_createSession. The walletId and sessionToken are provided as parameters.

```bash
curl https://api.us1.shinami.com/aptos/wallet/v1 \
  -X POST \
  -H 'X-API-Key: {{walletServicesAccessKey}}' \
  -H 'Content-Type: application/json' \
  -d '{
          "jsonrpc": "2.0",
          "method": "wal_initializeWalletOnChain",
          "params": [
              "{{walletId}}",
              "{{sessionToken}}"
          ],
          "id": 1
      }'
```

--------------------------------

### Get Account Transaction Summaries OpenAPI Specification

Source: https://docs.shinami.com/api-docs/aptos/node-service/rest-api/transactions/get_account_transaction_summaries

This OpenAPI specification defines the GET endpoint for retrieving transaction summaries for a given account. It allows filtering by start and end versions, and specifies the response format including transaction details and ledger information. Dependencies include the OpenAPI 3.0.0 schema and Aptos-specific types like Address and U64.

```yaml
openapi: 3.0.0
info:
  title: Aptos Node API
  description: >-
    The Aptos Node API is a RESTful API for client applications to interact with
    the Aptos blockchain.
  version: 1.2.0
  contact:
    name: Aptos Labs
    url: https://github.com/aptos-labs/aptos-core
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0.html
servers:
  - url: https://api.us1.shinami.com/aptos/node/v1
security: []
tags:
  - name: Accounts
    description: Access to accounts, resources, and modules
  - name: Blocks
    description: Access to blocks
  - name: Events
    description: Access to events
  - name: Experimental
    description: Experimental APIs, no guarantees
  - name: General
    description: General information
  - name: Tables
    description: Access to tables
  - name: Transactions
    description: Access to transactions
  - name: View
    description: View functions,
externalDocs:
  url: https://github.com/aptos-labs/aptos-core
paths:
  /accounts/{address}/transaction_summaries:
    get:
      tags:
        - Transactions
      summary: Get account transaction summaries
      description: >-
        Retrieves summaries of on-chain committed transactions (both sequence
        number based

        and orderless transactions) from an account.

        Each transaction summary contains the sender addresss, transaction hash,
        version, and replay protector.


        If start_version is provided, the output consists of transaction
        summaries starting form that version.


        If start_version is not provided but the end_version is provided, the
        output consists of transaction summaries

        ending at the end_version.


        If both start_version and end_version are not provided, the output
        consists of the summaries of

        most recent committed transaction from the account.


        The output always consists of transaction summaries ordered in ascending
        order by version.


        To retrieve a pending transaction, use /transactions/by_hash.
      operationId: get_account_transaction_summaries
      parameters:
        - name: address
          schema:
            $ref: '#/components/schemas/Address'
          in: path
          description: Address of account with or without a `0x` prefix
          required: true
          deprecated: false
          explode: true
        - name: start_version
          schema:
            $ref: '#/components/schemas/U64'
          in: query
          description: |-
            Transaction version to start list of transactions

            If not provided, defaults to showing the latest transactions
          required: false
          deprecated: false
          explode: true
        - name: end_version
          schema:
            $ref: '#/components/schemas/U64'
          in: query
          description: |-
            Transaction version to end list of transactions

            If not provided, defaults to showing the latest transactions
          required: false
          deprecated: false
          explode: true
        - name: limit
          schema:
            type: integer
            format: uint16
          in: query
          description: |-
            Max number of transactions to retrieve.

            If not provided, defaults to default page size
          required: false
          deprecated: false
          explode: true
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/TransactionSummary'
            application/x-bcs:
              schema:
                type: array
                items:
                  type: integer
                  format: uint8
          headers:
            X-APTOS-CHAIN-ID:
              description: Chain ID of the current chain
              required: true
              deprecated: false
              schema:
                type: integer
                format: uint8
            X-APTOS-LEDGER-VERSION:
              description: Current ledger version of the chain
              required: true
              deprecated: false
              schema:
                type: integer
                format: uint64
            X-APTOS-LEDGER-OLDEST-VERSION:
              description: Oldest non-pruned ledger version of the chain
              required: true
              deprecated: false
              schema:
                type: integer
                format: uint64
            X-APTOS-LEDGER-TIMESTAMPUSEC:
              description: Current timestamp of the chain
              required: true
              deprecated: false
              schema:
                type: integer
                format: uint64
            X-APTOS-EPOCH:
              description: Current epoch of the chain

```

--------------------------------

### Run Development Server

Source: https://docs.shinami.com/developer-guides/sui/tutorials/zklogin-nextjs-app-template

This command starts the Shinami application in development mode. It is typically run from the project's root directory in the command line. No specific inputs are required, and the output is the running application accessible via a local web browser.

```bash
npm run dev
```

--------------------------------

### Get Aptos Account Events by Handle (OpenAPI)

Source: https://docs.shinami.com/api-docs/aptos/node-service/rest-api/events/get_events_by_event_handle

This OpenAPI definition describes the GET endpoint for retrieving events associated with a specific account and event handle. It requires the account address, event handle name, and field name as path parameters, with optional query parameters for pagination (start and limit). The response includes versioned event data and various ledger-related headers.

```yaml
openapi: 3.0.0
info:
  title: Aptos Node API
  description: >-
    The Aptos Node API is a RESTful API for client applications to interact with
    the Aptos blockchain.
  version: 1.2.0
  contact:
    name: Aptos Labs
    url: https://github.com/aptos-labs/aptos-core
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0.html
servers:
  - url: https://api.us1.shinami.com/aptos/node/v1
security: []
tags:
  - name: Accounts
    description: Access to accounts, resources, and modules
  - name: Blocks
    description: Access to blocks
  - name: Events
    description: Access to events
  - name: Experimental
    description: Experimental APIs, no guarantees
  - name: General
    description: General information
  - name: Tables
    description: Access to tables
  - name: Transactions
    description: Access to transactions
  - name: View
    description: View functions,
externalDocs:
  url: https://github.com/aptos-labs/aptos-core
paths:
  /accounts/{address}/events/{event_handle}/{field_name}:
    get:
      tags:
        - Events
      summary: Get events by event handle
      description: >-
        This API uses the given account `address`, `eventHandle`, and
        `fieldName`

        to build a key that can globally identify an event types. It then uses
        this

        key to return events emitted to the given account matching that event
        type.
      operationId: get_events_by_event_handle
      parameters:
        - name: address
          schema:
            $ref: '#/components/schemas/Address'
          in: path
          description: >-
            Hex-encoded 32 byte Aptos account, with or without a `0x` prefix,
            for

            which events are queried. This refers to the account that events
            were

            emitted to, not the account hosting the move module that emits that

            event type.
          required: true
          deprecated: false
          explode: true
        - name: event_handle
          schema:
            $ref: '#/components/schemas/MoveStructTag'
          in: path
          description: Name of struct to lookup event handle e.g. `0x1::account::Account`
          required: true
          deprecated: false
          explode: true
        - name: field_name
          schema:
            $ref: '#/components/schemas/IdentifierWrapper'
          in: path
          description: Name of field to lookup event handle e.g. `withdraw_events`
          required: true
          deprecated: false
          explode: true
        - name: start
          schema:
            $ref: '#/components/schemas/U64'
          in: query
          description: |-
            Starting sequence number of events.

            If unspecified, by default will retrieve the most recent
          required: false
          deprecated: false
          explode: true
        - name: limit
          schema:
            type: integer
            format: uint16
          in: query
          description: |-
            Max number of events to retrieve.

            If unspecified, defaults to default page size
          required: false
          deprecated: false
          explode: true
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/VersionedEvent'
            application/x-bcs:
              schema:
                type: array
                items:
                  type: integer
                  format: uint8
          headers:
            X-APTOS-CHAIN-ID:
              description: Chain ID of the current chain
              required: true
              deprecated: false
              schema:
                type: integer
                format: uint8
            X-APTOS-LEDGER-VERSION:
              description: Current ledger version of the chain
              required: true
              deprecated: false
              schema:
                type: integer
                format: uint64
            X-APTOS-LEDGER-OLDEST-VERSION:
              description: Oldest non-pruned ledger version of the chain
              required: true
              deprecated: false
              schema:
                type: integer
                format: uint64
            X-APTOS-LEDGER-TIMESTAMPUSEC:
              description: Current timestamp of the chain
              required: true
              deprecated: false
              schema:
                type: integer
                format: uint64
            X-APTOS-EPOCH:
              description: Current epoch of the chain
              required: true
              deprecated: false
              schema:
                type: integer
                format: uint64
            X-APTOS-BLOCK-HEIGHT:

```

--------------------------------

### Create and Initialize Invisible Wallet (TypeScript)

Source: https://docs.shinami.com/developer-guides/aptos/tutorials/invisible-wallets

This snippet demonstrates how to set up wallet credentials, instantiate necessary Shinami clients (Aptos, Key, Wallet, Gas), create a ShinamiWalletSigner for easier operations, and finally create and initialize an Invisible Wallet on the Aptos Testnet. The wallet initialization is done explicitly to ensure it can sign transactions.

```typescript
// 3. Set up a walletId and its associated secret. Just for the tutorial. Your
//    app should figure out the best way to manage its wallet IDs and secrets.
const WALLET_ID = "{{walletID}}";
const WALLET_SECRET = "{{walletSecret}}";

// 4. Instantiate your Shinami clients
const aptosClient = createAptosClient(ALL_SERVICES_TESTNET_ACCESS_KEY);
const keyClient = new KeyClient(ALL_SERVICES_TESTNET_ACCESS_KEY);
const walletClient = new WalletClient(ALL_SERVICES_TESTNET_ACCESS_KEY);
// Only required for `signSponsorAndSubmitTransactionInTwoSteps` example:
const gasClient = new GasStationClient(ALL_SERVICES_TESTNET_ACCESS_KEY);

// 5. Create a ShinamiWalletSinger to more easily manage the Invisible Wallet
const signer = new ShinamiWalletSigner(
  WALLET_ID,
  walletClient,
  WALLET_SECRET,
  keyClient
);

// 6. Create the Invisible Wallet. The call to `executeGaslessTransaction` below
//    would initailize an un-initialized wallet. However, we are explicitly
//    initializing it now in case you only run the `signAndVerifyTransaction`
//    function, because a wallet must be initialized in order to sign a transaction.
//    This requires the Gas Station fund associated with this access key to have
//    sufficient APT to pay for the initialization transaction, as well as the
//    transaction we execute below.
const CREATE_WALLET_IF_NOT_FOUND = true;
const INITIALIZE_ON_CHAIN = true;
const walletAddress = await signer.getAddress(CREATE_WALLET_IF_NOT_FOUND, INITIALIZE_ON_CHAIN);

```
Tokens:
Raw