@latticexyz/common 2.0.0-next.11 → 2.0.0-next.13

package/src/{resourceIdToHex.ts → resourceToHex.ts}

@@ -1,5 +1,5 @@
 import { Hex, stringToHex, concatHex } from "viem";
-import { ResourceId } from "./common";
+import { Resource } from "./common";
 import { ResourceType } from "./resourceTypes";
 
 /** @internal */
@@ -13,11 +13,11 @@ export const resourceTypeIds = {
   system: "sy",
 } as const satisfies Record<ResourceType, string>;
 
-export function resourceIdToHex(resourceId: ResourceId): Hex {
-  const typeId = resourceTypeIds[resourceId.type];
+export function resourceToHex(resource: Omit<Resource, "resourceId">): Hex {
+  const typeId = resourceTypeIds[resource.type];
   return concatHex([
     stringToHex(typeId, { size: 2 }),
-    stringToHex(resourceId.namespace.slice(0, 14), { size: 14 }),
-    stringToHex(resourceId.name.slice(0, 16), { size: 16 }),
+    stringToHex(resource.namespace.slice(0, 14), { size: 14 }),
+    stringToHex(resource.name.slice(0, 16), { size: 16 }),
   ]);
 }

package/src/sendTransaction.ts

@@ -0,0 +1,89 @@
+import {
+  Account,
+  CallParameters,
+  Chain,
+  Client,
+  SendTransactionParameters,
+  Transport,
+  WriteContractReturnType,
+} from "viem";
+import { call, sendTransaction as viem_sendTransaction } from "viem/actions";
+import pRetry from "p-retry";
+import { debug as parentDebug } from "./debug";
+import { getNonceManager } from "./getNonceManager";
+import { parseAccount } from "viem/accounts";
+
+const debug = parentDebug.extend("sendTransaction");
+
+// TODO: migrate away from this approach once we can hook into viem's nonce management: https://github.com/wagmi-dev/viem/discussions/1230
+
+export async function sendTransaction<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined
+>(
+  client: Client<Transport, TChain, TAccount>,
+  request: SendTransactionParameters<TChain, TAccount, TChainOverride>
+): Promise<WriteContractReturnType> {
+  const rawAccount = request.account ?? client.account;
+  if (!rawAccount) {
+    // TODO: replace with viem AccountNotFoundError once its exported
+    throw new Error("No account provided");
+  }
+  const account = parseAccount(rawAccount);
+
+  const nonceManager = await getNonceManager({
+    client,
+    address: account.address,
+    blockTag: "pending",
+  });
+
+  async function prepare(): Promise<SendTransactionParameters<TChain, TAccount, TChainOverride>> {
+    if (request.gas) {
+      debug("gas provided, skipping simulate", request.to);
+      return request;
+    }
+
+    debug("simulating tx to", request.to);
+    await call(client, {
+      ...request,
+      blockTag: "pending",
+      account,
+    } as CallParameters<TChain>);
+
+    // TODO: estimate gas
+
+    return request;
+  }
+
+  const preparedRequest = await prepare();
+
+  return await nonceManager.mempoolQueue.add(
+    () =>
+      pRetry(
+        async () => {
+          if (!nonceManager.hasNonce()) {
+            await nonceManager.resetNonce();
+          }
+
+          const nonce = nonceManager.nextNonce();
+          debug("sending tx with nonce", nonce, "to", preparedRequest.to);
+          return await viem_sendTransaction(client, { nonce, ...preparedRequest });
+        },
+        {
+          retries: 3,
+          onFailedAttempt: async (error) => {
+            // On nonce errors, reset the nonce and retry
+            if (nonceManager.shouldResetNonce(error)) {
+              debug("got nonce error, retrying", error.message);
+              await nonceManager.resetNonce();
+              return;
+            }
+            // TODO: prepare again if there are gas errors?
+            throw error;
+          },
+        }
+      ),
+    { throwOnTimeout: true }
+  );
+}

package/src/utils/index.ts

@@ -8,5 +8,7 @@ export * from "./identity";
 export * from "./isDefined";
 export * from "./isNotNull";
 export * from "./iteratorToArray";
+export * from "./mapObject";
+export * from "./uniqueBy";
 export * from "./wait";
 export * from "./waitForIdle";

package/src/utils/mapObject.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { mapObject } from "./mapObject";
+import { assertExhaustive } from "./assertExhaustive";
+
+describe("mapObject", () => {
+  it("should map the source to the target", () => {
+    const source = {
+      hello: "world",
+      foo: "bar",
+    } as const;
+
+    type Mapped<T extends Record<string, string>> = { [key in keyof T]: `mapped-${T[key]}` };
+
+    const target = mapObject<typeof source, Mapped<typeof source>>(source, (value, key) => {
+      if (key === "hello") return `mapped-${value}`;
+      if (key === "foo") return `mapped-${value}`;
+      assertExhaustive(key);
+    });
+
+    expect(target).toEqual({ hello: `mapped-world`, foo: `mapped-bar` });
+    expectTypeOf<typeof target>().toEqualTypeOf<Mapped<typeof source>>();
+  });
+});

package/src/utils/mapObject.ts

@@ -0,0 +1,11 @@
+/**
+ * Map each key of a source object via a given valueMap function
+ */
+export function mapObject<
+  Source extends Record<string | number | symbol, unknown>,
+  Target extends { [key in keyof Source]: unknown }
+>(source: Source, valueMap: (value: Source[typeof key], key: keyof Source) => Target[typeof key]): Target {
+  return Object.fromEntries(
+    Object.entries(source).map(([key, value]) => [key, valueMap(value as Source[keyof Source], key)])
+  ) as Target;
+}

package/src/utils/uniqueBy.ts

@@ -0,0 +1,7 @@
+export function uniqueBy<value, key>(values: readonly value[], getKey: (value: value) => key): readonly value[] {
+  const map = new Map<key, value>();
+  for (const value of values) {
+    map.set(getKey(value), value);
+  }
+  return Array.from(map.values());
+}

package/src/writeContract.ts

@@ -3,7 +3,6 @@ import {
   Account,
   Chain,
   Client,
-  Hex,
   SimulateContractParameters,
   Transport,
   WriteContractParameters,
@@ -16,29 +15,6 @@ import { getNonceManager } from "./getNonceManager";
 import { parseAccount } from "viem/accounts";
 
 const debug = parentDebug.extend("writeContract");
-let nextWriteId = 0;
-
-export type ContractWrite<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-  TChain extends Chain | undefined = Chain,
-  TAccount extends Account | undefined = Account | undefined,
-  TChainOverride extends Chain | undefined = Chain | undefined
-> = {
-  id: string;
-  request: WriteContractParameters<TAbi, TFunctionName, TChain, TAccount, TChainOverride>;
-  result: Promise<Hex>;
-};
-
-export type WriteContractOptions<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-  TChain extends Chain | undefined = Chain,
-  TAccount extends Account | undefined = Account | undefined,
-  TChainOverride extends Chain | undefined = Chain | undefined
-> = WriteContractParameters<TAbi, TFunctionName, TChain, TAccount, TChainOverride> & {
-  onWrite?: (write: ContractWrite<TAbi, TFunctionName, TChain, TAccount, TChainOverride>) => void;
-};
 
 // TODO: migrate away from this approach once we can hook into viem's nonce management: https://github.com/wagmi-dev/viem/discussions/1230
 
@@ -50,71 +26,67 @@ export async function writeContract<
   TChainOverride extends Chain | undefined
 >(
   client: Client<Transport, TChain, TAccount>,
-  { onWrite, ...request_ }: WriteContractOptions<TAbi, TFunctionName, TChain, TAccount, TChainOverride>
+  request: WriteContractParameters<TAbi, TFunctionName, TChain, TAccount, TChainOverride>
 ): Promise<WriteContractReturnType> {
-  const request = request_ as WriteContractParameters<TAbi, TFunctionName, TChain, TAccount, TChainOverride>;
-
-  const account_ = request.account ?? client.account;
-  if (!account_) {
+  const rawAccount = request.account ?? client.account;
+  if (!rawAccount) {
     // TODO: replace with viem AccountNotFoundError once its exported
     throw new Error("No account provided");
   }
-  const account = parseAccount(account_);
+  const account = parseAccount(rawAccount);
 
   const nonceManager = await getNonceManager({
     client,
     address: account.address,
+    blockTag: "pending",
   });
 
   async function prepareWrite(): Promise<
     WriteContractParameters<TAbi, TFunctionName, TChain, TAccount, TChainOverride>
   > {
     if (request.gas) {
-      debug("gas provided, skipping simulate", request);
+      debug("gas provided, skipping simulate", request.functionName, request.address);
       return request;
     }
 
-    debug("simulating write", request);
+    debug("simulating", request.functionName, "at", request.address);
     const result = await simulateContract<TChain, TAbi, TFunctionName, TChainOverride>(client, {
       ...request,
+      blockTag: "pending",
       account,
     } as unknown as SimulateContractParameters<TAbi, TFunctionName, TChain, TChainOverride>);
 
     return result.request as unknown as WriteContractParameters<TAbi, TFunctionName, TChain, TAccount, TChainOverride>;
   }
 
-  async function write(): Promise<Hex> {
-    const preparedWrite = await prepareWrite();
+  const preparedWrite = await prepareWrite();
 
-    return await pRetry(
-      async () => {
-        if (!nonceManager.hasNonce()) {
-          await nonceManager.resetNonce();
-        }
-
-        const nonce = nonceManager.nextNonce();
-        debug("calling write function with nonce", nonce, preparedWrite);
-        return await viem_writeContract(client, { nonce, ...preparedWrite } as typeof preparedWrite);
-      },
-      {
-        retries: 3,
-        onFailedAttempt: async (error) => {
-          // On nonce errors, reset the nonce and retry
-          if (nonceManager.shouldResetNonce(error)) {
-            debug("got nonce error, retrying", error);
+  return nonceManager.mempoolQueue.add(
+    () =>
+      pRetry(
+        async () => {
+          if (!nonceManager.hasNonce()) {
             await nonceManager.resetNonce();
-            return;
           }
-          // TODO: prepareWrite again if there are gas errors?
-          throw error;
-        },
-      }
-    );
-  }
-
-  const result = write();
-
-  onWrite?.({ id: `${nextWriteId++}`, request, result });
 
-  return result;
+          const nonce = nonceManager.nextNonce();
+          debug("calling", preparedWrite.functionName, "with nonce", nonce, "at", preparedWrite.address);
+          return await viem_writeContract(client, { nonce, ...preparedWrite } as typeof preparedWrite);
+        },
+        {
+          retries: 3,
+          onFailedAttempt: async (error) => {
+            // On nonce errors, reset the nonce and retry
+            if (nonceManager.shouldResetNonce(error)) {
+              debug("got nonce error, retrying", error.message);
+              await nonceManager.resetNonce();
+              return;
+            }
+            // TODO: prepareWrite again if there are gas errors?
+            throw error;
+          },
+        }
+      ),
+    { throwOnTimeout: true }
+  );
 }

package/dist/deprecated.js

@@ -1,2 +0,0 @@
-import{stringToHex as i,hexToString as m,sliceHex as o,concatHex as c}from"viem";var n=class{namespace;name;constructor(e,t){this.namespace=e.substring(0,16),this.name=t.substring(0,16)}toString(){return`TableId<${this.namespace||"[empty]"}:${this.name||"[empty]"}>`}toHex(){return n.toHex(this.namespace,this.name)}static toHex(e,t){return c([i(e.substring(0,16),{size:16}),i(t.substring(0,16),{size:16})])}static fromHex(e){let t=m(o(e,0,16)).replace(/\0+$/,""),s=m(o(e,16,32)).replace(/\0+$/,"");return new n(t,s)}static parse(e){let t=e.match(/^TableId<(.+?):(.+?)>$/);if(!t)return null;let[,s,a]=t;return new n(s==="[empty]"?"":s,a==="[empty]"?"":a)}};function x(r){return Object.keys(r.tables).map(e=>new n(r.namespace,e))}export{n as TableId,x as getTableIds};
-//# sourceMappingURL=deprecated.js.map

package/dist/deprecated.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/deprecated/TableId.ts","../src/deprecated/getTableIds.ts"],"sourcesContent":["import { Hex, stringToHex, hexToString, sliceHex, concatHex } from \"viem\";\n\n/** @deprecated Use `tableIdToHex` and `hexToTableId` instead. */\nexport class TableId {\n  readonly namespace: string;\n  readonly name: string;\n\n  constructor(namespace: string, name: string) {\n    this.namespace = namespace.substring(0, 16);\n    this.name = name.substring(0, 16);\n  }\n\n  toString(): string {\n    return `TableId<${this.namespace || \"[empty]\"}:${this.name || \"[empty]\"}>`;\n  }\n\n  toHex(): Hex {\n    return TableId.toHex(this.namespace, this.name);\n  }\n\n  static toHex(namespace: string, name: string): Hex {\n    return concatHex([\n      stringToHex(namespace.substring(0, 16), { size: 16 }),\n      stringToHex(name.substring(0, 16), { size: 16 }),\n    ]);\n  }\n\n  static fromHex(hex: Hex): TableId {\n    const namespace = hexToString(sliceHex(hex, 0, 16)).replace(/\\0+$/, \"\");\n    const name = hexToString(sliceHex(hex, 16, 32)).replace(/\\0+$/, \"\");\n    return new TableId(namespace, name);\n  }\n\n  /** @deprecated Don't use this! This is a temporary hack for v2<>v1 compatibility until we can write v2 client libraries. This is here so it stays close to the formatting of `toString()` above. */\n  static parse(tableIdString: string): TableId | null {\n    const match = tableIdString.match(/^TableId<(.+?):(.+?)>$/);\n    if (!match) return null;\n    const [, namespace, name] = match;\n    return new TableId(namespace === \"[empty]\" ? \"\" : namespace, name === \"[empty]\" ? \"\" : name);\n  }\n}\n","import { TableId } from \"./TableId\";\n\n/** @deprecated Use `tableIdToHex` and `hexToTableId` instead. */\nexport function getTableIds(config: { namespace: string; tables: { [key: string]: unknown } }): TableId[] {\n  return Object.keys(config.tables).map((table) => new TableId(config.namespace, table));\n}\n"],"mappings":"AAAA,OAAc,eAAAA,EAAa,eAAAC,EAAa,YAAAC,EAAU,aAAAC,MAAiB,OAG5D,IAAMC,EAAN,KAAc,CACV,UACA,KAET,YAAYC,EAAmBC,EAAc,CAC3C,KAAK,UAAYD,EAAU,UAAU,EAAG,EAAE,EAC1C,KAAK,KAAOC,EAAK,UAAU,EAAG,EAAE,CAClC,CAEA,UAAmB,CACjB,MAAO,WAAW,KAAK,WAAa,aAAa,KAAK,MAAQ,YAChE,CAEA,OAAa,CACX,OAAOF,EAAQ,MAAM,KAAK,UAAW,KAAK,IAAI,CAChD,CAEA,OAAO,MAAMC,EAAmBC,EAAmB,CACjD,OAAOH,EAAU,CACfH,EAAYK,EAAU,UAAU,EAAG,EAAE,EAAG,CAAE,KAAM,EAAG,CAAC,EACpDL,EAAYM,EAAK,UAAU,EAAG,EAAE,EAAG,CAAE,KAAM,EAAG,CAAC,CACjD,CAAC,CACH,CAEA,OAAO,QAAQC,EAAmB,CAChC,IAAMF,EAAYJ,EAAYC,EAASK,EAAK,EAAG,EAAE,CAAC,EAAE,QAAQ,OAAQ,EAAE,EAChED,EAAOL,EAAYC,EAASK,EAAK,GAAI,EAAE,CAAC,EAAE,QAAQ,OAAQ,EAAE,EAClE,OAAO,IAAIH,EAAQC,EAAWC,CAAI,CACpC,CAGA,OAAO,MAAME,EAAuC,CAClD,IAAMC,EAAQD,EAAc,MAAM,wBAAwB,EAC1D,GAAI,CAACC,EAAO,OAAO,KACnB,GAAM,CAAC,CAAEJ,EAAWC,CAAI,EAAIG,EAC5B,OAAO,IAAIL,EAAQC,IAAc,UAAY,GAAKA,EAAWC,IAAS,UAAY,GAAKA,CAAI,CAC7F,CACF,ECrCO,SAASI,EAAYC,EAA8E,CACxG,OAAO,OAAO,KAAKA,EAAO,MAAM,EAAE,IAAKC,GAAU,IAAIC,EAAQF,EAAO,UAAWC,CAAK,CAAC,CACvF","names":["stringToHex","hexToString","sliceHex","concatHex","TableId","namespace","name","hex","tableIdString","match","getTableIds","config","table","TableId"]}

package/src/deprecated/TableId.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { TableId } from "./TableId";
-
-describe("TableId", () => {
-  it("can convert to hex string", () => {
-    const tableId = new TableId("namespace", "name");
-    expect(tableId.toHex()).toMatchInlineSnapshot(
-      '"0x6e616d657370616365000000000000006e616d65000000000000000000000000"'
-    );
-  });
-
-  it("can convert from hex string", () => {
-    const tableId = TableId.fromHex("0x6e616d657370616365000000000000006e616d65000000000000000000000000");
-    expect(tableId.namespace).toMatchInlineSnapshot('"namespace"');
-    expect(tableId.name).toMatchInlineSnapshot('"name"');
-  });
-
-  it("truncates namespaces >16 bytes", () => {
-    const hex = "0x41566572794c6f6e674e616d657370616e616d65000000000000000000000000";
-    expect(TableId.toHex("AVeryLongNamespace", "name")).toEqual(hex);
-    const tableId = new TableId("AVeryLongNamespace", "name");
-    expect(tableId.toHex()).toEqual(hex);
-    expect(TableId.fromHex(tableId.toHex()).namespace).toMatchInlineSnapshot('"AVeryLongNamespa"');
-  });
-
-  it("truncates names >16 bytes", () => {
-    const hex = "0x6e616d65737061636500000000000000416e556e6e65636573736172696c794c";
-    expect(TableId.toHex("namespace", "AnUnnecessarilyLongName")).toEqual(hex);
-    const tableId = new TableId("namespace", "AnUnnecessarilyLongName");
-    expect(tableId.toHex()).toEqual(hex);
-    expect(TableId.fromHex(tableId.toHex()).name).toMatchInlineSnapshot('"AnUnnecessarilyL"');
-  });
-});

package/src/deprecated/TableId.ts

@@ -1,41 +0,0 @@
-import { Hex, stringToHex, hexToString, sliceHex, concatHex } from "viem";
-
-/** @deprecated Use `tableIdToHex` and `hexToTableId` instead. */
-export class TableId {
-  readonly namespace: string;
-  readonly name: string;
-
-  constructor(namespace: string, name: string) {
-    this.namespace = namespace.substring(0, 16);
-    this.name = name.substring(0, 16);
-  }
-
-  toString(): string {
-    return `TableId<${this.namespace || "[empty]"}:${this.name || "[empty]"}>`;
-  }
-
-  toHex(): Hex {
-    return TableId.toHex(this.namespace, this.name);
-  }
-
-  static toHex(namespace: string, name: string): Hex {
-    return concatHex([
-      stringToHex(namespace.substring(0, 16), { size: 16 }),
-      stringToHex(name.substring(0, 16), { size: 16 }),
-    ]);
-  }
-
-  static fromHex(hex: Hex): TableId {
-    const namespace = hexToString(sliceHex(hex, 0, 16)).replace(/\0+$/, "");
-    const name = hexToString(sliceHex(hex, 16, 32)).replace(/\0+$/, "");
-    return new TableId(namespace, name);
-  }
-
-  /** @deprecated Don't use this! This is a temporary hack for v2<>v1 compatibility until we can write v2 client libraries. This is here so it stays close to the formatting of `toString()` above. */
-  static parse(tableIdString: string): TableId | null {
-    const match = tableIdString.match(/^TableId<(.+?):(.+?)>$/);
-    if (!match) return null;
-    const [, namespace, name] = match;
-    return new TableId(namespace === "[empty]" ? "" : namespace, name === "[empty]" ? "" : name);
-  }
-}

package/src/deprecated/getTableIds.ts

@@ -1,6 +0,0 @@
-import { TableId } from "./TableId";
-
-/** @deprecated Use `tableIdToHex` and `hexToTableId` instead. */
-export function getTableIds(config: { namespace: string; tables: { [key: string]: unknown } }): TableId[] {
-  return Object.keys(config.tables).map((table) => new TableId(config.namespace, table));
-}

package/src/deprecated/index.ts

@@ -1,2 +0,0 @@
-export * from "./getTableIds";
-export * from "./TableId";

package/src/hexToResourceId.test.ts

@@ -1,11 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { hexToResourceId } from "./hexToResourceId";
-
-describe("hexToResourceId", () => {
-  it("can convert from hex string", () => {
-    const resourceId = hexToResourceId("0x74626e616d65737061636500000000006e616d65000000000000000000000000");
-    expect(resourceId.type).toMatchInlineSnapshot('"table"');
-    expect(resourceId.namespace).toMatchInlineSnapshot('"namespace"');
-    expect(resourceId.name).toMatchInlineSnapshot('"name"');
-  });
-});