@evergonlabs/tmi-protocol-api 0.1.4 → 0.2.0

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

@@ -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

@@ -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/general/balanceClient.d.ts

@@ -5,9 +5,9 @@ import { z } from "../common/zod.js";
 export declare const AccountBalancesResponse: z.ZodObject<{
     message: z.ZodString;
     status: z.ZodString;
-    result: z.ZodArray<z.ZodObject<{
+    result: z.ZodArray<z.ZodEffects<z.ZodObject<{
         balance: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodString>;
-        tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        contractAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
         decimals: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodNumber>, number, string | number | bigint>;
         tokenId: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodString>>;
         name: z.ZodString;
@@ -18,7 +18,7 @@ export declare const AccountBalancesResponse: z.ZodObject<{
         type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
         name: string;
         decimals: number;
-        tokenAddress: `0x${string}`;
+        contractAddress: `0x${string}`;
         balance: string;
         tokenId?: string | undefined;
     }, {
@@ -26,7 +26,23 @@ export declare const AccountBalancesResponse: z.ZodObject<{
         type: string;
         name: string;
         decimals: string | number | bigint;
+        contractAddress: `0x${string}`;
+        balance: string | number | bigint;
+        tokenId?: string | number | bigint | undefined;
+    }>, {
         tokenAddress: `0x${string}`;
+        symbol: string;
+        type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
+        name: string;
+        decimals: number;
+        balance: string;
+        tokenId?: string | undefined;
+    }, {
+        symbol: string;
+        type: string;
+        name: string;
+        decimals: string | number | bigint;
+        contractAddress: `0x${string}`;
         balance: string | number | bigint;
         tokenId?: string | number | bigint | undefined;
     }>, "many">;
@@ -34,11 +50,11 @@ export declare const AccountBalancesResponse: z.ZodObject<{
     status: string;
     message: string;
     result: {
+        tokenAddress: `0x${string}`;
         symbol: string;
         type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
         name: string;
         decimals: number;
-        tokenAddress: `0x${string}`;
         balance: string;
         tokenId?: string | undefined;
     }[];
@@ -50,7 +66,7 @@ export declare const AccountBalancesResponse: z.ZodObject<{
         type: string;
         name: string;
         decimals: string | number | bigint;
-        tokenAddress: `0x${string}`;
+        contractAddress: `0x${string}`;
         balance: string | number | bigint;
         tokenId?: string | number | bigint | undefined;
     }[];

package/dist/general/balanceClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"balanceClient.d.ts","sourceRoot":"","sources":["../../src/general/balanceClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAErE,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,kBAAkB,CAAC;AAErC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIlC,CAAC;AAEH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,EAAE,CAAC,CA2BzC"}
+{"version":3,"file":"balanceClient.d.ts","sourceRoot":"","sources":["../../src/general/balanceClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAErE,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,kBAAkB,CAAC;AAErC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIlC,CAAC;AAEH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,EAAE,CAAC,CA2BzC"}

package/dist/general/utils/tokenBalance/tokenBalance.d.ts

@@ -1,8 +1,8 @@
 import { TokenTypeEnum } from "@evergonlabs/tmi-protocol-types/evm";
 import { z } from "../../../common/zod.js";
-export declare const TokenBalance: z.ZodObject<{
+export declare const TokenBalance: z.ZodEffects<z.ZodObject<{
     balance: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodString>;
-    tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    contractAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
     decimals: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodNumber>, number, string | number | bigint>;
     tokenId: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodString>>;
     name: z.ZodString;
@@ -13,7 +13,7 @@ export declare const TokenBalance: z.ZodObject<{
     type: TokenTypeEnum | null;
     name: string;
     decimals: number;
-    tokenAddress: `0x${string}`;
+    contractAddress: `0x${string}`;
     balance: string;
     tokenId?: string | undefined;
 }, {
@@ -21,7 +21,23 @@ export declare const TokenBalance: z.ZodObject<{
     type: string;
     name: string;
     decimals: string | number | bigint;
+    contractAddress: `0x${string}`;
+    balance: string | number | bigint;
+    tokenId?: string | number | bigint | undefined;
+}>, {
     tokenAddress: `0x${string}`;
+    symbol: string;
+    type: TokenTypeEnum | null;
+    name: string;
+    decimals: number;
+    balance: string;
+    tokenId?: string | undefined;
+}, {
+    symbol: string;
+    type: string;
+    name: string;
+    decimals: string | number | bigint;
+    contractAddress: `0x${string}`;
     balance: string | number | bigint;
     tokenId?: string | number | bigint | undefined;
 }>;

package/dist/general/utils/tokenBalance/tokenBalance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokenBalance.d.ts","sourceRoot":"","sources":["../../../../src/general/utils/tokenBalance/tokenBalance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAW3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;EASvB,CAAC"}
+{"version":3,"file":"tokenBalance.d.ts","sourceRoot":"","sources":["../../../../src/general/utils/tokenBalance/tokenBalance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAW3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcpB,CAAC"}

package/dist/general/utils/tokenBalance/tokenBalance.js

@@ -8,13 +8,18 @@ const tokenTypeDict = {
     "ERC-20": TokenTypeEnum.ERC20,
 };
 // @see definitions here https://docs.blockscout.com/devs/apis/rpc/account#get-list-of-tokens-owned-by-address
-export const TokenBalance = z.object({
+export const TokenBalance = z
+    .object({
     balance: NumberishSchema.pipe(z.string()),
-    tokenAddress: AddressSchema,
+    contractAddress: AddressSchema,
     // ERC-721 and ERC-1155 has no decimals but for interoperability we return 1
     decimals: NumberishSchema.pipe(z.coerce.number()).transform((x) => x || 1),
     tokenId: z.optional(NumberishSchema.pipe(z.string())),
     name: z.string(),
     symbol: z.string(),
     type: z.string().transform((x) => (x in tokenTypeDict ? tokenTypeDict[x] : null)),
-});
+})
+    .transform(({ contractAddress, ...rest }) => ({
+    ...rest,
+    tokenAddress: contractAddress,
+}));

package/dist/issuance/deploy.d.ts

@@ -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

@@ -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"}
+{"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

@@ -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

@@ -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

@@ -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"}
+{"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

@@ -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

@@ -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

@@ -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;AAMvC,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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
+import { proxyAdminAbi } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
+import { HexStringSchema } from "@evergonlabs/tmi-utils/models";
+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"],
+        }));
+    });
+}

package/dist/lending/buyBackAfterLiquidation/v0/buyBackAfterLiquidation.routes.d.ts

@@ -0,0 +1,57 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createBuyBackAfterLiquidationTransactionV0<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: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+        };
+    };
+}, 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: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+        };
+    };
+}, 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=buyBackAfterLiquidation.routes.d.ts.map

package/dist/lending/buyBackAfterLiquidation/v0/buyBackAfterLiquidation.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buyBackAfterLiquidation.routes.d.ts","sourceRoot":"","sources":["../../../../src/lending/buyBackAfterLiquidation/v0/buyBackAfterLiquidation.routes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAqBvC,wBAAgB,0CAA0C,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAe5F"}