Package Exports

@gotake/gotake-sdk

Readme

GoodTake SDK

GoodTake SDK is a JavaScript/TypeScript library for interacting with GoodTake smart contracts and backend services, supporting Token Bound Accounts (TBA), Content NFTs, and a seamless video-to-NFT pipeline.

Installation

Using npm:

npm install @gotake/gotake-sdk

Or using yarn:

yarn add @gotake/gotake-sdk

Browser & Frontend Compatibility ✨

The SDK is fully compatible with modern frontend frameworks and browsers:

✅ React, Vue, Angular, Svelte
✅ Vite, Webpack, Rollup, Parcel
✅ Next.js, Nuxt.js, SvelteKit
✅ Browser environments (Chrome, Firefox, Safari, Edge)
✅ No Node.js polyfills required

Usage

Browser/Frontend Usage

For React, Vue, and other frontend frameworks:

import { GoTakeSDK } from '@gotake/gotake-sdk';
import { ethers } from 'ethers';

// Connect to user's wallet (MetaMask, WalletConnect, etc.)
const provider = new ethers.providers.Web3Provider(window.ethereum);
await provider.send("eth_requestAccounts", []);
const signer = provider.getSigner();

// Initialize SDK with signer from wallet
const sdk = new GoTakeSDK({
    network: 'base_sepolia', // or 'base' for mainnet
    provider: provider,
    signer: signer  // Required in browser environment
});

// Ready to use!
const address = await sdk.getAddress();

Node.js Usage

For Node.js environments:

// ES Module import (Node.js with "type": "module")
import { GoTakeSDK } from '@gotake/gotake-sdk';

// CommonJS import (traditional Node.js)
const { GoTakeSDK } = require('@gotake/gotake-sdk');

// Initialize with private key from environment variables (recommended)
// Requires .env file with PRIVATE_KEY and RPC_URL
const sdk = new GoTakeSDK({
    network: 'base_sepolia',
});

// Or provide configuration directly
const sdk = new GoTakeSDK({
    network: 'base_sepolia',
    provider: 'https://sepolia.base.org', // RPC URL
    signer: '0x123...' // Your private key
});

Importing the SDK

The SDK supports both ES modules and CommonJS imports for maximum compatibility:

// ES Module import (recommended for React, Vue, modern bundlers)
import { GoTakeSDK } from '@gotake/gotake-sdk';

// CommonJS import (for Node.js, older projects)
const { GoTakeSDK } = require('@gotake/gotake-sdk');

// You can also import specific types and utilities
import { GoTakeSDK, NetworkId, VideoStatus } from '@gotake/gotake-sdk';

Network Support

The SDK supports multiple networks:

Base Mainnet (base)
Base Sepolia (base_sepolia) - Default

Switching networks:

// Switch by network ID
await sdk.switchNetwork(84532); // Switch to Base Sepolia

// Or switch by network name
await sdk.switchNetwork('base_sepolia');

Core Features

Unified Video Upload and Minting

The easiest way to get started is with the unified uploadAndMintWhenReady method. It handles the entire lifecycle: video upload, processing, status tracking, and automatically minting a Content NFT to the user's account when the video is ready.

// Upload video and automatically mint NFT when ready
const videoId = await sdk.uploadAndMintWhenReady(
  videoFile,
  {
    title: "My Awesome Video",
    description: "This is a description of my video",
    tags: ["tag1", "tag2"]
  },
  {
    statusCallback: (status) => {
      console.log(`Processing: ${status.status}`);
      if(status.progress) {
        updateUIProgress(status.progress);
      }
    },
    autoMint: true // Automatically mint when video is ready
  }
);

console.log(`Process started with video ID: ${videoId}`);

Account Management (TBA & AccountNFT)

The SDK provides comprehensive tools for managing user accounts, which consist of an AccountNFT (ERC-721) and a linked Token Bound Account (TBA).

Create a New User Account

Create an AccountNFT and its corresponding TBA in a single, atomic transaction.

const { accountNFT, tba } = await sdk.account.createNewUserAccount({
    recipientAddress: '0x...', // Address of the new user
});

console.log(`AccountNFT minted with Token ID: ${accountNFT.tokenId}`);
console.log(`TBA created at address: ${tba.tbaAddress}`);

Other Account Operations

createTBA(params): Create a TBA for an existing NFT.
computeTBAAddress(params): Calculate the deterministic address for a TBA without creating it on-chain.
getTBAInfo(tbaAddress): Retrieve information about a TBA, such as the underlying NFT.
getAccountInfo(tokenId): Get details for a specific AccountNFT.
executeTBATransaction(...): Execute a transaction from a TBA, for which the user's wallet is an owner.

Content NFT Management

Manage the lifecycle of Content NFTs, which represent video IP.

mint(to, metadata): Mint a new Content NFT. This is often handled automatically by uploadAndMintWhenReady.
getContentNFTDetails(tokenId): Get detailed metadata for a Content NFT, including title, description, creator, etc.
isOwner(tokenId, address): Check if a given address is the owner of a Content NFT.

Content Purchase & Permissions

The SDK provides a full suite of tools for managing pay-per-view or lifetime access content.

Content Management (Admin)

// Create pay-per-view content (5 views, priced at 0.01 ETH)
await sdk.videoPayment.setContentConfig({
    contentId: 100,
    price: '0.01',      // Price in native token (e.g., ETH)
    viewCount: 5,
    isActive: true
});

// Create lifetime access content with ERC20 pricing
await sdk.videoPayment.setContentConfig({
    contentId: 101,
    price: '10', // 10 units of the specified token
    token: '0x...', // ERC20 token address
    viewCount: 999999,  // Effectively unlimited views
    isActive: true
});

// Batch create multiple content items
await sdk.videoPayment.batchSetContentConfig({
    contentIds: [102, 103],
    prices: ['0.001', '0.002'],
    viewCounts: [3, 10],
    isActiveArray: [true, true]
});

Content Purchase (User)

// Get content info, including price and supported tokens
const contentInfo = await sdk.videoPayment.getContentInfo(100);
console.log('Price:', ethers.utils.formatEther(contentInfo.nativePrice), 'ETH');

// Purchase with ETH (native token)
const ethResult = await sdk.videoPayment.purchaseContent(100, 'ETH');
console.log('Purchase successful:', ethResult.transactionHash);

// Purchase with an ERC20 token
const tokenResult = await sdk.videoPayment.purchaseContent(
    101,
    'ERC20',
    '0x...'  // Token address
);

// Batch purchase multiple items
const batchResult = await sdk.videoPayment.batchPurchaseContent([102, 103], 'ETH');

Permission Checking

const hasPermission = await sdk.videoPayment.hasViewPermission(100);

if (hasPermission) {
    const permissions = await sdk.videoPayment.getMyPermissions(100);
    console.log('Remaining views:', permissions.remainingViews.toString());
    console.log('Purchase time:', new Date(permissions.purchaseTime.toNumber() * 1000));
}

Gas Price Management

The SDK provides a utility to get recommended gas prices for EIP-1559 transactions, helping to avoid overpaying or having transactions get stuck.

// Get current gas price recommendations
const gasPrices = await sdk.getGasPrice({
    multiplier: 1.5,         // Increase base fee by 50%
    priorityMultiplier: 1.2  // Increase priority fee by 20%
});

// Use recommended gas prices in a transaction
const tx = await sdk.account.createTBA(params, {
    gasConfig: {
        maxFeePerGas: gasPrices.maxFeePerGas,
        maxPriorityFeePerGas: gasPrices.maxPriorityFeePerGas
    }
});

Environment Variables

For Node.js applications, create a .env file in the project root:

# Network configuration
RPC_URL=https://sepolia.base.org

# Authentication - required for Node.js
PRIVATE_KEY=your_private_key_here

# API configuration (optional)
API_KEY=your_api_key_for_goodtake_backend
API_ENDPOINT=https://api.goodtake.io

Demo Scripts

The SDK includes several demo scripts in the scripts/ directory to demonstrate common operations.

Setup

Create a .env file in the project root with your PRIVATE_KEY and RPC_URL.
Install dependencies: npm install or yarn install.
Add a sample video file to scripts/assets/sample-video.mp4.

Available Scripts

upload-and-mint.ts: Demonstrates the unified one-step upload and mint process.
```
npm run upload-and-mint
```

manage-content.ts: Create, update, and view content configurations.

# Create content: npm run manage-content create <contentId> <price> <views> <durationHours> <isActive>
npm run manage-content create 100 0.01 5 24 true

purchase-content.ts: Purchase content using ETH or ERC20 tokens.

# Check content info: npm run purchase-content check <contentId>
npm run purchase-content check 100

# Buy with ETH: npm run purchase-content buy <contentId>
npm run purchase-content buy 100

check-permissions.ts: Check viewing permissions for a user.
```
npm run check-permissions
```
create-tba.ts: Manually create a Token Bound Account.
```
npm run create-tba
```

For more script commands and options, please inspect the individual files in the scripts/ directory.

API Reference

`GoTakeSDK`

The main entry point for all SDK functionality.

account: Access AccountApi.
contentNFT: Access ContentNFTApi.
video: Access VideoApi.
videoPayment: Access VideoPaymentApi.
getAddress(): Get the current signer's address.
switchNetwork(network): Switch the active blockchain network.
getGasPrice(options): Get EIP-1559 gas price recommendations.
uploadAndMintWhenReady(file, metadata, options): The core unified method for video-to-NFT.

`AccountApi`

createNewUserAccount(params): Create a new user (AccountNFT + TBA).
createTBA(params): Create a TBA for an existing NFT.
computeTBAAddress(params): Pre-calculate a TBA address.
executeTBATransaction(...): Execute a transaction from a TBA.

`ContentNFTApi`

mint(to, metadata): Mint a new Content NFT.
getContentNFTDetails(tokenId): Fetch on-chain metadata for a Content NFT.
isOwner(tokenId, address): Check NFT ownership.

`VideoApi`

uploadVideo(file, metadata): Handle the video upload process.
getVideoInfo(videoId): Get the latest status of a video from the backend.

`VideoPaymentApi`

setContentConfig(config): Create or update content sale parameters.
purchaseContent(contentId, paymentMethod, ...): Purchase access to content.
hasViewPermission(contentId): Check if the current user can view content.
getMyPermissions(contentId): Get detailed permission info for the user.
getContentInfo(contentId): Get public information about a piece of content.

Testing

GoodTake SDK provides three types of tests:

Unit Tests

npm test

Unit tests verify individual components without connecting to blockchain networks.

Integration Tests

# Set environment variables
export RUN_INTEGRATION_TESTS=true
export TEST_PRIVATE_KEY=your_private_key
export TEST_NFT_CONTRACT=0x...
export TEST_NFT_TOKEN_ID=1
export TEST_VIDEO_TOKEN_ID=2

# Run integration tests
npm run test:integration

Integration tests require connection to a test network (like Base Sepolia) and interact with real contracts.

Contributing

Fork the repository
Create your feature branch: git checkout -b feature/amazing-feature
Commit your changes: git commit -m 'Add some amazing feature'
Push to the branch: git push origin feature/amazing-feature
Open a Pull Request

License

MIT