@proto-kit/protocol 0.1.1-develop.190 → 0.1.1-develop.2024

package/dist/settlement/ContractArgsRegistry.js

@@ -0,0 +1,53 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable, singleton } from "tsyringe";
+import merge from "lodash/merge";
+/*
+interface Test {
+  one: string;
+  two?: string;
+}
+
+const x: NaiveObjectSchema<Test> = {
+  one: "Required",
+  two: "Optional",
+};
+*/
+export let ContractArgsRegistry = class ContractArgsRegistry {
+    constructor() {
+        this.args = {};
+    }
+    addArgs(name, addition) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const args = this.args[name] ?? {};
+        this.args[name] = merge(args, addition);
+    }
+    resetArgs(name) {
+        delete this.args[name];
+    }
+    getArgs(name, schema) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const args = this.args[name] ?? {};
+        const missing = Object.entries(schema).filter(([key, type]) => {
+            // We filter only if the key is required and isn't present
+            return type === "Required" && args[key] === undefined;
+        });
+        if (missing.length > 0) {
+            const missingKeys = missing.map(([key]) => key);
+            throw new Error(`Contract args for ${name} not all present, ${missingKeys} are missing`);
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return args;
+        }
+    }
+};
+ContractArgsRegistry = __decorate([
+    injectable(),
+    singleton()
+], ContractArgsRegistry);
+//# sourceMappingURL=ContractArgsRegistry.js.map

package/dist/settlement/ContractArgsRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractArgsRegistry.js","sourceRoot":"","sources":["../../src/settlement/ContractArgsRegistry.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,KAAK,MAAM,cAAc,CAAC;AAUjC;;;;;;;;;;EAUE;AAIK,WAAM,oBAAoB,GAA1B,MAAM,oBAAoB;IAA1B;QACL,SAAI,GAAwB,EAAE,CAAC;IAiCjC,CAAC;IA/BQ,OAAO,CAAO,IAAY,EAAE,QAAuB;QACxD,mEAAmE;QACnE,MAAM,IAAI,GAAkB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAClD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAEM,SAAS,CAAC,IAAY;QAC3B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAEM,OAAO,CAAO,IAAY,EAAE,MAA+B;QAChE,mEAAmE;QACnE,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAEnC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAA0B,MAAM,CAAC,CAAC,MAAM,CACpE,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE;YACd,0DAA0D;YAC1D,OAAO,IAAI,KAAK,UAAU,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;QACxD,CAAC,CACF,CAAC;QAEF,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;YACtB,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;YAChD,MAAM,IAAI,KAAK,CACb,qBAAqB,IAAI,qBAAqB,WAAW,cAAc,CACxE,CAAC;SACH;aAAM;YACL,yEAAyE;YACzE,OAAO,IAAY,CAAC;SACrB;IACH,CAAC;CACF,CAAA;AAlCY,oBAAoB;IAFhC,UAAU,EAAE;IACZ,SAAS,EAAE;GACC,oBAAoB,CAkChC"}

package/dist/settlement/ContractModule.d.ts

@@ -0,0 +1,16 @@
+import { ArtifactRecord, type CompilableModule, CompileRegistry, ConfigurableModule, NoConfig, TypedClass } from "@proto-kit/common";
+import { SmartContract } from "o1js";
+export type SmartContractClassFromInterface<Type> = typeof SmartContract & TypedClass<Type>;
+/**
+ * This module type is used to define a contract module that can be used to
+ * construct and inject smart contract instances.
+ * It defines a method contractFactory, whose arguments can be configured via
+ * the Argument generic. It returns a smart contract class that is a subclass
+ * of SmartContract and implements a certain interface as specified by the
+ * ContractType generic.
+ */
+export declare abstract class ContractModule<ContractType, Config = NoConfig> extends ConfigurableModule<Config> implements CompilableModule {
+    abstract contractFactory(): SmartContractClassFromInterface<ContractType>;
+    abstract compile(registry: CompileRegistry): Promise<ArtifactRecord | undefined>;
+}
+//# sourceMappingURL=ContractModule.d.ts.map

package/dist/settlement/ContractModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractModule.d.ts","sourceRoot":"","sources":["../../src/settlement/ContractModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,gBAAgB,EACrB,eAAe,EACf,kBAAkB,EAClB,QAAQ,EACR,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAErC,MAAM,MAAM,+BAA+B,CAAC,IAAI,IAAI,OAAO,aAAa,GACtE,UAAU,CAAC,IAAI,CAAC,CAAC;AAEnB;;;;;;;GAOG;AACH,8BAAsB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,CAClE,SAAQ,kBAAkB,CAAC,MAAM,CACjC,YAAW,gBAAgB;aAEX,eAAe,IAAI,+BAA+B,CAAC,YAAY,CAAC;aAEhE,OAAO,CACrB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;CACvC"}

package/dist/settlement/ContractModule.js

@@ -0,0 +1,12 @@
+import { ConfigurableModule, } from "@proto-kit/common";
+/**
+ * This module type is used to define a contract module that can be used to
+ * construct and inject smart contract instances.
+ * It defines a method contractFactory, whose arguments can be configured via
+ * the Argument generic. It returns a smart contract class that is a subclass
+ * of SmartContract and implements a certain interface as specified by the
+ * ContractType generic.
+ */
+export class ContractModule extends ConfigurableModule {
+}
+//# sourceMappingURL=ContractModule.js.map

package/dist/settlement/ContractModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractModule.js","sourceRoot":"","sources":["../../src/settlement/ContractModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,kBAAkB,GAGnB,MAAM,mBAAmB,CAAC;AAM3B;;;;;;;GAOG;AACH,MAAM,OAAgB,cACpB,SAAQ,kBAA0B;CAQnC"}

package/dist/settlement/SettlementContractModule.d.ts

@@ -0,0 +1,47 @@
+import { AreProofsEnabled, ChildContainerProvider, ModuleContainer, ModulesRecord, TypedClass, StringKeyOf } from "@proto-kit/common";
+import { Field, PublicKey, SmartContract } from "o1js";
+import { ProtocolEnvironment } from "../protocol/ProtocolEnvironment";
+import { ProtocolModule } from "../protocol/ProtocolModule";
+import { ContractModule } from "./ContractModule";
+import { DispatchContractProtocolModule } from "./contracts/DispatchContractProtocolModule";
+import { DispatchContractType } from "./contracts/DispatchSmartContract";
+import { BridgingSettlementContractModule } from "./contracts/BridgingSettlementContractModule";
+import { BridgeContractType } from "./contracts/BridgeContract";
+import { BridgeContractConfig, BridgeContractProtocolModule } from "./contracts/BridgeContractProtocolModule";
+import { GetContracts, InferContractType } from "./modularity/types";
+import { BridgingSettlementContractType } from "./contracts/settlement/BridgingSettlementContract";
+import { SettlementContractType } from "./contracts/settlement/SettlementBase";
+import { SettlementContractConfig, SettlementSmartContractModule } from "./contracts/SettlementSmartContractModule";
+export type SettlementModulesRecord = ModulesRecord<TypedClass<ContractModule<unknown, unknown>>>;
+export type MandatorySettlementModulesRecord = {
+    SettlementContract: TypedClass<ContractModule<SettlementContractType, SettlementContractConfig>>;
+};
+export type BridgingSettlementModulesRecord = {
+    SettlementContract: TypedClass<ContractModule<BridgingSettlementContractType, SettlementContractConfig>>;
+    DispatchContract: TypedClass<ContractModule<DispatchContractType, unknown>>;
+    BridgeContract: TypedClass<ContractModule<BridgeContractType, BridgeContractConfig>>;
+};
+export declare class SettlementContractModule<SettlementModules extends SettlementModulesRecord> extends ModuleContainer<SettlementModules> implements ProtocolModule<unknown> {
+    constructor(definition: SettlementModules);
+    static from<SettlementModules extends SettlementModulesRecord>(modules: SettlementModules): TypedClass<SettlementContractModule<SettlementModules>>;
+    static settlementOnly(): {
+        readonly SettlementContract: typeof SettlementSmartContractModule;
+    };
+    static settlementAndBridging(): {
+        readonly SettlementContract: typeof BridgingSettlementContractModule;
+        readonly DispatchContract: typeof DispatchContractProtocolModule;
+        readonly BridgeContract: typeof BridgeContractProtocolModule;
+    };
+    protocol?: ProtocolEnvironment;
+    get areProofsEnabled(): AreProofsEnabled | undefined;
+    create(childContainerProvider: ChildContainerProvider): void;
+    start(): Promise<void>;
+    getContractClasses(): GetContracts<SettlementModules>;
+    createContract<ContractName extends StringKeyOf<SettlementModules>>(contractName: ContractName, address: PublicKey, tokenId?: Field): InferContractType<SettlementModules[ContractName]>;
+    createContracts<ContractName extends keyof SettlementModules>(addresses: {
+        [Key in ContractName]: PublicKey;
+    }): {
+        [Key in ContractName]: SmartContract & InferContractType<SettlementModules[Key]>;
+    };
+}
+//# sourceMappingURL=SettlementContractModule.d.ts.map

package/dist/settlement/SettlementContractModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SettlementContractModule.d.ts","sourceRoot":"","sources":["../../src/settlement/SettlementContractModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,aAAa,EACb,UAAU,EAEV,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAGvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,8BAA8B,EAAE,MAAM,4CAA4C,CAAC;AAC5F,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,gCAAgC,EAAE,MAAM,8CAA8C,CAAC;AAChG,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EACL,oBAAoB,EACpB,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,8BAA8B,EAAE,MAAM,mDAAmD,CAAC;AACnG,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EACL,wBAAwB,EACxB,6BAA6B,EAC9B,MAAM,2CAA2C,CAAC;AAEnD,MAAM,MAAM,uBAAuB,GAAG,aAAa,CACjD,UAAU,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAC7C,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C,kBAAkB,EAAE,UAAU,CAC5B,cAAc,CAAC,sBAAsB,EAAE,wBAAwB,CAAC,CACjE,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,kBAAkB,EAAE,UAAU,CAC5B,cAAc,CAAC,8BAA8B,EAAE,wBAAwB,CAAC,CACzE,CAAC;IACF,gBAAgB,EAAE,UAAU,CAAC,cAAc,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5E,cAAc,EAAE,UAAU,CACxB,cAAc,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CACzD,CAAC;CACH,CAAC;AAEF,qBACa,wBAAwB,CACjC,iBAAiB,SAAS,uBAAuB,CAEnD,SAAQ,eAAe,CAAC,iBAAiB,CACzC,YAAW,cAAc,CAAC,OAAO,CAAC;gBAEf,UAAU,EAAE,iBAAiB;WAIlC,IAAI,CAAC,iBAAiB,SAAS,uBAAuB,EAClE,OAAO,EAAE,iBAAiB,GACzB,UAAU,CAAC,wBAAwB,CAAC,iBAAiB,CAAC,CAAC;WAQ5C,cAAc;;;WAMd,qBAAqB;;;;;IAS5B,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAEtC,IAAW,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAE1D;IAGM,MAAM,CAAC,sBAAsB,EAAE,sBAAsB;IAI/C,KAAK;IAIX,kBAAkB,IAAI,YAAY,CAAC,iBAAiB,CAAC;IAUrD,cAAc,CAAC,YAAY,SAAS,WAAW,CAAC,iBAAiB,CAAC,EACvE,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,SAAS,EAClB,OAAO,CAAC,EAAE,KAAK,GACd,iBAAiB,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;IAS9C,eAAe,CACpB,YAAY,SAAS,MAAM,iBAAiB,EAC5C,SAAS,EAAE;SACV,GAAG,IAAI,YAAY,GAAG,SAAS;KACjC,GAAG;SACD,GAAG,IAAI,YAAY,GAAG,aAAa,GAClC,iBAAiB,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;KAC5C;CAgBF"}

package/dist/settlement/SettlementContractModule.js

@@ -0,0 +1,81 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var SettlementContractModule_1;
+import { ModuleContainer, noop, } from "@proto-kit/common";
+import { injectable } from "tsyringe";
+import { DispatchContractProtocolModule } from "./contracts/DispatchContractProtocolModule";
+import { BridgingSettlementContractModule } from "./contracts/BridgingSettlementContractModule";
+import { BridgeContractProtocolModule, } from "./contracts/BridgeContractProtocolModule";
+import { SettlementSmartContractModule, } from "./contracts/SettlementSmartContractModule";
+export let SettlementContractModule = SettlementContractModule_1 = class SettlementContractModule extends ModuleContainer {
+    constructor(definition) {
+        super(definition);
+    }
+    static from(modules) {
+        return class ScopedSettlementContractModule extends SettlementContractModule_1 {
+            constructor() {
+                super(modules);
+            }
+        };
+    }
+    static settlementOnly() {
+        return {
+            SettlementContract: SettlementSmartContractModule,
+        };
+    }
+    static settlementAndBridging() {
+        return {
+            SettlementContract: BridgingSettlementContractModule,
+            DispatchContract: DispatchContractProtocolModule,
+            BridgeContract: BridgeContractProtocolModule,
+        };
+    }
+    get areProofsEnabled() {
+        return this.protocol?.getAreProofsEnabled();
+    }
+    // **
+    create(childContainerProvider) {
+        super.create(childContainerProvider);
+    }
+    async start() {
+        noop();
+    }
+    getContractClasses() {
+        const contracts = 
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        this.moduleNames.map((name) => {
+            const module = this.resolve(name);
+            return [name, module.contractFactory()];
+        });
+        return Object.fromEntries(contracts);
+    }
+    createContract(contractName, address, tokenId) {
+        const module = this.resolve(contractName);
+        const ContractClass = module.contractFactory();
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return new ContractClass(address, tokenId);
+    }
+    createContracts(addresses) {
+        const classes = this.getContractClasses();
+        const obj = {};
+        // eslint-disable-next-line guard-for-in
+        for (const key in addresses) {
+            const ContractClass = classes[key];
+            obj[key] = new ContractClass(addresses[key]);
+        }
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return obj;
+    }
+};
+SettlementContractModule = SettlementContractModule_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object])
+], SettlementContractModule);
+//# sourceMappingURL=SettlementContractModule.js.map

package/dist/settlement/SettlementContractModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SettlementContractModule.js","sourceRoot":"","sources":["../../src/settlement/SettlementContractModule.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,OAAO,EAGL,eAAe,EAGf,IAAI,GAEL,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAMtC,OAAO,EAAE,8BAA8B,EAAE,MAAM,4CAA4C,CAAC;AAE5F,OAAO,EAAE,gCAAgC,EAAE,MAAM,8CAA8C,CAAC;AAEhG,OAAO,EAEL,4BAA4B,GAC7B,MAAM,0CAA0C,CAAC;AAIlD,OAAO,EAEL,6BAA6B,GAC9B,MAAM,2CAA2C,CAAC;AAuB5C,WAAM,wBAAwB,gCAA9B,MAAM,wBAGX,SAAQ,eAAkC;IAG1C,YAAmB,UAA6B;QAC9C,KAAK,CAAC,UAAU,CAAC,CAAC;IACpB,CAAC;IAEM,MAAM,CAAC,IAAI,CAChB,OAA0B;QAE1B,OAAO,MAAM,8BAA+B,SAAQ,0BAA2C;YAC7F;gBACE,KAAK,CAAC,OAAO,CAAC,CAAC;YACjB,CAAC;SACF,CAAC;IACJ,CAAC;IAEM,MAAM,CAAC,cAAc;QAC1B,OAAO;YACL,kBAAkB,EAAE,6BAA6B;SACzC,CAAC;IACb,CAAC;IAEM,MAAM,CAAC,qBAAqB;QACjC,OAAO;YACL,kBAAkB,EAAE,gCAAgC;YACpD,gBAAgB,EAAE,8BAA8B;YAChD,cAAc,EAAE,4BAA4B;SACpC,CAAC;IACb,CAAC;IAKD,IAAW,gBAAgB;QACzB,OAAO,IAAI,CAAC,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAC9C,CAAC;IACD,KAAK;IAEE,MAAM,CAAC,sBAA8C;QAC1D,KAAK,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;IACvC,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,IAAI,EAAE,CAAC;IACT,CAAC;IAEM,kBAAkB;QACvB,MAAM,SAAS;QACb,yEAAyE;QACxE,IAAI,CAAC,WAAgD,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YAClE,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAClC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QACL,OAAO,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAEM,cAAc,CACnB,YAA0B,EAC1B,OAAkB,EAClB,OAAe;QAEf,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QAC1C,MAAM,aAAa,GAAG,MAAM,CAAC,eAAe,EAAE,CAAC;QAC/C,yEAAyE;QACzE,OAAO,IAAI,aAAa,CAAC,OAAO,EAAE,OAAO,CAExC,CAAC;IACJ,CAAC;IAEM,eAAe,CAEpB,SAED;QAIC,MAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAE1C,MAAM,GAAG,GAAkC,EAAE,CAAC;QAC9C,wCAAwC;QACxC,KAAK,MAAM,GAAG,IAAI,SAAS,EAAE;YAC3B,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;YACnC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;SAC9C;QAED,yEAAyE;QACzE,OAAO,GAGN,CAAC;IACJ,CAAC;CACF,CAAA;AAhGY,wBAAwB;IADpC,UAAU,EAAE;;GACA,wBAAwB,CAgGpC"}

package/dist/settlement/contracts/BridgeContract.d.ts

@@ -0,0 +1,119 @@
+import { AccountUpdate, Bool, Field, Permissions, PublicKey, SmartContract, State, TokenContract, VerificationKey } from "o1js";
+import { TypedClass } from "@proto-kit/common";
+import { OutgoingMessageArgumentBatch, OutgoingMessageArgument } from "../messages/OutgoingMessageArgument";
+import { OutgoingMessageProcessor } from "../modularity/OutgoingMessageProcessor";
+import { NaiveObjectSchema, StaticInitializationContract } from "../ContractArgsRegistry";
+import type { BridgingSettlementContractType } from "./settlement/BridgingSettlementContract";
+export type BridgeContractType = {
+    stateRoot: State<Field>;
+    outgoingMessageCursor: State<Field>;
+    rollupOutgoingMessages: (batch: OutgoingMessageArgumentBatch) => Promise<Field>;
+    redeem: (additionUpdate: AccountUpdate) => Promise<void>;
+    deployProvable: (args: VerificationKey | undefined, signedSettlement: boolean, permissions: Permissions, settlementContractAddress: PublicKey) => Promise<AccountUpdate>;
+    updateStateRoot: (root: Field) => Promise<void>;
+};
+declare const OutgoingMessageKey_base: (new (value: {
+    index: import("o1js/dist/node/lib/provable/field").Field;
+    tokenId: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    index: import("o1js/dist/node/lib/provable/field").Field;
+    tokenId: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    index: import("o1js/dist/node/lib/provable/field").Field;
+    tokenId: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    index: bigint;
+    tokenId: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        tokenId: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        index: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        tokenId: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        tokenId: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        tokenId: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        tokenId: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        index: string;
+        tokenId: string;
+    };
+    fromJSON: (x: {
+        index: string;
+        tokenId: string;
+    }) => {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        tokenId: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        tokenId: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class OutgoingMessageKey extends OutgoingMessageKey_base {
+}
+export declare class BridgeContractContext {
+    data: {
+        messageInputs: any[][];
+    };
+}
+export interface BridgeContractArgs {
+    SettlementContract: TypedClass<BridgingSettlementContractType> & typeof SmartContract;
+    messageProcessors: OutgoingMessageProcessor<unknown>[];
+    batchSize?: number;
+}
+export declare const BridgeContractArgsSchema: NaiveObjectSchema<BridgeContractArgs>;
+export declare abstract class BridgeContractBase extends TokenContract implements StaticInitializationContract<BridgeContractArgs> {
+    constructor(address: PublicKey, tokenId?: Field);
+    getInitializationArgs(): BridgeContractArgs;
+    abstract settlementContractAddress: State<PublicKey>;
+    abstract stateRoot: State<Field>;
+    abstract outgoingMessageCursor: State<Field>;
+    /**
+     * Function to deploy the bridging contract in a provable way, so that it can be
+     * a provable process initiated by the settlement contract with a baked-in vk
+     *
+     * @returns Creates and returns an account update deploying the bridge contract
+     */
+    deployProvable(verificationKey: VerificationKey | undefined, signedSettlement: boolean, permissions: Permissions, settlementContractAddress: PublicKey): Promise<AccountUpdate>;
+    approveBase(): Promise<void>;
+    updateStateRootBase(root: Field): Promise<void>;
+    private batchSize;
+    private executeProcessors;
+    processMessage(batchIndex: number, args: OutgoingMessageArgument, isDummy: Bool): {
+        messageType: import("o1js/dist/node/lib/provable/field").Field;
+        result: {
+            accountUpdates: AccountUpdate[];
+            status: import("o1js/dist/node/lib/provable/bool").Bool;
+            statusMessage?: string | undefined;
+        };
+        hash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    rollupOutgoingMessagesBase(batch: OutgoingMessageArgumentBatch): Promise<import("o1js/dist/node/lib/provable/field").Field>;
+    protected redeemBase(additionUpdate: AccountUpdate): Promise<void>;
+}
+export declare class BridgeContract extends BridgeContractBase implements BridgeContractType {
+    settlementContractAddress: State<PublicKey>;
+    stateRoot: State<import("o1js/dist/node/lib/provable/field").Field>;
+    outgoingMessageCursor: State<import("o1js/dist/node/lib/provable/field").Field>;
+    updateStateRoot(root: Field): Promise<void>;
+    rollupOutgoingMessages(batch: OutgoingMessageArgumentBatch): Promise<import("o1js/dist/node/lib/provable/field").Field>;
+    redeem(additionUpdate: AccountUpdate): Promise<void>;
+}
+export {};
+//# sourceMappingURL=BridgeContract.d.ts.map

package/dist/settlement/contracts/BridgeContract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeContract.d.ts","sourceRoot":"","sources":["../../../src/settlement/contracts/BridgeContract.ts"],"names":[],"mappings":"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"}

package/dist/settlement/contracts/BridgeContract.js

@@ -0,0 +1,269 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AccountUpdate, Bool, Experimental, Field, method, Poseidon, Provable, PublicKey, State, state, Struct, TokenContract, TokenId, } from "o1js";
+import { noop, range } from "@proto-kit/common";
+import { container, injectable, singleton } from "tsyringe";
+import { OUTGOING_MESSAGE_BATCH_SIZE, OutgoingMessageArgumentBatch, createMessageStruct, } from "../messages/OutgoingMessageArgument";
+import { Path } from "../../model/Path";
+import { PROTOKIT_FIELD_PREFIXES } from "../../hashing/protokit-prefixes";
+import { ContractArgsRegistry, } from "../ContractArgsRegistry";
+// Equal to WithdrawalKey
+export class OutgoingMessageKey extends Struct({
+    index: Field,
+    tokenId: Field,
+}) {
+}
+export let BridgeContractContext = class BridgeContractContext {
+    constructor() {
+        this.data = { messageInputs: [] };
+    }
+};
+BridgeContractContext = __decorate([
+    injectable(),
+    singleton()
+], BridgeContractContext);
+export const BridgeContractArgsSchema = {
+    batchSize: "Optional",
+    SettlementContract: "Required",
+    messageProcessors: "Required",
+};
+export class BridgeContractBase extends TokenContract {
+    constructor(address, tokenId) {
+        super(address, tokenId);
+    }
+    getInitializationArgs() {
+        return container
+            .resolve(ContractArgsRegistry)
+            .getArgs("BridgeContract", BridgeContractArgsSchema);
+    }
+    /**
+     * Function to deploy the bridging contract in a provable way, so that it can be
+     * a provable process initiated by the settlement contract with a baked-in vk
+     *
+     * @returns Creates and returns an account update deploying the bridge contract
+     */
+    async deployProvable(verificationKey, signedSettlement, permissions, settlementContractAddress) {
+        const accountUpdate = this.self;
+        if (!signedSettlement) {
+            if (verificationKey === undefined) {
+                throw new Error("Verification Key not provided, can't deploy");
+            }
+            accountUpdate.account.verificationKey.set(verificationKey);
+        }
+        accountUpdate.requireSignature();
+        this.account.permissions.set(permissions);
+        range(0, 8).forEach((i) => {
+            accountUpdate.update.appState[i] = {
+                isSome: Bool(true),
+                value: Field(0),
+            };
+        });
+        this.settlementContractAddress.set(settlementContractAddress);
+        accountUpdate.body.mayUseToken = {
+            // Set to true for custom tokens only
+            inheritFromParent: accountUpdate.tokenId.equals(TokenId.default).not(),
+            parentsOwnToken: Bool(false),
+        };
+        return accountUpdate;
+    }
+    async approveBase() {
+        noop();
+    }
+    async updateStateRootBase(root) {
+        // It's fine for us to only store the actual root since we only have to
+        // witness values, not update/insert
+        this.stateRoot.set(root);
+        const args = this.getInitializationArgs();
+        const settlementContractAddress = this.settlementContractAddress.getAndRequireEquals();
+        const SettlementContractClass = args.SettlementContract;
+        const settlementContract = new SettlementContractClass(settlementContractAddress);
+        const accountUpdate = settlementContract.assertStateRoot(root);
+        this.approve(accountUpdate);
+    }
+    batchSize() {
+        return (this.getInitializationArgs().batchSize ?? OUTGOING_MESSAGE_BATCH_SIZE);
+    }
+    executeProcessors(batchIndex, args) {
+        const { messageProcessors } = this.getInitializationArgs();
+        return messageProcessors.map((processor, j) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const value = Experimental.memoizeWitness(processor.type, () => {
+                return container.resolve(BridgeContractContext).data.messageInputs[batchIndex][j];
+            });
+            const MessageType = createMessageStruct(processor.type);
+            const message = new MessageType({
+                messageType: args.messageType,
+                value,
+            });
+            return {
+                messageType: args.messageType,
+                result: processor.processMessage(value, {
+                    bridgeContract: {
+                        publicKey: this.address,
+                        tokenId: this.tokenId,
+                    },
+                }),
+                hash: Poseidon.hash(MessageType.toFields(message)),
+            };
+        });
+    }
+    processMessage(batchIndex, args, isDummy) {
+        const results = this.executeProcessors(batchIndex, args);
+        const maxAccountUpdates = Math.max(0, ...results.map(({ result: { accountUpdates } }) => accountUpdates.length));
+        const AccountUpdateArray = Provable.Array(AccountUpdate, maxAccountUpdates);
+        const dummyMessageType = PROTOKIT_FIELD_PREFIXES.OUTGOING_MESSAGE_DUMMY_TYPE;
+        const argMessageType = Provable.if(isDummy, dummyMessageType, args.messageType);
+        const dummyAU = AccountUpdate.dummy();
+        const chosen = results
+            .map((a) => {
+            a.result.accountUpdates = a.result.accountUpdates.concat(...Array(maxAccountUpdates - a.result.accountUpdates.length).fill(dummyAU));
+            return a;
+        })
+            .concat({
+            messageType: dummyMessageType,
+            hash: Field(0),
+            result: {
+                accountUpdates: Array(maxAccountUpdates).fill(dummyAU),
+                status: Bool(true),
+                statusMessage: undefined,
+            },
+        })
+            .reduce((a, b) => {
+            const isA = a.messageType.equals(argMessageType);
+            const messageType = Provable.if(isA, a.messageType, b.messageType);
+            const hash = Provable.if(isA, a.hash, b.hash);
+            const accountUpdates = Provable.if(isA, AccountUpdateArray, a.result.accountUpdates, b.result.accountUpdates);
+            const status = Provable.if(isA, a.result.status, b.result.status);
+            let statusMessage = undefined;
+            Provable.asProver(() => {
+                if (isA.toBoolean()) {
+                    statusMessage = a.result.statusMessage;
+                }
+                else {
+                    statusMessage = b.result.statusMessage;
+                }
+            });
+            return {
+                messageType,
+                hash,
+                result: { accountUpdates, status, statusMessage },
+            };
+        });
+        // If no processor picks up our message type, the reduce above returns
+        // the first candidate. This statement asserts that this is not the case
+        chosen.messageType.assertEquals(argMessageType, "No processor found for message type");
+        return chosen;
+    }
+    async rollupOutgoingMessagesBase(batch) {
+        let counter = this.outgoingMessageCursor.getAndRequireEquals();
+        const stateRoot = this.stateRoot.getAndRequireEquals();
+        // Count account creation fee to return later, so that the sender can fund
+        // those accounts with a separate AU
+        let accountCreationFeePaid = Field(0);
+        for (let i = 0; i < this.batchSize(); i++) {
+            const args = batch.arguments[i];
+            const isDummy = batch.isDummys[i];
+            const message = this.processMessage(i, args, isDummy);
+            // Check witness
+            const path = Path.fromKey(PROTOKIT_FIELD_PREFIXES.OUTGOING_MESSAGE_BASE_PATH, OutgoingMessageKey, {
+                index: counter,
+                tokenId: this.tokenId,
+            });
+            args.witness
+                .checkMembership(stateRoot, path, message.hash)
+                .or(isDummy)
+                .assertTrue("Provided Withdrawal witness not valid");
+            message.result.status.assertTrue(message.result.statusMessage);
+            message.result.accountUpdates.forEach((accountUpdate) => {
+                Provable.log("Approving account update", accountUpdate.label);
+                this.approve(accountUpdate);
+            });
+            counter = counter.add(Provable.if(isDummy, Field(0), Field(1)));
+            // Track new accounts to be able to know how much new accounts to fund
+            const newAccounts = message.result.accountUpdates
+                .map((accountUpdate) => {
+                const isNew = accountUpdate.account.isNew.getAndRequireEquals();
+                return Provable.if(isNew, Field(1), Field(0));
+            })
+                .reduce((a, b) => a.add(b));
+            accountCreationFeePaid = accountCreationFeePaid.add(newAccounts);
+        }
+        this.outgoingMessageCursor.set(counter);
+        return accountCreationFeePaid;
+    }
+    async redeemBase(additionUpdate) {
+        additionUpdate.body.tokenId.assertEquals(this.tokenId, "Tokenid not same as this bridging contract's tokenId");
+        additionUpdate.body.balanceChange.sgn
+            .isPositive()
+            .assertTrue("Sign not correct");
+        const amount = additionUpdate.body.balanceChange.magnitude;
+        // Burn tokens
+        this.internal.burn({
+            address: additionUpdate.publicKey,
+            amount,
+        });
+        // Inherit from parent for custom tokens
+        additionUpdate.body.mayUseToken = {
+            inheritFromParent: this.tokenId.equals(TokenId.default).not(),
+            parentsOwnToken: Bool(false),
+        };
+        // Send mina
+        this.approve(additionUpdate);
+        this.balance.subInPlace(amount);
+    }
+}
+export class BridgeContract extends BridgeContractBase {
+    constructor() {
+        super(...arguments);
+        this.settlementContractAddress = State();
+        this.stateRoot = State();
+        this.outgoingMessageCursor = State();
+    }
+    async updateStateRoot(root) {
+        return await this.updateStateRootBase(root);
+    }
+    async rollupOutgoingMessages(batch) {
+        return await this.rollupOutgoingMessagesBase(batch);
+    }
+    async redeem(additionUpdate) {
+        return await this.redeemBase(additionUpdate);
+    }
+}
+__decorate([
+    state(PublicKey),
+    __metadata("design:type", Object)
+], BridgeContract.prototype, "settlementContractAddress", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], BridgeContract.prototype, "stateRoot", void 0);
+__decorate([
+    state(Field),
+    __metadata("design:type", Object)
+], BridgeContract.prototype, "outgoingMessageCursor", void 0);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Field]),
+    __metadata("design:returntype", Promise)
+], BridgeContract.prototype, "updateStateRoot", null);
+__decorate([
+    method.returns(Field),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [OutgoingMessageArgumentBatch]),
+    __metadata("design:returntype", Promise)
+], BridgeContract.prototype, "rollupOutgoingMessages", null);
+__decorate([
+    method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AccountUpdate]),
+    __metadata("design:returntype", Promise)
+], BridgeContract.prototype, "redeem", null);
+//# sourceMappingURL=BridgeContract.js.map