@thyme-sh/sdk 0.2.0

package/README.md

@@ -0,0 +1,256 @@
+# @thyme-sh/sdk
+
+SDK for authoring Web3 automation tasks with Thyme.
+
+## Installation
+
+```bash
+npm install @thyme-sh/sdk zod viem
+```
+
+## Usage
+
+Create a task with embedded schema:
+
+```typescript
+import { defineTask, z } from '@thyme-sh/sdk'
+import { encodeFunctionData } from 'viem'
+
+const abi = [
+  {
+    name: 'updatePrice',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'price', type: 'uint256' }],
+    outputs: [],
+  },
+  {
+    name: 'getPrice',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [],
+    outputs: [{ type: 'uint256' }],
+  },
+] as const
+
+export default defineTask({
+  // Define your arguments schema with type-safe Ethereum addresses
+  schema: z.object({
+    oracleAddress: z.address(), // Validates and returns viem's Address type
+    threshold: z.number().min(0),
+  }),
+
+  // Main execution logic
+  async run(ctx) {
+    const { oracleAddress, threshold } = ctx.args
+    
+    // Read from blockchain using the public client
+    const lastPrice = await ctx.client.readContract({
+      address: oracleAddress,
+      abi,
+      functionName: 'getPrice',
+    })
+    
+    // Your logic here
+    const price = await fetchPrice()
+    
+    if (price > threshold && price !== lastPrice) {
+      return {
+        canExec: true,
+        calls: [{
+          to: oracleAddress,
+          data: encodeFunctionData({
+            abi,
+            functionName: 'updatePrice',
+            args: [price],
+          }),
+        }]
+      }
+    }
+    
+    return {
+      canExec: false,
+      message: 'Price below threshold or unchanged'
+    }
+  },
+
+  // Optional: Handle successful execution
+  async onSuccess(ctx, txHashes) {
+    console.log('Executed:', txHashes)
+  },
+
+  // Optional: Handle failed execution
+  async onFail(ctx, error) {
+    console.error('Failed:', error.message)
+  },
+})
+```
+
+## Schema Validation
+
+The SDK provides an extended Zod instance with Ethereum-specific validators:
+
+### `z.address()`
+
+Validates an Ethereum address and returns viem's `Address` type:
+
+```typescript
+import { defineTask, z } from '@thyme-sh/sdk'
+
+export default defineTask({
+  schema: z.object({
+    targetAddress: z.address(), // Validates checksum and format
+  }),
+  async run(ctx) {
+    // ctx.args.targetAddress is typed as Address from viem
+    return {
+      canExec: true,
+      calls: [{
+        to: ctx.args.targetAddress,
+        data: '0x',
+      }]
+    }
+  }
+})
+```
+
+You can also use standard Zod validators:
+
+```typescript
+schema: z.object({
+  address: z.address(),
+  amount: z.bigint().positive(),
+  enabled: z.boolean(),
+  metadata: z.string().optional(),
+})
+```
+
+## Public Client
+
+The context includes a viem `PublicClient` for reading blockchain data:
+
+```typescript
+import { defineTask, z } from '@thyme-sh/sdk'
+
+export default defineTask({
+  schema: z.object({
+    tokenAddress: z.address(),
+    threshold: z.bigint(),
+  }),
+  
+  async run(ctx) {
+    // Read contract state
+    const totalSupply = await ctx.client.readContract({
+      address: ctx.args.tokenAddress,
+      abi: [{
+        name: 'totalSupply',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: 'uint256' }],
+      }],
+      functionName: 'totalSupply',
+    })
+    
+    // Get block data
+    const blockNumber = await ctx.client.getBlockNumber()
+    const block = await ctx.client.getBlock({ blockNumber })
+    
+    // Get balance
+    const balance = await ctx.client.getBalance({
+      address: ctx.args.tokenAddress,
+    })
+    
+    if (totalSupply > ctx.args.threshold) {
+      return {
+        canExec: true,
+        calls: [...]
+      }
+    }
+    
+    return {
+      canExec: false,
+      message: 'Threshold not met'
+    }
+  }
+})
+```
+
+The client is configured using the `RPC_URL` environment variable in your `.env` file.
+
+## Encoding Function Calls
+
+Use viem's `encodeFunctionData` to encode function calls:
+
+```typescript
+import { defineTask, z } from '@thyme-sh/sdk'
+import { encodeFunctionData } from 'viem'
+
+const abi = [
+  'function transfer(address to, uint256 amount) returns (bool)',
+] as const
+
+export default defineTask({
+  schema: z.object({
+    token: z.address(),
+    recipient: z.address(),
+  }),
+  
+  async run(ctx) {
+    return {
+      canExec: true,
+      calls: [{
+        to: ctx.args.token,
+        data: encodeFunctionData({
+          abi,
+          functionName: 'transfer',
+          args: [ctx.args.recipient, 1000n],
+        }),
+      }]
+    }
+  }
+})
+```
+
+Viem's `encodeFunctionData` provides full type safety and validation.
+
+## API
+
+### `defineTask(definition)`
+
+Define a Web3 automation task.
+
+#### Parameters
+
+- `definition.schema` - Zod schema for validating task arguments
+- `definition.run` - Main execution function that returns whether to execute and what calls to make
+- `definition.onSuccess` - Optional callback on successful execution
+- `definition.onFail` - Optional callback on failed execution
+
+#### Returns
+
+The task definition (for type inference).
+
+## Types
+
+### `ThymeContext<TArgs>`
+
+Context provided to task execution:
+- `args` - User-provided arguments validated against schema
+- `client` - Viem public client for reading blockchain data
+
+### `TaskResult`
+
+Result from task execution:
+- `{ canExec: true, calls: Call[] }` - Execute these calls
+- `{ canExec: false, message: string }` - Don't execute, with reason
+
+### `Call`
+
+A call to execute on-chain:
+- `to` - Target contract address
+- `data` - Encoded function call data
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,310 @@
+import { z } from 'zod';
+import { PublicClient, Address, Hex } from 'viem';
+
+/**
+ * Context provided to task execution
+ */
+interface ThymeContext<TArgs> {
+    /** User-provided arguments validated against schema */
+    args: TArgs;
+    /** Viem public client for reading blockchain data */
+    client: PublicClient;
+}
+/**
+ * A call to be executed on-chain
+ */
+interface Call {
+    /** Target contract address */
+    to: Address;
+    /** Encoded function call data */
+    data: Hex;
+}
+/**
+ * Result when task determines execution should proceed
+ */
+interface SuccessResult {
+    canExec: true;
+    /** Array of calls to execute on-chain */
+    calls: Call[];
+}
+/**
+ * Result when task determines execution should not proceed
+ */
+interface FailResult {
+    canExec: false;
+    /** Reason why execution should not proceed */
+    message: string;
+}
+/**
+ * Result returned from task execution
+ */
+type TaskResult = SuccessResult | FailResult;
+/**
+ * Task definition with schema and execution logic
+ */
+interface TaskDefinition<TSchema extends z.ZodType> {
+    /** Zod schema for validating task arguments */
+    schema: TSchema;
+    /** Main execution function */
+    run: (ctx: ThymeContext<z.infer<TSchema>>) => Promise<TaskResult>;
+}
+
+/**
+ * Define a Web3 automation task
+ *
+ * @example
+ * ```typescript
+ * import { defineTask, z } from '@thyme-sh/sdk'
+ * import { encodeFunctionData } from 'viem'
+ *
+ * const abi = [
+ *   'function transfer(address to, uint256 amount) returns (bool)',
+ * ] as const
+ *
+ * export default defineTask({
+ *   schema: z.object({
+ *     targetAddress: z.address(),
+ *   }),
+ *   async run(ctx) {
+ *     return {
+ *       canExec: true,
+ *       calls: [{
+ *         to: ctx.args.targetAddress,
+ *         data: encodeFunctionData({
+ *           abi,
+ *           functionName: 'transfer',
+ *           args: [recipientAddress, 1000n],
+ *         }),
+ *       }]
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare function defineTask<TSchema extends z.ZodType>(definition: TaskDefinition<TSchema>): TaskDefinition<TSchema>;
+
+/**
+ * Extended Zod with Ethereum address validation
+ */
+declare const zodExtended: {
+    /**
+     * Validates an Ethereum address and returns viem's Address type
+     * Accepts both checksummed and non-checksummed addresses
+     *
+     * @example
+     * ```typescript
+     * import { zodExtended as z } from '@thyme-sh/sdk'
+     *
+     * const schema = z.object({
+     *   targetAddress: z.address(),
+     * })
+     * ```
+     */
+    address: () => z.ZodEffects<z.ZodEffects<z.ZodString, `0x${string}`, string>, `0x${string}`, string>;
+    setErrorMap(map: z.ZodErrorMap): void;
+    getErrorMap(): z.ZodErrorMap;
+    defaultErrorMap: z.ZodErrorMap;
+    addIssueToContext(ctx: z.ParseContext, issueData: z.IssueData): void;
+    makeIssue: (params: {
+        data: any;
+        path: (string | number)[];
+        errorMaps: z.ZodErrorMap[];
+        issueData: z.IssueData;
+    }) => z.ZodIssue;
+    EMPTY_PATH: z.ParsePath;
+    ParseStatus: typeof z.ParseStatus;
+    INVALID: z.INVALID;
+    DIRTY: <T>(value: T) => z.DIRTY<T>;
+    OK: <T>(value: T) => z.OK<T>;
+    isAborted: (x: z.ParseReturnType<any>) => x is z.INVALID;
+    isDirty: <T>(x: z.ParseReturnType<T>) => x is z.OK<T> | z.DIRTY<T>;
+    isValid: <T>(x: z.ParseReturnType<T>) => x is z.OK<T>;
+    isAsync: <T>(x: z.ParseReturnType<T>) => x is z.AsyncParseReturnType<T>;
+    util: typeof z.util;
+    objectUtil: typeof z.objectUtil;
+    ZodParsedType: {
+        string: "string";
+        nan: "nan";
+        number: "number";
+        integer: "integer";
+        float: "float";
+        boolean: "boolean";
+        date: "date";
+        bigint: "bigint";
+        symbol: "symbol";
+        function: "function";
+        undefined: "undefined";
+        null: "null";
+        array: "array";
+        object: "object";
+        unknown: "unknown";
+        promise: "promise";
+        void: "void";
+        never: "never";
+        map: "map";
+        set: "set";
+    };
+    getParsedType: (data: any) => z.ZodParsedType;
+    datetimeRegex(args: {
+        precision?: number | null;
+        offset?: boolean;
+        local?: boolean;
+    }): RegExp;
+    custom<T>(check?: (data: any) => any, _params?: string | (Partial<z.util.Omit<z.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
+    }) | ((input: any) => Partial<z.util.Omit<z.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
+    }), fatal?: boolean): z.ZodType<T, z.ZodTypeDef, T>;
+    ZodType: typeof z.ZodType;
+    ZodString: typeof z.ZodString;
+    ZodNumber: typeof z.ZodNumber;
+    ZodBigInt: typeof z.ZodBigInt;
+    ZodBoolean: typeof z.ZodBoolean;
+    ZodDate: typeof z.ZodDate;
+    ZodSymbol: typeof z.ZodSymbol;
+    ZodUndefined: typeof z.ZodUndefined;
+    ZodNull: typeof z.ZodNull;
+    ZodAny: typeof z.ZodAny;
+    ZodUnknown: typeof z.ZodUnknown;
+    ZodNever: typeof z.ZodNever;
+    ZodVoid: typeof z.ZodVoid;
+    ZodArray: typeof z.ZodArray;
+    ZodObject: typeof z.ZodObject;
+    ZodUnion: typeof z.ZodUnion;
+    ZodDiscriminatedUnion: typeof z.ZodDiscriminatedUnion;
+    ZodIntersection: typeof z.ZodIntersection;
+    ZodTuple: typeof z.ZodTuple;
+    ZodRecord: typeof z.ZodRecord;
+    ZodMap: typeof z.ZodMap;
+    ZodSet: typeof z.ZodSet;
+    ZodFunction: typeof z.ZodFunction;
+    ZodLazy: typeof z.ZodLazy;
+    ZodLiteral: typeof z.ZodLiteral;
+    ZodEnum: typeof z.ZodEnum;
+    ZodNativeEnum: typeof z.ZodNativeEnum;
+    ZodPromise: typeof z.ZodPromise;
+    ZodEffects: typeof z.ZodEffects;
+    ZodTransformer: typeof z.ZodEffects;
+    ZodOptional: typeof z.ZodOptional;
+    ZodNullable: typeof z.ZodNullable;
+    ZodDefault: typeof z.ZodDefault;
+    ZodCatch: typeof z.ZodCatch;
+    ZodNaN: typeof z.ZodNaN;
+    BRAND: typeof z.BRAND;
+    ZodBranded: typeof z.ZodBranded;
+    ZodPipeline: typeof z.ZodPipeline;
+    ZodReadonly: typeof z.ZodReadonly;
+    Schema: typeof z.ZodType;
+    ZodSchema: typeof z.ZodType;
+    late: {
+        object: <Shape extends z.ZodRawShape>(shape: () => Shape, params?: z.RawCreateParams) => z.ZodObject<Shape, "strip">;
+    };
+    ZodFirstPartyTypeKind: typeof z.ZodFirstPartyTypeKind;
+    coerce: {
+        string: (typeof z.ZodString)["create"];
+        number: (typeof z.ZodNumber)["create"];
+        boolean: (typeof z.ZodBoolean)["create"];
+        bigint: (typeof z.ZodBigInt)["create"];
+        date: (typeof z.ZodDate)["create"];
+    };
+    any: (params?: z.RawCreateParams) => z.ZodAny;
+    array: <El extends z.ZodTypeAny>(schema: El, params?: z.RawCreateParams) => z.ZodArray<El>;
+    bigint: (params?: z.RawCreateParams & {
+        coerce?: boolean;
+    }) => z.ZodBigInt;
+    boolean: (params?: z.RawCreateParams & {
+        coerce?: boolean;
+    }) => z.ZodBoolean;
+    date: (params?: z.RawCreateParams & {
+        coerce?: boolean;
+    }) => z.ZodDate;
+    discriminatedUnion: typeof z.ZodDiscriminatedUnion.create;
+    effect: <I extends z.ZodTypeAny>(schema: I, effect: z.Effect<I["_output"]>, params?: z.RawCreateParams) => z.ZodEffects<I, I["_output"]>;
+    enum: {
+        <U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: z.RawCreateParams): z.ZodEnum<z.Writeable<T>>;
+        <U extends string, T extends [U, ...U[]]>(values: T, params?: z.RawCreateParams): z.ZodEnum<T>;
+    };
+    function: typeof z.ZodFunction.create;
+    instanceof: <T extends abstract new (..._: any[]) => {}>(cls: T, params?: Partial<z.util.Omit<z.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
+    }) => z.ZodType<InstanceType<T>, z.ZodTypeDef, InstanceType<T>>;
+    intersection: <TSchema extends z.ZodTypeAny, USchema extends z.ZodTypeAny>(left: TSchema, right: USchema, params?: z.RawCreateParams) => z.ZodIntersection<TSchema, USchema>;
+    lazy: <Inner extends z.ZodTypeAny>(getter: () => Inner, params?: z.RawCreateParams) => z.ZodLazy<Inner>;
+    literal: <Value extends z.Primitive>(value: Value, params?: z.RawCreateParams) => z.ZodLiteral<Value>;
+    map: <KeySchema extends z.ZodTypeAny = z.ZodTypeAny, ValueSchema extends z.ZodTypeAny = z.ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: z.RawCreateParams) => z.ZodMap<KeySchema, ValueSchema>;
+    nan: (params?: z.RawCreateParams) => z.ZodNaN;
+    nativeEnum: <Elements extends z.EnumLike>(values: Elements, params?: z.RawCreateParams) => z.ZodNativeEnum<Elements>;
+    never: (params?: z.RawCreateParams) => z.ZodNever;
+    null: (params?: z.RawCreateParams) => z.ZodNull;
+    nullable: <Inner extends z.ZodTypeAny>(type: Inner, params?: z.RawCreateParams) => z.ZodNullable<Inner>;
+    number: (params?: z.RawCreateParams & {
+        coerce?: boolean;
+    }) => z.ZodNumber;
+    object: <Shape extends z.ZodRawShape>(shape: Shape, params?: z.RawCreateParams) => z.ZodObject<Shape, "strip", z.ZodTypeAny, z.objectOutputType<Shape, z.ZodTypeAny, "strip">, z.objectInputType<Shape, z.ZodTypeAny, "strip">>;
+    oboolean: () => z.ZodOptional<z.ZodBoolean>;
+    onumber: () => z.ZodOptional<z.ZodNumber>;
+    optional: <Inner extends z.ZodTypeAny>(type: Inner, params?: z.RawCreateParams) => z.ZodOptional<Inner>;
+    ostring: () => z.ZodOptional<z.ZodString>;
+    pipeline: typeof z.ZodPipeline.create;
+    preprocess: <I extends z.ZodTypeAny>(preprocess: (arg: unknown, ctx: z.RefinementCtx) => unknown, schema: I, params?: z.RawCreateParams) => z.ZodEffects<I, I["_output"], unknown>;
+    promise: <Inner extends z.ZodTypeAny>(schema: Inner, params?: z.RawCreateParams) => z.ZodPromise<Inner>;
+    record: typeof z.ZodRecord.create;
+    set: <ValueSchema extends z.ZodTypeAny = z.ZodTypeAny>(valueType: ValueSchema, params?: z.RawCreateParams) => z.ZodSet<ValueSchema>;
+    strictObject: <Shape extends z.ZodRawShape>(shape: Shape, params?: z.RawCreateParams) => z.ZodObject<Shape, "strict">;
+    string: (params?: z.RawCreateParams & {
+        coerce?: true;
+    }) => z.ZodString;
+    symbol: (params?: z.RawCreateParams) => z.ZodSymbol;
+    transformer: <I extends z.ZodTypeAny>(schema: I, effect: z.Effect<I["_output"]>, params?: z.RawCreateParams) => z.ZodEffects<I, I["_output"]>;
+    tuple: <Items extends [z.ZodTypeAny, ...z.ZodTypeAny[]] | []>(schemas: Items, params?: z.RawCreateParams) => z.ZodTuple<Items, null>;
+    undefined: (params?: z.RawCreateParams) => z.ZodUndefined;
+    union: <Options extends Readonly<[z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>>(types: Options, params?: z.RawCreateParams) => z.ZodUnion<Options>;
+    unknown: (params?: z.RawCreateParams) => z.ZodUnknown;
+    void: (params?: z.RawCreateParams) => z.ZodVoid;
+    NEVER: never;
+    ZodIssueCode: {
+        invalid_type: "invalid_type";
+        invalid_literal: "invalid_literal";
+        custom: "custom";
+        invalid_union: "invalid_union";
+        invalid_union_discriminator: "invalid_union_discriminator";
+        invalid_enum_value: "invalid_enum_value";
+        unrecognized_keys: "unrecognized_keys";
+        invalid_arguments: "invalid_arguments";
+        invalid_return_type: "invalid_return_type";
+        invalid_date: "invalid_date";
+        invalid_string: "invalid_string";
+        too_small: "too_small";
+        too_big: "too_big";
+        invalid_intersection_types: "invalid_intersection_types";
+        not_multiple_of: "not_multiple_of";
+        not_finite: "not_finite";
+    };
+    quotelessJson: (obj: any) => string;
+    ZodError: typeof z.ZodError;
+};
+/**
+ * Type helper to infer the schema type
+ */
+type InferSchema<T extends z.ZodType> = z.infer<T>;
+
+interface CompressResult {
+    zipBuffer: Uint8Array;
+    checksum: string;
+}
+interface DecompressResult {
+    source: string;
+    bundle: string;
+}
+/**
+ * Compress source and bundle into a ZIP archive
+ * Uses fflate for fast, modern compression
+ */
+declare function compressTask(source: string, bundle: string): CompressResult;
+/**
+ * Decompress ZIP archive and extract source and bundle files
+ * Uses fflate for fast decompression
+ */
+declare function decompressTask(zipBuffer: Uint8Array | ArrayBuffer): DecompressResult;
+
+export { type Call, type CompressResult, type DecompressResult, type FailResult, type InferSchema, type SuccessResult, type TaskDefinition, type TaskResult, type ThymeContext, compressTask, decompressTask, defineTask, zodExtended as z };

package/dist/index.js

@@ -0,0 +1,78 @@
+// src/task.ts
+function defineTask(definition) {
+  return definition;
+}
+
+// src/schema.ts
+import { getAddress, isAddress } from "viem";
+import { z } from "zod";
+var zodExtended = {
+  ...z,
+  /**
+   * Validates an Ethereum address and returns viem's Address type
+   * Accepts both checksummed and non-checksummed addresses
+   *
+   * @example
+   * ```typescript
+   * import { zodExtended as z } from '@thyme-sh/sdk'
+   *
+   * const schema = z.object({
+   *   targetAddress: z.address(),
+   * })
+   * ```
+   */
+  address: () => z.string().refine((val) => isAddress(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => getAddress(val))
+};
+
+// src/archive.ts
+import { strFromU8, strToU8, unzipSync, zipSync } from "fflate";
+function compressTask(source, bundle) {
+  const files = {
+    "source.ts": strToU8(source),
+    "bundle.js": strToU8(bundle)
+  };
+  const compressed = zipSync(files, {
+    level: 6
+    // Balanced compression
+  });
+  let hash = 0;
+  for (let i = 0; i < compressed.length; i++) {
+    const byte = compressed[i];
+    if (byte !== void 0) {
+      hash = (hash << 5) - hash + byte;
+      hash = hash & hash;
+    }
+  }
+  const checksum = Math.abs(hash).toString(16);
+  return {
+    zipBuffer: compressed,
+    checksum
+  };
+}
+function decompressTask(zipBuffer) {
+  const uint8Array = zipBuffer instanceof ArrayBuffer ? new Uint8Array(zipBuffer) : zipBuffer;
+  const decompressed = unzipSync(uint8Array);
+  const sourceBytes = decompressed["source.ts"];
+  const bundleBytes = decompressed["bundle.js"];
+  if (!sourceBytes) {
+    throw new Error("source.ts not found in ZIP archive");
+  }
+  if (!bundleBytes) {
+    throw new Error("bundle.js not found in ZIP archive");
+  }
+  const source = strFromU8(sourceBytes);
+  const bundle = strFromU8(bundleBytes);
+  return {
+    source,
+    bundle
+  };
+}
+export {
+  compressTask,
+  decompressTask,
+  defineTask,
+  zodExtended as z
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/task.ts","../src/schema.ts","../src/archive.ts"],"sourcesContent":["import type { z } from 'zod'\nimport type { TaskDefinition } from './types'\n\n/**\n * Define a Web3 automation task\n *\n * @example\n * ```typescript\n * import { defineTask, z } from '@thyme-sh/sdk'\n * import { encodeFunctionData } from 'viem'\n *\n * const abi = [\n *   'function transfer(address to, uint256 amount) returns (bool)',\n * ] as const\n *\n * export default defineTask({\n *   schema: z.object({\n *     targetAddress: z.address(),\n *   }),\n *   async run(ctx) {\n *     return {\n *       canExec: true,\n *       calls: [{\n *         to: ctx.args.targetAddress,\n *         data: encodeFunctionData({\n *           abi,\n *           functionName: 'transfer',\n *           args: [recipientAddress, 1000n],\n *         }),\n *       }]\n *     }\n *   }\n * })\n * ```\n */\nexport function defineTask<TSchema extends z.ZodType>(\n\tdefinition: TaskDefinition<TSchema>,\n): TaskDefinition<TSchema> {\n\treturn definition\n}\n","import { type Address, getAddress, isAddress } from 'viem'\nimport { z } from 'zod'\n\n/**\n * Extended Zod with Ethereum address validation\n */\nexport const zodExtended = {\n\t...z,\n\t/**\n\t * Validates an Ethereum address and returns viem's Address type\n\t * Accepts both checksummed and non-checksummed addresses\n\t *\n\t * @example\n\t * ```typescript\n\t * import { zodExtended as z } from '@thyme-sh/sdk'\n\t *\n\t * const schema = z.object({\n\t *   targetAddress: z.address(),\n\t * })\n\t * ```\n\t */\n\taddress: () =>\n\t\tz\n\t\t\t.string()\n\t\t\t.refine((val): val is Address => isAddress(val), {\n\t\t\t\tmessage: 'Invalid Ethereum address',\n\t\t\t})\n\t\t\t.transform((val) => getAddress(val)),\n}\n\n/**\n * Type helper to infer the schema type\n */\nexport type InferSchema<T extends z.ZodType> = z.infer<T>\n","import { strFromU8, strToU8, unzipSync, zipSync } from 'fflate'\n\nexport interface CompressResult {\n\tzipBuffer: Uint8Array\n\tchecksum: string\n}\n\nexport interface DecompressResult {\n\tsource: string\n\tbundle: string\n}\n\n/**\n * Compress source and bundle into a ZIP archive\n * Uses fflate for fast, modern compression\n */\nexport function compressTask(source: string, bundle: string): CompressResult {\n\t// Create ZIP archive with both files\n\tconst files = {\n\t\t'source.ts': strToU8(source),\n\t\t'bundle.js': strToU8(bundle),\n\t}\n\n\tconst compressed = zipSync(files, {\n\t\tlevel: 6, // Balanced compression\n\t})\n\n\t// Calculate checksum (simple hash for now)\n\tlet hash = 0\n\tfor (let i = 0; i < compressed.length; i++) {\n\t\tconst byte = compressed[i]\n\t\tif (byte !== undefined) {\n\t\t\thash = (hash << 5) - hash + byte\n\t\t\thash = hash & hash // Convert to 32bit integer\n\t\t}\n\t}\n\tconst checksum = Math.abs(hash).toString(16)\n\n\treturn {\n\t\tzipBuffer: compressed,\n\t\tchecksum,\n\t}\n}\n\n/**\n * Decompress ZIP archive and extract source and bundle files\n * Uses fflate for fast decompression\n */\nexport function decompressTask(\n\tzipBuffer: Uint8Array | ArrayBuffer,\n): DecompressResult {\n\t// Convert ArrayBuffer to Uint8Array if needed\n\tconst uint8Array =\n\t\tzipBuffer instanceof ArrayBuffer ? new Uint8Array(zipBuffer) : zipBuffer\n\n\t// Decompress ZIP\n\tconst decompressed = unzipSync(uint8Array)\n\n\t// Extract files\n\tconst sourceBytes = decompressed['source.ts']\n\tconst bundleBytes = decompressed['bundle.js']\n\n\tif (!sourceBytes) {\n\t\tthrow new Error('source.ts not found in ZIP archive')\n\t}\n\n\tif (!bundleBytes) {\n\t\tthrow new Error('bundle.js not found in ZIP archive')\n\t}\n\n\t// Convert bytes to strings\n\tconst source = strFromU8(sourceBytes)\n\tconst bundle = strFromU8(bundleBytes)\n\n\treturn {\n\t\tsource,\n\t\tbundle,\n\t}\n}\n"],"mappings":";AAmCO,SAAS,WACf,YAC0B;AAC1B,SAAO;AACR;;;ACvCA,SAAuB,YAAY,iBAAiB;AACpD,SAAS,SAAS;AAKX,IAAM,cAAc;AAAA,EAC1B,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcH,SAAS,MACR,EACE,OAAO,EACP,OAAO,CAAC,QAAwB,UAAU,GAAG,GAAG;AAAA,IAChD,SAAS;AAAA,EACV,CAAC,EACA,UAAU,CAAC,QAAQ,WAAW,GAAG,CAAC;AACtC;;;AC5BA,SAAS,WAAW,SAAS,WAAW,eAAe;AAgBhD,SAAS,aAAa,QAAgB,QAAgC;AAE5E,QAAM,QAAQ;AAAA,IACb,aAAa,QAAQ,MAAM;AAAA,IAC3B,aAAa,QAAQ,MAAM;AAAA,EAC5B;AAEA,QAAM,aAAa,QAAQ,OAAO;AAAA,IACjC,OAAO;AAAA;AAAA,EACR,CAAC;AAGD,MAAI,OAAO;AACX,WAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AAC3C,UAAM,OAAO,WAAW,CAAC;AACzB,QAAI,SAAS,QAAW;AACvB,cAAQ,QAAQ,KAAK,OAAO;AAC5B,aAAO,OAAO;AAAA,IACf;AAAA,EACD;AACA,QAAM,WAAW,KAAK,IAAI,IAAI,EAAE,SAAS,EAAE;AAE3C,SAAO;AAAA,IACN,WAAW;AAAA,IACX;AAAA,EACD;AACD;AAMO,SAAS,eACf,WACmB;AAEnB,QAAM,aACL,qBAAqB,cAAc,IAAI,WAAW,SAAS,IAAI;AAGhE,QAAM,eAAe,UAAU,UAAU;AAGzC,QAAM,cAAc,aAAa,WAAW;AAC5C,QAAM,cAAc,aAAa,WAAW;AAE5C,MAAI,CAAC,aAAa;AACjB,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACrD;AAEA,MAAI,CAAC,aAAa;AACjB,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACrD;AAGA,QAAM,SAAS,UAAU,WAAW;AACpC,QAAM,SAAS,UAAU,WAAW;AAEpC,SAAO;AAAA,IACN;AAAA,IACA;AAAA,EACD;AACD;","names":[]}

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@thyme-sh/sdk",
+	"version": "0.2.0",
+	"description": "SDK for authoring Web3 automation tasks",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsup",
+		"dev": "tsup --watch",
+		"test": "echo \"No tests yet\""
+	},
+	"keywords": [
+		"web3",
+		"automation",
+		"ethereum",
+		"tasks",
+		"thyme"
+	],
+	"author": "",
+	"license": "MIT",
+	"dependencies": {
+		"fflate": "^0.8.2",
+		"viem": "^2.21.54",
+		"zod": "^3.24.1"
+	},
+	"devDependencies": {
+		"tsup": "^8.3.5",
+		"typescript": "^5.7.2"
+	}
+}