@intentlayer/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Intent Layer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,259 @@
+# @intentlayer/sdk
+
+A TypeScript SDK for building, signing, and verifying intents on Intent Layer.
+
+[![npm version](https://badge.fury.io/js/@intentlayer%2Fsdk.svg)](https://badge.fury.io/js/@intentlayer%2Fsdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Beta Notice
+
+This SDK is in **beta**. Here's what that means for you:
+
+| Area | Stability |
+|------|-----------|
+| `CloudRuntime` API | Stable — safe to build against |
+| Intent signing (`buildIntent`, `signIntent`, `verifyIntent`) | Stable |
+| Error types | May expand — new error classes may be added |
+| Constraint builders | Stable API, coverage expanding |
+
+Breaking changes will follow semver: breaking = major version bump.
+
+## Features
+
+- **EIP-712 Intent Signing** - Cryptographically secure intent signing with viem
+- **Intent Builders** - Easy-to-use functions for building intents
+- **Signature Verification** - Verify intent signatures off-chain
+- **Type-Safe** - Full TypeScript support with strict types
+- **Modern Bundling** - ESM/CJS dual exports for maximum compatibility
+- **Minimal Dependencies** - Only depends on viem for maximum efficiency
+
+## Installation
+
+```bash
+npm install @intentlayer/sdk viem
+# or
+yarn add @intentlayer/sdk viem
+# or
+pnpm add @intentlayer/sdk viem
+```
+
+## Quick Start
+
+```typescript
+import {
+  buildIntent,
+  signIntent,
+  verifyIntent,
+  makeDomain,
+} from "@intentlayer/sdk";
+import { createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// Setup wallet
+const account = privateKeyToAccount("0x...");
+const wallet = createWalletClient({
+  account,
+  chain: mainnet, // or your target chain
+  transport: http(),
+});
+
+// Build an intent
+const intent = buildIntent({
+  policyId: "0x1234...", // Policy ID for the intent
+  amount: 100n,
+  tokenOrRecip: "0xA0b86a33E6842740073e8138aA1204a5d9e31e85", // Token address
+  nonce: 0,
+  intentType: 0,
+  sigType: 0,
+  callData: "0x...", // ABI-encoded function call
+  validFor: 3600, // Valid for 1 hour
+});
+
+// Sign the intent
+const domain = makeDomain(1, "0x..."); // chainId, Intent Manager address
+const signedIntent = await signIntent(intent, domain, wallet);
+
+// Verify the signature
+const isValid = await verifyIntent(signedIntent, domain, account.address);
+
+console.log("Intent signed and verified:", isValid);
+```
+
+## Core Concepts
+
+### Intent Structure
+
+An intent represents a user's desire to perform an action:
+
+```typescript
+interface Intent {
+  policyId: HexString; // Policy governing this intent
+  amount: bigint; // Amount in smallest units
+  tokenOrRecip: Address; // Token or recipient address
+  validUntil: number; // Unix timestamp when intent expires
+  nonce: number; // Anti-replay nonce
+  intentType: number; // Intent type discriminator
+  sigType: number; // Signature type (0 = EOA/EIP-712)
+  callData: HexString; // Executor call data
+  signature?: HexString; // EIP-712 signature (added by signIntent)
+}
+```
+
+### EIP-712 Domain
+
+The SDK uses EIP-712 for secure intent signing:
+
+```typescript
+const domain = makeDomain(
+  31337, // Chain ID (Hardhat local)
+  "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0" // Intent Manager contract address
+);
+```
+
+## API Reference
+
+### Core Functions
+
+#### `buildIntent(args: BuildIntentArgs): Intent`
+
+Creates an unsigned intent object.
+
+```typescript
+const intent = buildIntent({
+  policyId: "0x...",
+  amount: 100n,
+  tokenOrRecip: "0x...",
+  nonce: 0,
+  intentType: 0,
+  sigType: 0,
+  callData: "0x...",
+  validFor: 3600, // Seconds until expiry
+});
+```
+
+#### `signIntent(intent, domain, wallet): Promise<Intent>`
+
+Signs an intent using EIP-712.
+
+```typescript
+const signedIntent = await signIntent(intent, domain, walletClient);
+```
+
+#### `verifyIntent(intent, domain, signer): Promise<boolean>`
+
+Verifies an intent signature.
+
+```typescript
+const isValid = await verifyIntent(signedIntent, domain, signerAddress);
+```
+
+#### `getDigest(intent, domain): HexString`
+
+Computes the EIP-712 digest for an intent.
+
+```typescript
+const digest = getDigest(intent, domain);
+```
+
+#### `makeDomain(chainId, verifyingContract): TypedDataDomain`
+
+Creates the EIP-712 domain for intent signing.
+
+```typescript
+const domain = makeDomain(1, intentManagerAddress);
+```
+
+### Executor Helpers
+
+#### `buildPermit2ExecutorCalldata(args): HexString`
+
+Builds calldata for ERC20 token transfers via Permit2Executor.
+
+```typescript
+import { buildPermit2ExecutorCalldata } from "@intentlayer/sdk";
+
+const callData = buildPermit2ExecutorCalldata({
+  owner: "0x...", // Token owner address
+  token: "0x...", // Token contract address
+  to: "0x...", // Recipient address
+  amount: 100n, // Amount in token's smallest unit
+});
+```
+
+## Testing
+
+The SDK includes comprehensive tests:
+
+```bash
+# Run tests
+yarn test
+
+# Run tests in watch mode
+yarn test:watch
+
+# Run specific test
+yarn test intent.test.ts
+```
+
+## Build from Source
+
+```bash
+# Install dependencies
+yarn install
+
+# Build the SDK
+yarn build
+
+# Run tests
+yarn test
+
+# Generate documentation
+yarn docs
+```
+
+## Examples
+
+### Token Transfer Intent
+
+```typescript
+import { buildIntent, buildPermit2ExecutorCalldata } from "@intentlayer/sdk";
+
+// Build executor calldata for token transfer
+const callData = buildPermit2ExecutorCalldata({
+  owner: wallet.account.address,
+  token: "0xA0b86a33E6842740073e8138aA1204a5d9e31e85",
+  to: "0x742d35Cc641C0532F23c7C4de5Ff2ff2B2Acf5A2",
+  amount: parseUnits("100", 18), // 100 tokens
+});
+
+// Build the intent
+const intent = buildIntent({
+  policyId: "0x1234...",
+  amount: parseUnits("100", 18),
+  tokenOrRecip: "0xA0b86a33E6842740073e8138aA1204a5d9e31e85",
+  nonce: 0,
+  intentType: 0,
+  sigType: 0,
+  callData,
+  validFor: 3600, // 1 hour
+});
+```
+
+### Batch Operations
+
+```typescript
+// Multiple intents can be created and signed together
+const intents = await Promise.all([
+  signIntent(intent1, domain, wallet),
+  signIntent(intent2, domain, wallet),
+  signIntent(intent3, domain, wallet),
+]);
+```
+
+## Development
+
+This SDK is part of the Intent Layer monorepo. See the main README for development setup.
+
+## License
+
+MIT License - see LICENSE file for details.

package/dist/agentConstraintBuilder-CK56UDUI.mjs

@@ -0,0 +1,9 @@
+import {
+  buildV2ConstraintsFromAgent,
+  constraintsToV2Params
+} from "./chunk-GRBEB2EV.mjs";
+import "./chunk-XP4I75K7.mjs";
+export {
+  buildV2ConstraintsFromAgent,
+  constraintsToV2Params
+};

package/dist/chunk-ABTKEYXQ.mjs

@@ -0,0 +1,227 @@
+// src/registryBootstrapBuilder.ts
+import { keccak256, encodePacked } from "viem";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var DEFAULT_VALIDITY_HOURS = 1;
+var DEFAULT_ORACLE_MAX_AGE = 3600;
+var DEFAULT_TIMEOUT_SECONDS = 3600;
+function buildRegistryBootstrapIntent(params) {
+  const validUntil = params.validUntil ?? params.currentTimestamp + BigInt(DEFAULT_VALIDITY_HOURS * 3600);
+  return {
+    // Common fields
+    wallet: params.wallet,
+    nonce: params.nonce ?? 0n,
+    validUntil,
+    chainId: params.chainId,
+    // Vendor Registry
+    enableVendor: params.enableVendor ?? false,
+    vendorProfileId: params.vendorProfileId ?? ZERO_BYTES32,
+    vendorProfileOwner: params.vendorProfileOwner ?? ZERO_ADDRESS,
+    vendorGroups: params.vendorGroups ?? [],
+    sealVendorVersion: params.sealVendorVersion ?? false,
+    // Venue Registry
+    enableVenue: params.enableVenue ?? false,
+    venueProfileId: params.venueProfileId ?? ZERO_BYTES32,
+    venueVersion: params.venueVersion ?? 0,
+    venueTargets: params.venueTargets ?? [],
+    venueSelectors: params.venueSelectors ?? [],
+    // Oracle Registry
+    enableOracle: params.enableOracle ?? false,
+    oracleProfileId: params.oracleProfileId ?? ZERO_BYTES32,
+    oracleVersion: params.oracleVersion ?? 0,
+    oracleMaxAge: params.oracleMaxAge ?? DEFAULT_ORACLE_MAX_AGE,
+    // Approval Registry
+    enableApproval: params.enableApproval ?? false,
+    approvalProfileId: params.approvalProfileId ?? ZERO_BYTES32,
+    softCapUSD: params.softCapUSD ?? 0n,
+    hardCapUSD: params.hardCapUSD ?? 0n,
+    approvers: params.approvers ?? [],
+    requiredSigs: params.requiredSigs ?? 0,
+    timeoutSeconds: params.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS
+  };
+}
+function buildVendorOnlyIntent(params) {
+  return buildRegistryBootstrapIntent({
+    ...params,
+    enableVendor: true,
+    sealVendorVersion: params.sealVendorVersion ?? true
+  });
+}
+function buildVenueOnlyIntent(params) {
+  return buildRegistryBootstrapIntent({
+    ...params,
+    enableVenue: true
+  });
+}
+function buildOracleOnlyIntent(params) {
+  return buildRegistryBootstrapIntent({
+    ...params,
+    enableOracle: true
+  });
+}
+function buildApprovalOnlyIntent(params) {
+  return buildRegistryBootstrapIntent({
+    ...params,
+    enableApproval: true
+  });
+}
+function buildAllRegistriesIntent(params) {
+  return buildRegistryBootstrapIntent({
+    ...params,
+    enableVendor: true,
+    sealVendorVersion: params.sealVendorVersion ?? true,
+    enableVenue: true,
+    enableOracle: true,
+    enableApproval: true
+  });
+}
+function validateRegistryBootstrapIntent(intent, currentTimestamp) {
+  const errors = [];
+  if (!intent.wallet || intent.wallet === ZERO_ADDRESS) {
+    errors.push("Wallet address is required");
+  }
+  if (intent.chainId === 0n) {
+    errors.push("Chain ID must be non-zero");
+  }
+  if (currentTimestamp && intent.validUntil <= currentTimestamp) {
+    errors.push("Intent has already expired");
+  }
+  if (!intent.enableVendor && !intent.enableVenue && !intent.enableOracle && !intent.enableApproval) {
+    errors.push("At least one registry must be enabled");
+  }
+  if (intent.enableVendor) {
+    if (intent.vendorProfileId === ZERO_BYTES32) {
+      errors.push("Vendor profile ID is required when vendor is enabled");
+    }
+    if (intent.vendorGroups.length === 0) {
+      errors.push("At least one vendor group is required when vendor is enabled");
+    }
+    for (let i = 0; i < intent.vendorGroups.length; i++) {
+      const group = intent.vendorGroups[i];
+      if (group.groupId === ZERO_BYTES32) {
+        errors.push(`Vendor group ${i} has invalid groupId`);
+      }
+      if (group.merkleRoot === ZERO_BYTES32) {
+        errors.push(`Vendor group ${i} has invalid merkleRoot`);
+      }
+    }
+  }
+  if (intent.enableVenue) {
+    if (intent.venueProfileId === ZERO_BYTES32) {
+      errors.push("Venue profile ID is required when venue is enabled");
+    }
+    if (intent.venueTargets.length === 0) {
+      errors.push("At least one venue target is required when venue is enabled");
+    }
+    if (intent.venueSelectors.length === 0) {
+      errors.push("At least one venue selector is required when venue is enabled");
+    }
+  }
+  if (intent.enableOracle) {
+    if (intent.oracleProfileId === ZERO_BYTES32) {
+      errors.push("Oracle profile ID is required when oracle is enabled");
+    }
+    if (intent.oracleMaxAge === 0) {
+      errors.push("Oracle max age must be non-zero");
+    }
+  }
+  if (intent.enableApproval) {
+    if (intent.approvalProfileId === ZERO_BYTES32) {
+      errors.push("Approval profile ID is required when approval is enabled");
+    }
+    if (intent.approvers.length === 0) {
+      errors.push("At least one approver is required when approval is enabled");
+    }
+    if (intent.requiredSigs === 0) {
+      errors.push("Required signatures must be non-zero");
+    }
+    if (intent.requiredSigs > intent.approvers.length) {
+      errors.push("Required signatures cannot exceed number of approvers");
+    }
+    if (intent.softCapUSD > intent.hardCapUSD) {
+      errors.push("Soft cap cannot exceed hard cap");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function generateProfileId(organization, profileName) {
+  return keccak256(encodePacked(["string", "string"], [organization, profileName]));
+}
+function hasRegistriesEnabled(intent) {
+  return intent.enableVendor || intent.enableVenue || intent.enableOracle || intent.enableApproval;
+}
+function summarizeRegistryFeatures(intent) {
+  const features = [];
+  if (intent.enableVendor) {
+    features.push(`Vendor (${intent.vendorGroups.length} groups${intent.sealVendorVersion ? ", sealed" : ""})`);
+  }
+  if (intent.enableVenue) {
+    features.push(`Venue (${intent.venueTargets.length} targets, ${intent.venueSelectors.length} selectors)`);
+  }
+  if (intent.enableOracle) {
+    features.push(`Oracle (maxAge: ${intent.oracleMaxAge}s)`);
+  }
+  if (intent.enableApproval) {
+    features.push(`Approval (${intent.requiredSigs}/${intent.approvers.length} sigs, soft: $${Number(intent.softCapUSD) / 1e8}, hard: $${Number(intent.hardCapUSD) / 1e8})`);
+  }
+  if (features.length === 0) {
+    return "No registries enabled";
+  }
+  return features.join(", ");
+}
+function stringToProfileId(profileName) {
+  const bytes = new TextEncoder().encode(profileName);
+  const padded = new Uint8Array(32);
+  padded.set(bytes.slice(0, 32));
+  return "0x" + Array.from(padded).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function serializeRegistryIntent(intent) {
+  return {
+    wallet: intent.wallet,
+    nonce: intent.nonce.toString(),
+    validUntil: intent.validUntil.toString(),
+    chainId: intent.chainId.toString(),
+    enableVendor: intent.enableVendor,
+    vendorProfileId: intent.vendorProfileId,
+    vendorProfileOwner: intent.vendorProfileOwner,
+    vendorGroups: intent.vendorGroups.map((g) => ({
+      groupId: g.groupId,
+      merkleRoot: g.merkleRoot
+    })),
+    sealVendorVersion: intent.sealVendorVersion,
+    enableVenue: intent.enableVenue,
+    venueProfileId: intent.venueProfileId,
+    venueVersion: intent.venueVersion,
+    venueTargets: intent.venueTargets,
+    venueSelectors: intent.venueSelectors,
+    enableOracle: intent.enableOracle,
+    oracleProfileId: intent.oracleProfileId,
+    oracleVersion: intent.oracleVersion,
+    oracleMaxAge: intent.oracleMaxAge,
+    enableApproval: intent.enableApproval,
+    approvalProfileId: intent.approvalProfileId,
+    softCapUSD: intent.softCapUSD.toString(),
+    hardCapUSD: intent.hardCapUSD.toString(),
+    approvers: intent.approvers,
+    requiredSigs: intent.requiredSigs,
+    timeoutSeconds: intent.timeoutSeconds
+  };
+}
+
+export {
+  buildRegistryBootstrapIntent,
+  buildVendorOnlyIntent,
+  buildVenueOnlyIntent,
+  buildOracleOnlyIntent,
+  buildApprovalOnlyIntent,
+  buildAllRegistriesIntent,
+  validateRegistryBootstrapIntent,
+  generateProfileId,
+  hasRegistriesEnabled,
+  summarizeRegistryFeatures,
+  stringToProfileId,
+  serializeRegistryIntent
+};