@iota/isc-sdk 0.0.0-dev-20251015065834

package/examples/tokens.ts

@@ -0,0 +1,96 @@
+import {
+    AccountsContractMethod,
+    CoreContract,
+    EvmRpcClient,
+    getHname,
+    IscTransaction,
+    L2_FROM_L1_GAS_BUDGET,
+} from '../src/index.js';
+import { IOTA_TYPE_ARG } from '@iota/iota-sdk/utils';
+import { Ed25519Keypair } from '@iota/iota-sdk/keypairs/ed25519';
+import { IotaClient } from '@iota/iota-sdk/client';
+import { CONFIG } from './config.js';
+import { bcs } from '@iota/iota-sdk/bcs';
+
+const { L1, L2 } = CONFIG;
+
+const client = new IotaClient({
+    url: L1.rpcUrl,
+});
+const evmRpcClient = new EvmRpcClient(L2.evmRpcUrl);
+
+const MNEMONIC =
+    'mom program scrap easily doctor seed slender secret mad flat foam hospital cherry seek river you obscure column blood reflect arch pencil cat burst';
+const TOKEN_COIN_TYPE =
+    '0xe1e88f4962b3ea96cfad19aee42f666b04bbce4dc4327c3cd63f1b8ff16e13b2::tool_coin::TOOL_COIN';
+
+const keypair = Ed25519Keypair.deriveKeypair(MNEMONIC);
+const address = keypair.toIotaAddress();
+
+// EVM Address
+const recipientAddress = process.argv[2];
+
+if (!recipientAddress) {
+    console.error('Please provide a recipient address as an argument');
+    process.exit(1);
+}
+
+// Amount to send (0.01 IOTAs)
+const amountToSend = BigInt(1 * 1_000_000);
+// Amount to send (1 Boxfish)
+const tokenAmountToSend = BigInt(1);
+// We also need to place a little more in the bag to cover the L2 gas
+const amountToPlace = amountToSend + L2_FROM_L1_GAS_BUDGET;
+
+console.log('Sending...');
+
+const iscTx = new IscTransaction(L1);
+const tx = iscTx.transaction();
+
+const bag = iscTx.newBag();
+
+// Place IOTA
+const iotaCoin = iscTx.coinFromAmount({ amount: amountToPlace });
+iscTx.placeCoinInBag({ coin: iotaCoin, bag, coinType: IOTA_TYPE_ARG });
+
+// Place Token
+const tokenCoin = tx.splitCoins(
+    tx.object('0xf7662ffd9cb079d8e75ab4805ba78fdb0e0fb78cf49aa0fa01ecb7ebdf15d04e'),
+    [tx.pure(bcs.U64.serialize(tokenAmountToSend))],
+);
+iscTx.placeCoinInBag({
+    bag,
+    coin: tokenCoin,
+    coinType: TOKEN_COIN_TYPE,
+});
+
+iscTx.createAndSendToEvm({
+    bag,
+    transfers: [
+        [IOTA_TYPE_ARG, amountToSend],
+        [TOKEN_COIN_TYPE, tokenAmountToSend],
+    ],
+    address: recipientAddress,
+    accountsContract: getHname(CoreContract.Accounts),
+    accountsFunction: getHname(AccountsContractMethod.TransferAllowanceTo),
+});
+
+const transaction = iscTx.build();
+transaction.setSender(address);
+
+await transaction.build({ client });
+
+const { digest } = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction,
+});
+
+await client.waitForTransaction({
+    digest,
+});
+
+console.log('Sent!');
+
+const l1BalanceInL2 = await evmRpcClient.getBalanceBaseToken(address);
+
+console.log(`L2 balance of the L1 address ${address}: ${JSON.stringify(l1BalanceInL2)}`);

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@iota/isc-sdk",
+  "author": "IOTA Foundation <info@iota.org>",
+  "version": "0.0.0-dev-20251015065834",
+  "description": "ISC SDK for interacting with IOTA Smart Contracts.",
+  "type": "commonjs",
+  "license": "Apache-2.0",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.4.0",
+    "@iota/bcs": "1.2.0",
+    "@iota/dapp-kit": "0.0.0-dev-20251015065834",
+    "@iota/iota-sdk": "0.0.0-dev-20251015065834"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.10",
+    "dotenv": "^16.4.5",
+    "ethers": "^6.13.5",
+    "tsx": "^3.12.7",
+    "typescript": "^5.5.3",
+    "vite": "^5.4.12",
+    "vite-plugin-dts": "^4.3.0",
+    "vitest": "^2.1.9",
+    "zod": "^3.21.4",
+    "@iota/build-scripts": "0.0.0"
+  },
+  "lint-staged": {
+    "src/**/*.{ts,js,mjs}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "examples/**/*.{ts,js,mjs}": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  },
+  "scripts": {
+    "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
+    "build": "build-package",
+    "eslint:check": "eslint --max-warnings=0 \"./src/**/*.{js,ts}\"",
+    "eslint:fix": "pnpm eslint:check --fix",
+    "prettier:check": "prettier -c --ignore-unknown --ignore-path=.prettierignore .",
+    "prettier:fix": "prettier -w --ignore-unknown --ignore-path=.prettierignore .",
+    "lint": "pnpm eslint:check && pnpm prettier:check",
+    "lint:fix": "pnpm eslint:fix && pnpm prettier:fix",
+    "run:example": "tsx",
+    "test": "vitest"
+  }
+}

package/src/api/EvmRpcClient.ts

@@ -0,0 +1,48 @@
+import type { AssetsResponse } from '../types/index.js';
+
+export class EvmRpcClient {
+    public baseUrl: string;
+
+    constructor(baseUrl?: string) {
+        if (!baseUrl) {
+            throw new Error('Base URL for EVM rpc is required.');
+        }
+        // Normalize baseUrl by removing any trailing slash in the end
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+    }
+
+    private async request<T>(
+        endpoint: string,
+        options?: RequestInit,
+        params?: Record<string, string | number | undefined>,
+    ): Promise<T> {
+        const url = new URL(`${this.baseUrl}${endpoint}`);
+
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    url.searchParams.append(key, value.toString());
+                }
+            });
+        }
+
+        const response = await fetch(url, {
+            ...(options ?? {}),
+            headers: {
+                'Content-Type': 'application/json',
+                ...(options?.headers || {}),
+            },
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`API Error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+
+        return response.json() as T;
+    }
+
+    public getBalanceBaseToken = async (address: string): Promise<AssetsResponse> => {
+        return this.request(`/v1/chain/core/accounts/account/${address}/balance`);
+    };
+}

package/src/api/index.ts

@@ -0,0 +1 @@
+export * from './EvmRpcClient.js';

package/src/bcs.ts

@@ -0,0 +1,237 @@
+import { bcs } from '@iota/iota-sdk/bcs';
+
+export const IotagoObjectRef = bcs.struct('IotagoObjectRef', {
+    objectID: bcs.fixedArray(32, bcs.u8()),
+    version: bcs.u64(),
+    digest: bcs.vector(bcs.u8()),
+});
+
+export const IscmoveAssetsBag = bcs.struct('IscmoveAssetsBag', {
+    iD: bcs.fixedArray(32, bcs.u8()),
+    size: bcs.u64(),
+});
+
+export const IscAssets = bcs.struct('IscAssets', {
+    coins: bcs.map(bcs.string(), bcs.u64()),
+    objects: bcs.map(bcs.fixedArray(32, bcs.u8()), bcs.string()),
+});
+
+export const IscmoveReferent_AssetsBag = bcs.struct('IscmoveReferent_AssetsBag', {
+    iD: bcs.fixedArray(32, bcs.u8()),
+    value: IscmoveAssetsBag,
+});
+
+export const IscmoveAnchor = bcs.struct('IscmoveAnchor', {
+    iD: bcs.fixedArray(32, bcs.u8()),
+    assets: IscmoveReferent_AssetsBag,
+    stateMetadata: bcs.vector(bcs.u8()),
+    stateIndex: bcs.u32(),
+});
+
+export const IscmoveRefWithObject_Anchor = bcs.struct('IscmoveRefWithObject_Anchor', {
+    objectRef: IotagoObjectRef,
+    object: IscmoveAnchor,
+    owner: bcs.fixedArray(32, bcs.u8()),
+});
+
+export const IscStateAnchor = bcs.struct('IscStateAnchor', {
+    anchor: IscmoveRefWithObject_Anchor,
+    iscPackage: bcs.fixedArray(32, bcs.u8()),
+});
+
+export const CoinType = bcs.struct('CoinType', {
+    s: bcs.string(),
+});
+
+export const ParametersBaseToken = bcs.struct('ParametersBaseToken', {
+    name: bcs.string(),
+    tickerSymbol: bcs.string(),
+    unit: bcs.string(),
+    subunit: bcs.string(),
+    decimals: bcs.u8(),
+    useMetricPrefix: bcs.bool(),
+    coinType: CoinType,
+    totalSupply: bcs.u64(),
+});
+
+export const IotajsonrpcBigInt = bcs.struct('IotajsonrpcBigInt', {
+    int: bcs.u256(),
+});
+
+export const ParametersProtocol = bcs.struct('ParametersProtocol', {
+    epoch: IotajsonrpcBigInt,
+    protocolVersion: IotajsonrpcBigInt,
+    systemStateVersion: IotajsonrpcBigInt,
+    iotaTotalSupply: IotajsonrpcBigInt,
+    referenceGasPrice: IotajsonrpcBigInt,
+    epochStartTimestampMs: IotajsonrpcBigInt,
+    epochDurationMs: IotajsonrpcBigInt,
+});
+
+export const ParametersL1Params = bcs.struct('ParametersL1Params', {
+    protocol: ParametersProtocol,
+    baseToken: ParametersBaseToken,
+});
+
+export const BlocklogBlockInfo = bcs.struct('BlocklogBlockInfo', {
+    schemaVersion: bcs.u8(),
+    blockIndex: bcs.u32(),
+    timestamp: bcs.u64(),
+    previousAnchor: IscStateAnchor,
+    l1Params: ParametersL1Params,
+    totalRequests: bcs.u16(),
+    numSuccessfulRequests: bcs.u16(),
+    numOffLedgerRequests: bcs.u16(),
+    gasBurned: bcs.u64(),
+    gasFeeCharged: bcs.u64(),
+});
+
+export const IscCallTarget = bcs.struct('IscCallTarget', {
+    contract: bcs.u32(),
+    entryPoint: bcs.u32(),
+});
+
+export const IscMessage = bcs.struct('IscMessage', {
+    target: IscCallTarget,
+    params: bcs.vector(bcs.vector(bcs.u8())),
+});
+
+export const CryptolibPublicKey = bcs.struct('CryptolibPublicKey', {
+    key: bcs.vector(bcs.u8()),
+});
+
+export const CryptolibSignature = bcs.struct('CryptolibSignature', {
+    signatureScheme: bcs.u8(),
+    publicKey: CryptolibPublicKey,
+    signature: bcs.fixedArray(64, bcs.u8()),
+});
+
+export const RootContractRecord = bcs.struct('RootContractRecord', {
+    name: bcs.string(),
+});
+
+export const LoTuple2_Hname_ContractRecord = bcs.struct('LoTuple2_Hname_ContractRecord', {
+    a: bcs.u32(),
+    b: RootContractRecord,
+});
+
+export const IscContractAgentID = bcs.struct('IscContractAgentID', {
+    hname: bcs.u32(),
+});
+
+export const IscEthereumAddressAgentID = bcs.struct('IscEthereumAddressAgentID', {
+    eth: bcs.fixedArray(20, bcs.u8()),
+});
+
+export const IscNilAgentID = bcs.struct('IscNilAgentID', {});
+
+export const IscAddressAgentID = bcs.struct('IscAddressAgentID', {
+    a: bcs.fixedArray(32, bcs.u8()),
+});
+
+export const IscAgentID = bcs.enum('IscAgentID', {
+    NoType: null,
+    AddressAgentID: IscAddressAgentID,
+    ContractAgentID: IscContractAgentID,
+    EthereumAddressAgentID: IscEthereumAddressAgentID,
+    NilAgentID: IscNilAgentID,
+});
+
+export const balanceInputs = bcs.struct('balanceInputs', {
+    agentID: bcs.option(IscAgentID),
+});
+
+export const balanceOutputs = bcs.struct('balanceOutputs', {
+    coinBalances: bcs.map(CoinType, bcs.u64()),
+});
+
+export const balanceBaseTokenEVMInputs = bcs.struct('balanceBaseTokenEVMInputs', {
+    agentID: bcs.option(IscAgentID),
+});
+
+export const balanceBaseTokenEVMOutputs = bcs.struct('balanceBaseTokenEVMOutputs', {
+    evmBaseTokenBalance: bcs.u256(),
+});
+
+export const AtomicnoCopy = bcs.struct('AtomicnoCopy', {});
+
+export const Atomicalign64 = bcs.struct('Atomicalign64', {});
+
+export const IscEvent = bcs.struct('IscEvent', {
+    contractID: bcs.u32(),
+    topic: bcs.string(),
+    timestamp: bcs.u64(),
+    payload: bcs.vector(bcs.u8()),
+});
+
+export const UtilRatio32 = bcs.struct('UtilRatio32', {
+    a: bcs.u32(),
+    b: bcs.u32(),
+});
+
+export const GasFeePolicy = bcs.struct('GasFeePolicy', {
+    eVMGasRatio: UtilRatio32,
+    gasPerToken: UtilRatio32,
+    validatorFeeShare: bcs.u8(),
+});
+
+export const GasLimits = bcs.struct('GasLimits', {
+    maxGasPerBlock: bcs.u64(),
+    minGasPerRequest: bcs.u64(),
+    maxGasPerRequest: bcs.u64(),
+    maxGasExternalViewCall: bcs.u64(),
+});
+
+export const IscPublicChainMetadata = bcs.struct('IscPublicChainMetadata', {
+    eVMJsonRPCURL: bcs.string(),
+    eVMWebSocketURL: bcs.string(),
+    name: bcs.string(),
+    description: bcs.string(),
+    website: bcs.string(),
+});
+
+export const IscChainInfo = bcs.struct('IscChainInfo', {
+    chainID: bcs.fixedArray(32, bcs.u8()),
+    chainOwnerID: IscAgentID,
+    gasFeePolicy: GasFeePolicy,
+    gasLimits: GasLimits,
+    blockKeepAmount: bcs.bytes(4),
+    publicURL: bcs.string(),
+    metadata: IscPublicChainMetadata,
+});
+
+export const IscVMErrorCode = bcs.struct('IscVMErrorCode', {
+    contractID: bcs.u32(),
+    iD: bcs.u16(),
+});
+
+export const GasBurnRecord = bcs.struct('GasBurnRecord', {
+    code: bcs.u16(),
+    gasBurned: bcs.u64(),
+});
+
+export const IscVMErrorParam = bcs.enum('IscVMErrorParam', {
+    NoType: null,
+    uint16: bcs.u16(),
+    int64: bcs.bytes(8),
+    string: bcs.string(),
+    uint8: bcs.u8(),
+    int32: bcs.bytes(4),
+    uint64: bcs.u64(),
+    int16: bcs.bytes(2),
+    uint32: bcs.u32(),
+});
+
+export const IscUnresolvedVMError = bcs.struct('IscUnresolvedVMError', {
+    errorCode: IscVMErrorCode,
+    params: bcs.vector(IscVMErrorParam),
+});
+
+export const GasBurnLog = bcs.struct('GasBurnLog', {
+    records: bcs.vector(GasBurnRecord),
+});
+
+export const TypesAccessTuple = bcs.struct('TypesAccessTuple', {
+    address: bcs.fixedArray(20, bcs.u8()),
+    storageKeys: bcs.vector(bcs.fixedArray(32, bcs.u8())),
+});

package/src/constants.ts

@@ -0,0 +1,4 @@
+// Base gas used in L1 when sending from L1
+export const L1_BASE_GAS_BUDGET = 10000000n;
+// Gas used in L2 when sending from L1
+export const L2_FROM_L1_GAS_BUDGET = 1000000n;

package/src/enums/contracts.enums.ts

@@ -0,0 +1,82 @@
+export enum CoreContract {
+    Root = 'root',
+    Accounts = 'accounts',
+    Blocklog = 'blocklog',
+    Governance = 'governance',
+    Errors = 'errors',
+    evm = 'evm',
+}
+
+export enum RootContractMethod {
+    FindContract = 'findContract',
+    GetContractRecords = 'getContractRecords',
+}
+
+export enum AccountsContractMethod {
+    Deposit = 'deposit',
+    Withdraw = 'withdraw',
+    TransferAllowanceTo = 'transferAllowanceTo',
+    TransferAccountToChain = 'transferAccountToChain',
+    SetCoinMetadata = 'setCoinMetadata',
+    DeleteCoinMetadata = 'deleteCoinMetadata',
+    Balance = 'balance',
+    BalanceBaseToken = 'balanceBaseToken',
+    BalanceBaseTokenEVM = 'balanceBaseTokenEVM',
+    BalanceCoin = 'balanceCoin',
+    TotalAssets = 'totalAssets',
+    AccountObjects = 'accountObjects',
+    AccountObjectsInCollection = 'accountObjectsInCollection',
+    GetAccountNonce = 'getAccountNonce',
+    ObjectBCS = 'objectBCS',
+}
+
+export enum BlocklogContractMethod {
+    GetBlockInfo = 'getBlockInfo',
+    GetRequestIDsForBlock = 'getRequestIDsForBlock',
+    GetRequestReceipt = 'getRequestReceipt',
+    GetRequestReceiptsForBlock = 'getRequestReceiptsForBlock',
+    IsRequestProcessed = 'isRequestProcessed',
+    GetEventsForRequest = 'getEventsForRequest',
+    GetEventsForBlock = 'getEventsForBlock',
+}
+
+export enum GovernanceContractMethod {
+    RotateStateController = 'rotateStateController',
+    AddAllowedStateControllerAddress = 'addAllowedStateControllerAddress',
+    RemoveAllowedStateControllerAddress = 'removeAllowedStateControllerAddress',
+    DelegateChainOwnership = 'delegateChainOwnership',
+    ClaimChainOwnership = 'claimChainOwnership',
+    SetFeePolicy = 'setFeePolicy',
+    SetGasLimits = 'setGasLimits',
+    SetEVMGasRatio = 'setEVMGasRatio',
+    AddCandidateNode = 'addCandidateNode',
+    RevokeAccessNode = 'revokeAccessNode',
+    ChangeAccessNodes = 'changeAccessNodes',
+    StartMaintenance = 'startMaintenance',
+    StopMaintenance = 'stopMaintenance',
+    SetPayoutAgentID = 'setPayoutAgentID',
+    GetAllowedStateControllerAddresses = 'getAllowedStateControllerAddresses',
+    GetChainOwner = 'getChainOwner',
+    GetChainInfo = 'getChainInfo',
+    GetFeePolicy = 'getFeePolicy',
+    GetGasLimits = 'getGasLimits',
+    GetEVMGasRatio = 'getEVMGasRatio',
+    GetChainNodes = 'getChainNodes',
+    GetMaintenanceStatus = 'getMaintenanceStatus',
+    GetPayoutAgentID = 'getPayoutAgentID',
+    GetMetadata = 'getMetadata',
+}
+
+export enum ErrorsContractMethod {
+    RegisterError = 'registerError',
+    GetErrorMessageFormat = 'getErrorMessageFormat',
+}
+
+export enum EVMContractMethod {
+    RegisterERC20Coin = 'registerERC20Coin',
+    SendTransaction = 'sendTransaction',
+    CallContract = 'callContract',
+    RegisterERC721NFTCollection = 'registerERC721NFTCollection',
+    NewL1Deposit = 'newL1Deposit',
+    GetChainID = 'getChainID',
+}

package/src/enums/index.ts

@@ -0,0 +1 @@
+export * from './contracts.enums.js';

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './enums/index.js';
+export * from './utils/index.js';
+export * from './bcs.js';
+export * from './constants.js';
+export * from './transaction.js';
+export * from './types/index.js';
+export * from './move_bcs.js';
+export * from './api/index.js';
+export * from './types/index.js';