@ubi.fun/sdk 0.1.0

package/dist/clients/TreasuryManagerFactoryClient.d.cts

@@ -0,0 +1,15 @@
+import { type ReadContract, type Address, type Drift, type ReadWriteContract, type HexString } from "@delvtech/drift";
+import { type PublicClient } from "viem";
+import { TreasuryManagerFactoryAbi } from "../abi/TreasuryManagerFactory.cjs";
+export type TreasuryManagerFactoryABI = typeof TreasuryManagerFactoryAbi;
+export declare class ReadTreasuryManagerFactory {
+    chainId: number;
+    readonly contract: ReadContract<TreasuryManagerFactoryABI>;
+    readonly publicClient: PublicClient | undefined;
+    constructor(chainId: number, address: Address, drift?: Drift, publicClient?: PublicClient);
+    getManagerDeployedAddressFromTx(hash: HexString): Promise<`0x${string}`>;
+}
+export declare class ReadWriteTreasuryManagerFactory extends ReadTreasuryManagerFactory {
+    contract: ReadWriteContract<TreasuryManagerFactoryABI>;
+    constructor(chainId: number, address: Address, drift?: Drift, publicClient?: PublicClient);
+}

package/dist/clients/TreasuryManagerFactoryClient.d.ts

@@ -0,0 +1,16 @@
+import { type ReadContract, type Address, type Drift, type ReadWriteContract, type HexString } from "@delvtech/drift";
+import { type PublicClient } from "viem";
+import { TreasuryManagerFactoryAbi } from "../abi/TreasuryManagerFactory.js";
+export type TreasuryManagerFactoryABI = typeof TreasuryManagerFactoryAbi;
+export declare class ReadTreasuryManagerFactory {
+    chainId: number;
+    readonly contract: ReadContract<TreasuryManagerFactoryABI>;
+    readonly publicClient: PublicClient | undefined;
+    constructor(chainId: number, address: Address, drift?: Drift, publicClient?: PublicClient);
+    getManagerDeployedAddressFromTx(hash: HexString): Promise<`0x${string}`>;
+}
+export declare class ReadWriteTreasuryManagerFactory extends ReadTreasuryManagerFactory {
+    contract: ReadWriteContract<TreasuryManagerFactoryABI>;
+    constructor(chainId: number, address: Address, drift?: Drift, publicClient?: PublicClient);
+}
+//# sourceMappingURL=TreasuryManagerFactoryClient.d.ts.map

package/dist/clients/TreasuryManagerFactoryClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreasuryManagerFactoryClient.d.ts","sourceRoot":"","sources":["../../src/clients/TreasuryManagerFactoryClient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,KAAK,EAEV,KAAK,iBAAiB,EAEtB,KAAK,SAAS,EAEf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAEL,KAAK,YAAY,EAIlB,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAG1E,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC;AAEzE,qBAAa,0BAA0B;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAgB,QAAQ,EAAE,YAAY,CAAC,yBAAyB,CAAC,CAAC;IAClE,SAAgB,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;gBAGrD,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,KAAK,GAAE,KAAqB,EAC5B,YAAY,CAAC,EAAE,YAAY;IAavB,+BAA+B,CAAC,IAAI,EAAE,SAAS;CAyBtD;AAED,qBAAa,+BAAgC,SAAQ,0BAA0B;IACrE,QAAQ,EAAE,iBAAiB,CAAC,yBAAyB,CAAC,CAAC;gBAG7D,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,KAAK,GAAE,KAAqB,EAC5B,YAAY,CAAC,EAAE,YAAY;CAI9B"}

package/dist/clients/UniversalRewardsDistributorClient.d.cts

@@ -0,0 +1,45 @@
+import { type ReadContract, type ReadWriteContract, type ReadWriteAdapter, type Address, type Drift } from "@delvtech/drift";
+import { type Hex } from "viem";
+import { UniversalRewardsDistributorAbi } from "../abi/UniversalRewardsDistributor.cjs";
+export type UniversalRewardsDistributorABI = typeof UniversalRewardsDistributorAbi;
+/**
+ * Client for Morpho's UniversalRewardsDistributor, which pays the daily USDC
+ * holder pool (24% of every swap fee). Entitlements are cumulative amounts in
+ * a Merkle root the keeper submits after each daily epoch; a root becomes
+ * claimable after the on-chain timelock. Fetch an address's cumulative amount
+ * and proof from the ubi.fun API (GET {apiUrl}/ubi/:address), then `claim`
+ * pays out the difference between the cumulative amount and what was already
+ * claimed.
+ */
+export declare class ReadUniversalRewardsDistributor {
+    readonly contract: ReadContract<UniversalRewardsDistributorABI>;
+    constructor(address: Address, drift?: Drift);
+    /** The active Merkle root claims are verified against. */
+    root(): Promise<`0x${string}`>;
+    /** A submitted root still inside the timelock, if any. */
+    pendingRoot(): Promise<{
+        ipfsHash: `0x${string}`;
+        root: `0x${string}`;
+        validAt: bigint;
+    }>;
+    /** The cumulative amount `account` has already claimed of `reward`. */
+    claimed(account: Address, reward: Address): Promise<bigint>;
+}
+export declare class ReadWriteUniversalRewardsDistributor extends ReadUniversalRewardsDistributor {
+    contract: ReadWriteContract<UniversalRewardsDistributorABI>;
+    constructor(address: Address, drift?: Drift<ReadWriteAdapter>);
+    /**
+     * Claims the outstanding balance for an account. Anyone can submit; the
+     * payout always goes to `account`.
+     * @param params.account - The holder being claimed for
+     * @param params.reward - The reward token (USDC on Arc)
+     * @param params.claimable - The CUMULATIVE entitlement from the API ledger
+     * @param params.proof - The Merkle proof from the API ledger
+     */
+    claim(params: {
+        account: Address;
+        reward: Address;
+        claimable: bigint;
+        proof: Hex[];
+    }): Promise<`0x${string}`>;
+}

package/dist/clients/UniversalRewardsDistributorClient.d.ts

@@ -0,0 +1,46 @@
+import { type ReadContract, type ReadWriteContract, type ReadWriteAdapter, type Address, type Drift } from "@delvtech/drift";
+import { type Hex } from "viem";
+import { UniversalRewardsDistributorAbi } from "../abi/UniversalRewardsDistributor.js";
+export type UniversalRewardsDistributorABI = typeof UniversalRewardsDistributorAbi;
+/**
+ * Client for Morpho's UniversalRewardsDistributor, which pays the daily USDC
+ * holder pool (24% of every swap fee). Entitlements are cumulative amounts in
+ * a Merkle root the keeper submits after each daily epoch; a root becomes
+ * claimable after the on-chain timelock. Fetch an address's cumulative amount
+ * and proof from the ubi.fun API (GET {apiUrl}/ubi/:address), then `claim`
+ * pays out the difference between the cumulative amount and what was already
+ * claimed.
+ */
+export declare class ReadUniversalRewardsDistributor {
+    readonly contract: ReadContract<UniversalRewardsDistributorABI>;
+    constructor(address: Address, drift?: Drift);
+    /** The active Merkle root claims are verified against. */
+    root(): Promise<`0x${string}`>;
+    /** A submitted root still inside the timelock, if any. */
+    pendingRoot(): Promise<{
+        ipfsHash: `0x${string}`;
+        root: `0x${string}`;
+        validAt: bigint;
+    }>;
+    /** The cumulative amount `account` has already claimed of `reward`. */
+    claimed(account: Address, reward: Address): Promise<bigint>;
+}
+export declare class ReadWriteUniversalRewardsDistributor extends ReadUniversalRewardsDistributor {
+    contract: ReadWriteContract<UniversalRewardsDistributorABI>;
+    constructor(address: Address, drift?: Drift<ReadWriteAdapter>);
+    /**
+     * Claims the outstanding balance for an account. Anyone can submit; the
+     * payout always goes to `account`.
+     * @param params.account - The holder being claimed for
+     * @param params.reward - The reward token (USDC on Arc)
+     * @param params.claimable - The CUMULATIVE entitlement from the API ledger
+     * @param params.proof - The Merkle proof from the API ledger
+     */
+    claim(params: {
+        account: Address;
+        reward: Address;
+        claimable: bigint;
+        proof: Hex[];
+    }): Promise<`0x${string}`>;
+}
+//# sourceMappingURL=UniversalRewardsDistributorClient.d.ts.map

package/dist/clients/UniversalRewardsDistributorClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniversalRewardsDistributorClient.d.ts","sourceRoot":"","sources":["../../src/clients/UniversalRewardsDistributorClient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,OAAO,EACZ,KAAK,KAAK,EAEX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAChC,OAAO,EAAE,8BAA8B,EAAE,MAAM,oCAAoC,CAAC;AAEpF,MAAM,MAAM,8BAA8B,GACxC,OAAO,8BAA8B,CAAC;AAExC;;;;;;;;GAQG;AACH,qBAAa,+BAA+B;IAC1C,SAAgB,QAAQ,EAAE,YAAY,CAAC,8BAA8B,CAAC,CAAC;gBAE3D,OAAO,EAAE,OAAO,EAAE,KAAK,GAAE,KAAqB;IAW1D,0DAA0D;IAC1D,IAAI;IAIJ,0DAA0D;IAC1D,WAAW;;;;;IAIX,uEAAuE;IACvE,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO;CAM1C;AAED,qBAAa,oCAAqC,SAAQ,+BAA+B;IAC/E,QAAQ,EAAE,iBAAiB,CAAC,8BAA8B,CAAC,CAAC;gBAGlE,OAAO,EAAE,OAAO,EAChB,KAAK,GAAE,KAAK,CAAC,gBAAgB,CAAiB;IAKhD;;;;;;;OAOG;IACH,KAAK,CAAC,MAAM,EAAE;QACZ,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,OAAO,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,GAAG,EAAE,CAAC;KACd;CAQF"}

package/dist/clients/XHandleClaimsClient.d.cts

@@ -0,0 +1,64 @@
+import { type ReadContract, type ReadWriteContract, type ReadWriteAdapter, type Address, type Drift } from "@delvtech/drift";
+import { type Hex } from "viem";
+import { XHandleClaimsAbi } from "../abi/XHandleClaims.cjs";
+export type XHandleClaimsABI = typeof XHandleClaimsAbi;
+/** Allowed X handle shape, with or without the leading @. */
+export declare const HANDLE_RE: RegExp;
+/** Lowercase, no leading @. The canonical form links and hashes use. */
+export declare function normalizeHandle(handle: string): string;
+/**
+ * keccak256 of the normalized handle: the on-chain key of the XHandleClaims
+ * registry. Must match the app and backend (it does; same normalization).
+ * Throws on anything outside HANDLE_RE: the OAuth backend only attests real X
+ * usernames, so an escrow derived from an invalid handle could never be bound
+ * and any revenue routed to it would be stuck forever.
+ */
+export declare function handleHashOf(handle: string): Hex;
+/**
+ * Client for the XHandleClaims registry: launches can route earnings-split
+ * shares to an X handle instead of an address. Each handle maps to a
+ * deterministic CREATE2 escrow (predictable before deployment, so it can be a
+ * split recipient at launch). The handle's owner proves control through the
+ * ubi.fun X OAuth flow, which returns an attestation signature for `bind`;
+ * after binding, `claim` pulls the escrowed USDC to the bound wallet.
+ */
+export declare class ReadXHandleClaims {
+    readonly contract: ReadContract<XHandleClaimsABI>;
+    constructor(address: Address, drift?: Drift);
+    /**
+     * The deterministic escrow address for a handle, valid before the escrow is
+     * deployed. Use this as a split recipient at launch time.
+     */
+    escrowAddress(handle: string): Promise<`0x${string}`>;
+    /** The wallet a handle is bound to (zero address if unbound). */
+    boundWallet(handle: string): Promise<`0x${string}`>;
+    /** The current bind nonce for a handle (increments on each re-bind). */
+    bindNonce(handle: string): Promise<bigint>;
+}
+export declare class ReadWriteXHandleClaims extends ReadXHandleClaims {
+    contract: ReadWriteContract<XHandleClaimsABI>;
+    constructor(address: Address, drift?: Drift<ReadWriteAdapter>);
+    /**
+     * Binds a handle to a wallet using the attestation from the ubi.fun X OAuth
+     * flow (GET /auth/x/start on the API starts it; the callback returns this
+     * signature). Anyone can submit the bind once signed.
+     */
+    bind(params: {
+        handle: string;
+        wallet: Address;
+        deadline: bigint;
+        signature: Hex;
+    }): Promise<`0x${string}`>;
+    /**
+     * Claims a bound handle's share out of a launch's split manager and forwards
+     * it to the bound wallet as USDC.
+     * @param handle - The X handle
+     * @param manager - The AddressFeeSplitManager instance holding the share
+     */
+    claim(handle: string, manager: Address): Promise<`0x${string}`>;
+    /**
+     * Sweeps a token balance sitting directly on the handle's escrow (e.g. USDC
+     * sent to it outside a split manager) to the bound wallet.
+     */
+    sweep(handle: string, token: Address): Promise<`0x${string}`>;
+}

package/dist/clients/XHandleClaimsClient.d.ts

@@ -0,0 +1,65 @@
+import { type ReadContract, type ReadWriteContract, type ReadWriteAdapter, type Address, type Drift } from "@delvtech/drift";
+import { type Hex } from "viem";
+import { XHandleClaimsAbi } from "../abi/XHandleClaims.js";
+export type XHandleClaimsABI = typeof XHandleClaimsAbi;
+/** Allowed X handle shape, with or without the leading @. */
+export declare const HANDLE_RE: RegExp;
+/** Lowercase, no leading @. The canonical form links and hashes use. */
+export declare function normalizeHandle(handle: string): string;
+/**
+ * keccak256 of the normalized handle: the on-chain key of the XHandleClaims
+ * registry. Must match the app and backend (it does; same normalization).
+ * Throws on anything outside HANDLE_RE: the OAuth backend only attests real X
+ * usernames, so an escrow derived from an invalid handle could never be bound
+ * and any revenue routed to it would be stuck forever.
+ */
+export declare function handleHashOf(handle: string): Hex;
+/**
+ * Client for the XHandleClaims registry: launches can route earnings-split
+ * shares to an X handle instead of an address. Each handle maps to a
+ * deterministic CREATE2 escrow (predictable before deployment, so it can be a
+ * split recipient at launch). The handle's owner proves control through the
+ * ubi.fun X OAuth flow, which returns an attestation signature for `bind`;
+ * after binding, `claim` pulls the escrowed USDC to the bound wallet.
+ */
+export declare class ReadXHandleClaims {
+    readonly contract: ReadContract<XHandleClaimsABI>;
+    constructor(address: Address, drift?: Drift);
+    /**
+     * The deterministic escrow address for a handle, valid before the escrow is
+     * deployed. Use this as a split recipient at launch time.
+     */
+    escrowAddress(handle: string): Promise<`0x${string}`>;
+    /** The wallet a handle is bound to (zero address if unbound). */
+    boundWallet(handle: string): Promise<`0x${string}`>;
+    /** The current bind nonce for a handle (increments on each re-bind). */
+    bindNonce(handle: string): Promise<bigint>;
+}
+export declare class ReadWriteXHandleClaims extends ReadXHandleClaims {
+    contract: ReadWriteContract<XHandleClaimsABI>;
+    constructor(address: Address, drift?: Drift<ReadWriteAdapter>);
+    /**
+     * Binds a handle to a wallet using the attestation from the ubi.fun X OAuth
+     * flow (GET /auth/x/start on the API starts it; the callback returns this
+     * signature). Anyone can submit the bind once signed.
+     */
+    bind(params: {
+        handle: string;
+        wallet: Address;
+        deadline: bigint;
+        signature: Hex;
+    }): Promise<`0x${string}`>;
+    /**
+     * Claims a bound handle's share out of a launch's split manager and forwards
+     * it to the bound wallet as USDC.
+     * @param handle - The X handle
+     * @param manager - The AddressFeeSplitManager instance holding the share
+     */
+    claim(handle: string, manager: Address): Promise<`0x${string}`>;
+    /**
+     * Sweeps a token balance sitting directly on the handle's escrow (e.g. USDC
+     * sent to it outside a split manager) to the bound wallet.
+     */
+    sweep(handle: string, token: Address): Promise<`0x${string}`>;
+}
+//# sourceMappingURL=XHandleClaimsClient.d.ts.map

package/dist/clients/XHandleClaimsClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XHandleClaimsClient.d.ts","sourceRoot":"","sources":["../../src/clients/XHandleClaimsClient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,OAAO,EACZ,KAAK,KAAK,EAEX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAA4B,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AAEvD,6DAA6D;AAC7D,eAAO,MAAM,SAAS,QAA2B,CAAC;AAElD,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAShD;AAED;;;;;;;GAOG;AACH,qBAAa,iBAAiB;IAC5B,SAAgB,QAAQ,EAAE,YAAY,CAAC,gBAAgB,CAAC,CAAC;gBAE7C,OAAO,EAAE,OAAO,EAAE,KAAK,GAAE,KAAqB;IAW1D;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM;IAM5B,iEAAiE;IACjE,WAAW,CAAC,MAAM,EAAE,MAAM;IAM1B,wEAAwE;IACxE,SAAS,CAAC,MAAM,EAAE,MAAM;CAKzB;AAED,qBAAa,sBAAuB,SAAQ,iBAAiB;IACnD,QAAQ,EAAE,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;gBAGpD,OAAO,EAAE,OAAO,EAChB,KAAK,GAAE,KAAK,CAAC,gBAAgB,CAAiB;IAKhD;;;;OAIG;IACH,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,OAAO,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,GAAG,CAAC;KAChB;IASD;;;;;OAKG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAOtC;;;OAGG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;CAMrC"}

package/dist/helpers/chainIdToChain.d.cts

@@ -0,0 +1,113 @@
+import { Chain } from "viem";
+/**
+ * Arc (Circle) chain definitions for viem. Gas is paid in USDC: msg.value is
+ * 18-decimal native USDC while the ERC20 interface at 0x3600... is the same
+ * asset at 6 decimals.
+ *
+ * Arc mainnet is in its private phase: provider endpoints (including this
+ * default) reject public traffic until Circle opens access, so pass your own
+ * transport url. Once the network opens, public RPCs will be plentiful.
+ */
+export declare const arc: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Arc Explorer";
+            readonly url: "https://explorer.arc.io";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 5042;
+    name: "Arc";
+    nativeCurrency: {
+        readonly name: "USD Coin";
+        readonly symbol: "USDC";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.blockdaemon.mainnet.arc.io"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+export declare const arcTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Arcscan";
+            readonly url: "https://testnet.arcscan.app";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 5042002;
+    name: "Arc Testnet";
+    nativeCurrency: {
+        readonly name: "USD Coin";
+        readonly symbol: "USDC";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://arc-testnet.drpc.org", "https://rpc.testnet.arc.network"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+export declare const chainIdToChain: {
+    [key: number]: Chain;
+};

package/dist/helpers/chainIdToChain.d.ts

@@ -0,0 +1,114 @@
+import { Chain } from "viem";
+/**
+ * Arc (Circle) chain definitions for viem. Gas is paid in USDC: msg.value is
+ * 18-decimal native USDC while the ERC20 interface at 0x3600... is the same
+ * asset at 6 decimals.
+ *
+ * Arc mainnet is in its private phase: provider endpoints (including this
+ * default) reject public traffic until Circle opens access, so pass your own
+ * transport url. Once the network opens, public RPCs will be plentiful.
+ */
+export declare const arc: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Arc Explorer";
+            readonly url: "https://explorer.arc.io";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 5042;
+    name: "Arc";
+    nativeCurrency: {
+        readonly name: "USD Coin";
+        readonly symbol: "USDC";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.blockdaemon.mainnet.arc.io"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+export declare const arcTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Arcscan";
+            readonly url: "https://testnet.arcscan.app";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 5042002;
+    name: "Arc Testnet";
+    nativeCurrency: {
+        readonly name: "USD Coin";
+        readonly symbol: "USDC";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://arc-testnet.drpc.org", "https://rpc.testnet.arc.network"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+export declare const chainIdToChain: {
+    [key: number]: Chain;
+};
+//# sourceMappingURL=chainIdToChain.d.ts.map

package/dist/helpers/chainIdToChain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chainIdToChain.d.ts","sourceRoot":"","sources":["../../src/helpers/chainIdToChain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAe,MAAM,MAAM,CAAC;AAG1C;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBd,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBrB,CAAC;AAEH,eAAO,MAAM,cAAc,EAAE;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC;CAItB,CAAC"}

package/dist/helpers/hex.d.cts

@@ -0,0 +1,3 @@
+import { Hex } from "viem";
+export declare const bytes32ToUint256: (value: Hex) => bigint;
+export declare const uint256ToBytes32: (value: bigint) => `0x${string}`;

package/dist/helpers/hex.d.ts

@@ -0,0 +1,4 @@
+import { Hex } from "viem";
+export declare const bytes32ToUint256: (value: Hex) => bigint;
+export declare const uint256ToBytes32: (value: bigint) => `0x${string}`;
+//# sourceMappingURL=hex.d.ts.map

package/dist/helpers/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../src/helpers/hex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,GAAG,EAAoB,MAAM,MAAM,CAAC;AAElE,eAAO,MAAM,gBAAgB,GAAI,OAAO,GAAG,WAE1C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,kBAK7C,CAAC"}