npm - @evergonlabs/tmi-protocol-api - Versions diffs - 0.1.5 → 0.2.1 - Mend

@evergonlabs/tmi-protocol-api 0.1.5 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (68) hide show

package/dist/app.d.ts CHANGED Viewed

@@ -2498,6 +2498,62 @@ export declare function getApp(factory: Factory): import("hono/hono-base").HonoB
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
+} & {
+    "/proxy/deployTransparentProxy": {
+        $post: {
+            input: {
+                json: {
+                    implementation: `0x${string}`;
+                    proxyAdmin: `0x${string}`;
+                    data?: `0x${string}` | undefined;
+                };
+            };
+            output: {
+                abi: any[];
+                args: any[];
+                bytecode: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/proxy/deployProxyAdmin": {
+        $get: {
+            input: {};
+            output: {
+                abi: any[];
+                bytecode: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/proxy/upgradeTransparentProxy": {
+        $post: {
+            input: {
+                json: {
+                    newImplementation: `0x${string}`;
+                    proxyAdminAddress: `0x${string}`;
+                    proxyAddress: `0x${string}`;
+                    data?: `0x${string}` | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
 }, "/issuance">, "/">, "/">;
 export type IApp = ReturnType<typeof getApp>;
 export declare const appConfig: {

package/dist/app.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;~~AAUvC~~,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAUtC;AAED,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC;AAE7C,eAAO,MAAM,SAAS;;;CAGpB,CAAC"}
1	+ {"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAWvC,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAWtC;AAED,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC;AAE7C,eAAO,MAAM,SAAS;;;CAGpB,CAAC"}

package/dist/app.js CHANGED Viewed

@@ -1,4 +1,5 @@
 import { cors } from "hono/cors";
+import { logger } from "hono/logger";
 import { stakingApi } from "./staking/index.js";
 import { stakingTemplatesApi } from "./staking-templates/index.js";
 import { createErrorHandler } from "./error.js";
@@ -10,6 +11,7 @@ export function getApp(factory) {
     return factory
         .createApp()
         .use("/*", cors())
+        .use("/*", logger())
         .route("/", stakingApi.createApp(factory))
         .route("/", stakingTemplatesApi.createApp(factory))
         .route("/", fractionsApi.createApp(factory))

package/dist/client.d.ts CHANGED Viewed

@@ -3046,6 +3046,74 @@ export declare function createClient(...args: Parameters<typeof hc>): {
             }>;
         };
     };
+} & {
+    issuance: {
+        proxy: {
+            deployTransparentProxy: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            implementation: `0x${string}`;
+                            proxyAdmin: `0x${string}`;
+                            data?: `0x${string}` | undefined;
+                        };
+                    };
+                    output: {
+                        abi: any[];
+                        args: any[];
+                        bytecode: `0x${string}`;
+                    };
+                    outputFormat: "json";
+                    status: import("hono/utils/http-status").ContentfulStatusCode;
+                };
+            }>;
+        };
+    };
+} & {
+    issuance: {
+        proxy: {
+            deployProxyAdmin: import("hono/client").ClientRequest<{
+                $get: {
+                    input: {};
+                    output: {
+                        abi: any[];
+                        bytecode: `0x${string}`;
+                    };
+                    outputFormat: "json";
+                    status: import("hono/utils/http-status").ContentfulStatusCode;
+                };
+            }>;
+        };
+    };
+} & {
+    issuance: {
+        proxy: {
+            upgradeTransparentProxy: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            newImplementation: `0x${string}`;
+                            proxyAdminAddress: `0x${string}`;
+                            proxyAddress: `0x${string}`;
+                            data?: `0x${string}` | undefined;
+                        };
+                    };
+                    output: {
+                        data: `0x${string}`;
+                        to: `0x${string}`;
+                        details: {
+                            functionName: string;
+                            address: `0x${string}`;
+                            abi: any[];
+                            args: any[];
+                        };
+                    };
+                    outputFormat: "json";
+                    status: import("hono/utils/http-status").ContentfulStatusCode;
+                };
+            }>;
+        };
+    };
 };
 export type IApi = ReturnType<typeof createClient>;
 export type { InferRequestType, InferResponseType } from "hono/client";

package/dist/client.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAGjC,wBAAgB,YAAY,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE1D;AAED,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AACnD,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACvE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAGjC,wBAAgB,YAAY,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE1D;AAED,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AACnD,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACvE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}

package/dist/fractions/deployMarket/v0/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export * from "./deployMarket.routes.js";
+export * from "./initNid.route.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/fractions/deployMarket/v0/index.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/fractions/deployMarket/v0/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC"}

package/dist/fractions/deployMarket/v0/index.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from "./deployMarket.routes.js";
2	+ export * from "./initNid.route.js";

package/dist/fractions/sales/searchActivity.route.js CHANGED Viewed

@@ -1,6 +1,6 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
-import { and, desc, eq } from "@ponder/client";
+import { and, eq } from "@ponder/client";
 import { z } from "../../common/zod.js";
 import { indexerClient } from "../../common/indexer/index.js";
 import { indexerSchemas } from "../../common/indexer/schemas.js";
@@ -50,7 +50,7 @@ export function createSearchActivityV0App(factory) {
             where: and(filter.chainId ? eq(fractionsSaleActivity.chainId, Number(filter.chainId)) : undefined, filter.platform ? eq(fractionsSaleActivity.diamondAddress, filter.platform) : undefined, typeof filter.campaignId === "bigint" ? eq(fractionsSaleActivity.saleId, filter.campaignId) : undefined),
             limit: page.limit,
             offset: page.skip,
-            orderBy: desc(fractionsSaleActivity.createdAt),
+            orderBy: fractionsSaleActivity.createdAt,
         });
         return c.json(result.map((i) => FractionsSaleActivitySchema.parse({
             chainId: i.chainId,

package/dist/fractions/sales/searchSaleEvents/v0/searchSaleEvents.js CHANGED Viewed

@@ -59,23 +59,23 @@ export function createSearchSaleEventsV0App(factory) {
         const { page, filter } = c.req.valid("json");
         const result = await indexerClient.db
             .select()
-            .from(indexerSchemas.fractions.fractionsSales)
+            .from(indexerSchemas.fractions.fractionEvents)
             .limit(page.limit)
             .offset(page.skip)
-            .orderBy(indexerSchemas.fractions.fractionsSales.createdAt)
-            .where(and(filter.chainId ? eq(indexerSchemas.fractions.fractionsSales.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.fractions.fractionsSales.creator, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.fractions.fractionsSales.diamondAddress, filter.platform) : undefined, typeof filter.campaignId === "number"
-            ? eq(indexerSchemas.fractions.fractionsSales.saleId, BigInt(filter.campaignId))
+            .orderBy(indexerSchemas.fractions.fractionEvents.createdAt)
+            .where(and(filter.chainId ? eq(indexerSchemas.fractions.fractionEvents.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.fractions.fractionEvents.walletAddress, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.fractions.fractionEvents.diamondAddress, filter.platform) : undefined, typeof filter.campaignId === "number"
+            ? eq(indexerSchemas.fractions.fractionEvents.saleId, BigInt(filter.campaignId))
             : undefined));
         return c.json(result.map((x) => toSaleEvent(x)), 200);
     });
 }
 function toSaleEvent(raw) {
     return {
-        id: "0",
+        id: raw.id,
         txHash: raw.txHash,
         chainId: TmiChainIdSchema.parse(raw.chainId),
         platform: raw.diamondAddress,
-        owner: raw.creator,
+        owner: raw.walletAddress,
         campaignId: raw.saleId ? PoolIdSchema.parse(raw.saleId) : undefined,
         createdAt: unixToDate(raw.createdAt).toISOString(),
     };

package/dist/issuance/deploy.d.ts CHANGED Viewed

@@ -85,4 +85,67 @@ export declare function createErc1967Proxy<E extends Env>(factory: Factory<E>):
     args: any[];
     bytecode: `0x${string}`;
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+export declare const DeployTransparentProxySchema: z.ZodObject<{
+    implementation: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    proxyAdmin: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    data: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+}, "strip", z.ZodTypeAny, {
+    implementation: `0x${string}`;
+    proxyAdmin: `0x${string}`;
+    data?: `0x${string}` | undefined;
+}, {
+    implementation: `0x${string}`;
+    proxyAdmin: `0x${string}`;
+    data?: `0x${string}` | undefined;
+}>;
+export declare function createTransparentProxy<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    args: any[];
+    bytecode: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            implementation: `0x${string}`;
+            proxyAdmin: `0x${string}`;
+            data?: `0x${string}` | undefined;
+        };
+    };
+    out: {
+        json: {
+            implementation: `0x${string}`;
+            proxyAdmin: `0x${string}`;
+            data?: `0x${string}` | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    args: any[];
+    bytecode: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            implementation: `0x${string}`;
+            proxyAdmin: `0x${string}`;
+            data?: `0x${string}` | undefined;
+        };
+    };
+    out: {
+        json: {
+            implementation: `0x${string}`;
+            proxyAdmin: `0x${string}`;
+            data?: `0x${string}` | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    args: any[];
+    bytecode: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+export declare function createProxyAdmin<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    bytecode: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    bytecode: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
 //# sourceMappingURL=deploy.d.ts.map

package/dist/issuance/deploy.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/issuance/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;~~AAIxB~~,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA+BvC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOlE;~~AAgCD~~,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAiBpE"}
1	+ {"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/issuance/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA+BvC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOlE;AAiCD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAiBpE;AAgCD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAIvC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAcxE;AA4BD,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOlE"}

package/dist/issuance/deploy.js CHANGED Viewed

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { describeRoute } from "hono-openapi";
 import { erc1967ProxyAbi, erc1967ProxyBytecode } from "@evergonlabs/tmi-evm-contracts/erc1967";
+import { transparentUpgradeableProxyAbi, transparentUpgradeableProxyBytecode, } from "@evergonlabs/tmi-evm-contracts/transparentUpgradeableProxy";
+import { proxyAdminAbi, proxyAdminBytecode } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
 import { resolver, validator } from "hono-openapi/zod";
 import { AddressSchema, HexStringSchema } from "../common/index.js";
 import { encodeFunctionData } from "viem";
@@ -54,6 +56,7 @@ const deployProxyRoute = describeRoute({
     summary: "Get ERC1967Proxy",
     description: "Returns transaction data for deploying a ERC1967Proxy",
     tags: ["Issuance"],
+    deprecated: true,
     responses: {
         200: {
             description: "Returns transaction data for deploying a ERC1967Proxy",
@@ -89,3 +92,78 @@ export function createErc1967Proxy(factory) {
         });
     });
 }
+const IssuanceDeployTransparentProxySchema = z
+    .object({
+    bytecode: HexStringSchema.openapi({ description: "Bytecode of the smartcontract" }),
+    abi: z.array(z.any()).openapi({
+        description: "ABI of a contract.",
+        type: "array",
+    }),
+    args: z.array(z.any()).openapi({
+        description: "Arguments for the transparent proxy initialization",
+        type: "array",
+    }),
+})
+    .openapi({ ref: "IssuanceDeployTransparentProxySchema" });
+const deployTransparentProxyRoute = describeRoute({
+    summary: "Deploy TransparentUpgradeableProxy",
+    description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
+            content: {
+                "application/json": {
+                    schema: resolver(IssuanceDeployTransparentProxySchema),
+                },
+            },
+        },
+    },
+});
+export const DeployTransparentProxySchema = z.object({
+    implementation: AddressSchema.openapi("The address of the implementation contract"),
+    proxyAdmin: AddressSchema.openapi("The address of the proxy admin"),
+    data: HexStringSchema.openapi("The encoded initialization data for the implementation").optional(),
+});
+export function createTransparentProxy(factory) {
+    return factory.createHandlers(deployTransparentProxyRoute, validator("json", DeployTransparentProxySchema), async (c) => {
+        const { implementation, proxyAdmin: admin, data } = c.req.valid("json");
+        return c.json({
+            bytecode: transparentUpgradeableProxyBytecode,
+            abi: transparentUpgradeableProxyAbi,
+            args: [implementation, admin, data || "0x"],
+        });
+    });
+}
+const IssuanceDeployProxyAdminSchema = z
+    .object({
+    bytecode: HexStringSchema.openapi({ description: "Bytecode of the smartcontract" }),
+    abi: z.array(z.any()).openapi({
+        description: "ABI of a contract.",
+        type: "array",
+    }),
+})
+    .openapi({ ref: "IssuanceDeployProxyAdminSchema" });
+const deployProxyAdminRoute = describeRoute({
+    summary: "Deploy ProxyAdmin",
+    description: "Returns transaction data for deploying a ProxyAdmin contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a ProxyAdmin contract",
+            content: {
+                "application/json": {
+                    schema: resolver(IssuanceDeployProxyAdminSchema),
+                },
+            },
+        },
+    },
+});
+export function createProxyAdmin(factory) {
+    return factory.createHandlers(deployProxyAdminRoute, async (c) => {
+        return c.json({
+            bytecode: proxyAdminBytecode,
+            abi: proxyAdminAbi,
+        });
+    });
+}

package/dist/issuance/index.d.ts CHANGED Viewed

@@ -180,6 +180,62 @@ export declare const issuanceApis: {
                 status: import("hono/utils/http-status").ContentfulStatusCode;
             };
         };
+    } & {
+        "/proxy/deployTransparentProxy": {
+            $post: {
+                input: {
+                    json: {
+                        implementation: `0x${string}`;
+                        proxyAdmin: `0x${string}`;
+                        data?: `0x${string}` | undefined;
+                    };
+                };
+                output: {
+                    abi: any[];
+                    args: any[];
+                    bytecode: `0x${string}`;
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/proxy/deployProxyAdmin": {
+            $get: {
+                input: {};
+                output: {
+                    abi: any[];
+                    bytecode: `0x${string}`;
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/proxy/upgradeTransparentProxy": {
+            $post: {
+                input: {
+                    json: {
+                        newImplementation: `0x${string}`;
+                        proxyAdminAddress: `0x${string}`;
+                        proxyAddress: `0x${string}`;
+                        data?: `0x${string}` | undefined;
+                    };
+                };
+                output: {
+                    data: `0x${string}`;
+                    to: `0x${string}`;
+                    details: {
+                        functionName: string;
+                        address: `0x${string}`;
+                        abi: any[];
+                        args: any[];
+                    };
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
     }, "/issuance">, "/">;
     config: {
         title: string;

package/dist/issuance/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/issuance/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;~~AAUvC~~,eAAO,MAAM,YAAY;;gBAEX,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkB~~/C,CAAC"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/issuance/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAWvC,eAAO,MAAM,YAAY;;gBAEX,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqB/C,CAAC"}

package/dist/issuance/index.js CHANGED Viewed

@@ -1,11 +1,12 @@
 import { createApiConfig } from "../common/app.js";
 import { approveErc20Token } from "./approve.js";
 import { burnErc20Token } from "./burn.js";
-import { createErc1967Proxy, createErc20Token } from "./deploy.js";
+import { createErc1967Proxy, createErc20Token, createTransparentProxy, createProxyAdmin } from "./deploy.js";
 import { mintErc20Token } from "./mint.js";
 import { transferErc20Token } from "./transfer.js";
 import { createGrantRole } from "./grantRole.js";
 import { createRenounceRole } from "./renounceRole.js";
+import { upgradeTransparentProxy } from "./upgrade.js";
 export const issuanceApis = {
     name: "Issuance APIs",
     createApp: (factory) => factory.createApp().route("/issuance", factory
@@ -17,7 +18,10 @@ export const issuanceApis = {
         .post("/erc20/transfer", ...transferErc20Token(factory))
         .post("/erc20/proxy", ...createErc1967Proxy(factory))
         .post("/erc20/grantRole", ...createGrantRole(factory))
-        .post("/erc20/renounceRole", ...createRenounceRole(factory))),
+        .post("/erc20/renounceRole", ...createRenounceRole(factory))
+        .post("/proxy/deployTransparentProxy", ...createTransparentProxy(factory))
+        .get("/proxy/deployProxyAdmin", ...createProxyAdmin(factory))
+        .post("/proxy/upgradeTransparentProxy", ...upgradeTransparentProxy(factory))),
     config: createApiConfig({
         title: "Issuance API",
         description: "APIs for issuing tokens",

package/dist/issuance/upgrade.d.ts ADDED Viewed

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare const UpgradeProxyRequestSchema: z.ZodObject<{
+    proxyAdminAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    proxyAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    newImplementation: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    data: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+}, "strip", z.ZodTypeAny, {
+    newImplementation: `0x${string}`;
+    proxyAdminAddress: `0x${string}`;
+    proxyAddress: `0x${string}`;
+    data?: `0x${string}` | undefined;
+}, {
+    newImplementation: `0x${string}`;
+    proxyAdminAddress: `0x${string}`;
+    proxyAddress: `0x${string}`;
+    data?: `0x${string}` | undefined;
+}>;
+export declare function upgradeTransparentProxy<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            newImplementation: `0x${string}`;
+            proxyAdminAddress: `0x${string}`;
+            proxyAddress: `0x${string}`;
+            data?: `0x${string}` | undefined;
+        };
+    };
+    out: {
+        json: {
+            newImplementation: `0x${string}`;
+            proxyAdminAddress: `0x${string}`;
+            proxyAddress: `0x${string}`;
+            data?: `0x${string}` | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            newImplementation: `0x${string}`;
+            proxyAdminAddress: `0x${string}`;
+            proxyAddress: `0x${string}`;
+            data?: `0x${string}` | undefined;
+        };
+    };
+    out: {
+        json: {
+            newImplementation: `0x${string}`;
+            proxyAdminAddress: `0x${string}`;
+            proxyAddress: `0x${string}`;
+            data?: `0x${string}` | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=upgrade.d.ts.map

package/dist/issuance/upgrade.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../src/issuance/upgrade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAapC,CAAC;AAmBH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAazE"}

package/dist/issuance/upgrade.js ADDED Viewed

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { AddressSchema, HexStringSchema, toTransaction, TransactionSchema } from "../common/index.js";
+import { proxyAdminAbi } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
+export const UpgradeProxyRequestSchema = z.object({
+    proxyAdminAddress: AddressSchema.openapi({
+        description: "The address of the ProxyAdmin contract that manages the proxy",
+    }),
+    proxyAddress: AddressSchema.openapi({
+        description: "The address of the transparent proxy contract to upgrade",
+    }),
+    newImplementation: AddressSchema.openapi({
+        description: "The address of the new implementation contract",
+    }),
+    data: HexStringSchema.optional().openapi({
+        description: "Initialization data",
+    }),
+});
+const upgradeRoute = describeRoute({
+    summary: "Upgrade Transparent Proxy Implementation",
+    description: "Returns transaction data for upgrading the implementation of a transparent proxy contract using ProxyAdmin",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for upgrading transparent proxy implementation via ProxyAdmin",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function upgradeTransparentProxy(factory) {
+    return factory.createHandlers(upgradeRoute, validator("json", UpgradeProxyRequestSchema), async (c) => {
+        const { proxyAdminAddress, proxyAddress, newImplementation, data } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: proxyAdminAddress,
+            abi: proxyAdminAbi,
+            functionName: "upgradeAndCall",
+            args: [proxyAddress, newImplementation, data || "0x"],
+        }));
+    });
+}