@indigo-labs/indigo-sdk 0.2.41 → 0.3.0

package/src/contracts/version-registry/scripts.ts

@@ -14,7 +14,7 @@ export function mkVersionRecordTokenPolicy(
   params: VersionRecordTokenParams,
 ): MintingPolicy {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: applyParamsToScript(_versionRecordTokenPolicy.cborHex, [
       castVersionRecordTokenParams(params),
     ]),
@@ -23,7 +23,7 @@ export function mkVersionRecordTokenPolicy(
 
 export const mkVersionRegistryValidator = (): SpendingValidator => {
   return {
-    type: 'PlutusV2',
+    type: 'PlutusV3',
     script: _versionRegistryValidator.cborHex,
   };
 };

package/src/contracts/version-registry/types-new.ts

@@ -1,18 +1,17 @@
-import { Core as EvoCore } from '@evolution-sdk/evolution';
+import { TSchema, Data } from '@evolution-sdk/evolution';
 import { DEFAULT_SCHEMA_OPTIONS } from '../../types/evolution-schema-options';
 
-const VersionRecordDatumSchema = EvoCore.TSchema.Struct({
-  upgradeId: EvoCore.TSchema.Integer,
+const VersionRecordDatumSchema = TSchema.Struct({
+  upgradeId: TSchema.Integer,
   /// Underlying representation of the following mapping: ValidatorHash -> UpgradePath
-  upgradePaths: EvoCore.TSchema.Map(
-    EvoCore.TSchema.ByteArray,
-    EvoCore.TSchema.ByteArray,
+  upgradePaths: TSchema.Array(
+    TSchema.Tuple([TSchema.ByteArray, TSchema.ByteArray]),
   ),
 });
 export type VersionRecordDatum = typeof VersionRecordDatumSchema.Type;
 
 export function serialiseVersionRecordDatum(d: VersionRecordDatum): string {
-  return EvoCore.Data.withSchema(
+  return Data.withSchema(
     VersionRecordDatumSchema,
     DEFAULT_SCHEMA_OPTIONS,
   ).toCBORHex(d);

package/src/index.ts

@@ -1,58 +1,75 @@
 export * from './contracts/cdp/transactions';
 export * from './contracts/cdp/helpers';
 export * from './contracts/cdp/types';
+export * from './contracts/cdp/types-new';
 export * from './contracts/cdp/scripts';
 export * from './contracts/cdp-creator/types';
 export * from './contracts/cdp-creator/scripts';
 export * from './contracts/poll/scripts';
 export * from './contracts/collector/transactions';
-export * from './contracts/collector/types';
+export * from './contracts/collector/types-new';
 export * from './contracts/gov/transactions';
 export * from './contracts/gov/types';
 export * from './contracts/gov/types-new';
 export * from './contracts/stability-pool/transactions';
-export * from './contracts/stability-pool/types-new';
-export * from './contracts/staking/helpers';
 export * from './contracts/staking/transactions';
-export * from './contracts/staking/types';
+export * from './contracts/staking/helpers';
 export * from './contracts/staking/types-new';
+export * from './contracts/staking/types';
 export * from './contracts/interest-oracle/transactions';
 export * from './contracts/interest-oracle/types';
-export * from './contracts/interest-oracle/scripts';
+export * from './contracts/interest-oracle/types-new';
 export * from './contracts/interest-oracle/helpers';
-export * from './contracts/price-oracle/transactions';
-export * from './contracts/price-oracle/types';
-export * from './contracts/price-oracle/helpers';
+export * from './contracts/interest-collection/helpers';
+export * from './contracts/interest-collection/types';
+export * from './contracts/interest-collection/types-new';
+export * from './contracts/interest-collection/scripts';
+export * from './contracts/interest-collection/transactions';
+export * from './contracts/interest-oracle/scripts';
 export * from './contracts/version-registry/types';
 export * from './contracts/version-registry/scripts';
 export * from './contracts/treasury/transactions';
-export * from './utils/lucid-utils';
+export * from './contracts/treasury/helpers';
 export * from './contracts/stability-pool/helpers';
 export * from './utils/time-helpers';
 export * from './contracts/cdp/scripts';
 export * from './contracts/collector/scripts';
 export * from './contracts/treasury/scripts';
-export * from './contracts/treasury/types';
 export * from './contracts/execute/types';
+export * from './contracts/execute/types-new';
 export * from './contracts/execute/scripts';
 export * from './contracts/price-oracle/types';
 export * from './contracts/stability-pool/types';
+export * from './contracts/stability-pool/types-new';
 export * from './contracts/poll/types-poll-shard';
 export * from './contracts/poll/types-poll-manager';
-export * from './contracts/poll/types-poll';
 export * from './types/generic';
+export * from './types/rational';
 export * from './types/system-params';
-export * from './contracts/lrp/helpers';
-export * from './contracts/lrp/transactions';
-export * from './contracts/lrp/scripts';
-export * from './contracts/lrp/types';
-export * from './utils/helper-txs';
+export * from './contracts/rob/helpers';
+export * from './contracts/rob/types';
+export * from './contracts/rob/types-new';
+export * from './contracts/rob/transactions';
+export * from './contracts/rob/scripts';
 export * from './contracts/one-shot/transactions';
+export * from './contracts/rob-leverage/transactions';
+export * from './contracts/rob-leverage/helpers';
+export * from './contracts/price-oracle/transactions';
+export * from './contracts/price-oracle/types';
+export * from './contracts/price-oracle/types-new';
+export * from './contracts/price-oracle/scripts';
 export * from './utils/utils';
 export * from './utils/array-utils';
-export * from './utils/value-helpers';
-export * from './contracts/leverage/transactions';
-export * from './contracts/leverage/helpers';
+export * from './utils/lucid-utils';
+export * from './utils/helper-txs';
+export * from './utils/bigint-utils';
 export * from './contracts/initialize/types';
 export * from './contracts/initialize/helpers';
-export * from './contracts/initialize/transactions';
+export * from './contracts/initialize/actions';
+export * from './utils/pyth';
+export * from './contracts/pyth-feed/types';
+export * from './contracts/pyth-feed/scripts';
+export * from './contracts/iasset/types';
+export * from './contracts/stableswap/helpers';
+export * from './contracts/stableswap/transactions';
+export * from './contracts/stableswap/types-new';

package/src/scripts/auth-token-policy.ts

@@ -1,10 +1,11 @@
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
 import {
   applyParamsToScript,
   Constr,
   MintingPolicy,
   ScriptType,
+  toHex,
 } from '@lucid-evolution/lucid';
-import { AssetClass } from '../types/generic';
 
 const authPolicyData = {
   type: 'PlutusV2' as ScriptType,
@@ -16,7 +17,7 @@ export function mkAuthTokenPolicy(ac: AssetClass, tn: string): MintingPolicy {
   return {
     type: authPolicyData.type,
     script: applyParamsToScript(authPolicyData.cborHex, [
-      new Constr(0, [ac.currencySymbol, ac.tokenName]),
+      new Constr(0, [toHex(ac.currencySymbol), toHex(ac.tokenName)]),
       tn,
     ]),
   };

package/src/scripts/iasset-policy.ts

@@ -1,10 +1,11 @@
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
 import {
   applyParamsToScript,
   Constr,
   MintingPolicy,
   ScriptType,
+  toHex,
 } from '@lucid-evolution/lucid';
-import { AssetClass } from '../types/generic';
 
 const iassetPolicyData = {
   type: 'PlutusV2' as ScriptType,
@@ -16,7 +17,7 @@ export function mkIAssetTokenPolicy(ac: AssetClass): MintingPolicy {
   return {
     type: iassetPolicyData.type,
     script: applyParamsToScript(iassetPolicyData.cborHex, [
-      new Constr(0, [ac.currencySymbol, ac.tokenName]),
+      new Constr(0, [toHex(ac.currencySymbol), toHex(ac.tokenName)]),
     ]),
   };
 }

package/src/types/evolution-schema-options.ts

@@ -1,6 +1,6 @@
-import { CodecOptions } from '@evolution-sdk/evolution/core/CBOR';
+import { CBOR } from '@evolution-sdk/evolution';
 
-/**
+/**`
  * This is related to our on-chain codebase for aiken v1.0.26-alpha
  */
 export const DEFAULT_SCHEMA_OPTIONS = {
@@ -13,4 +13,4 @@ export const DEFAULT_SCHEMA_OPTIONS = {
   useMinimalEncoding: true,
   mapsAsObjects: false,
   encodeMapAsPairs: false,
-} as const satisfies CodecOptions;
+} as const satisfies CBOR.CodecOptions;

package/src/types/generic.ts

@@ -1,24 +1,23 @@
-import {
-  credentialToAddress,
-  Data,
-  getAddressDetails,
-  Credential,
-  Network,
-} from '@lucid-evolution/lucid';
-import { match, P } from 'ts-pattern';
+import { AssetClass } from '@3rd-eye-labs/cardano-offchain-common';
+import { Data, fromHex, toHex, UTxO } from '@lucid-evolution/lucid';
 
 export const AssetClassSchema = Data.Object({
   currencySymbol: Data.Bytes(),
   /** Use the HEX encoding */
   tokenName: Data.Bytes(),
 });
-export type AssetClass = Data.Static<typeof AssetClassSchema>;
+export type AssetClassD = Data.Static<typeof AssetClassSchema>;
 
-export const OutputReferenceSchema = Data.Object({
-  txHash: Data.Object({ hash: Data.Bytes() }),
-  outputIndex: Data.Integer(),
-});
-export type OutputReference = Data.Static<typeof OutputReferenceSchema>;
+export function toAssetClassFromLucid(asset: AssetClassD): AssetClass {
+  return {
+    currencySymbol: fromHex(asset.currencySymbol),
+    tokenName: fromHex(asset.tokenName),
+  };
+}
+
+export function getAssetClassComparisonStr(asset: AssetClass): string {
+  return `${toHex(asset.currencySymbol)}${toHex(asset.tokenName)}`;
+}
 
 export const VerificationKeyHashSchema = Data.Bytes();
 
@@ -46,79 +45,8 @@ export const StakeCredentialSchema = Data.Enum([
   }),
 ]);
 
-export const AddressSchema = Data.Object({
-  paymentCredential: CredentialSchema,
-  stakeCredential: Data.Nullable(StakeCredentialSchema),
-});
-export type AddressD = Data.Static<typeof AddressSchema>;
-export const AddressD = AddressSchema as unknown as AddressD;
-
-export function addressToBech32(address: AddressD, network: Network): string {
-  const matchCred = (cred: CredentialD) =>
-    match(cred)
-      .returnType<Credential>()
-      .with({ PublicKeyCredential: [P.select()] }, (pkh) => {
-        return { type: 'Key', hash: pkh };
-      })
-      .with({ ScriptCredential: [P.select()] }, (scriptCred) => {
-        return { type: 'Script', hash: scriptCred };
-      })
-      .exhaustive();
-
-  const stakeCred: Credential | undefined = match(address.stakeCredential)
-    .returnType<Credential | undefined>()
-    .with(P.nullish, () => undefined)
-    .with({ Inline: [P.select()] }, (cred) => matchCred(cred))
-    .otherwise(() => {
-      throw new Error('Unexpected stake credential format.');
-    });
+export type StakeCredential = Data.Static<typeof StakeCredentialSchema>;
+export const StakeCredential =
+  StakeCredentialSchema as unknown as StakeCredential;
 
-  const cred: Credential = matchCred(address.paymentCredential);
-
-  return credentialToAddress(network, cred, stakeCred);
-}
-
-export function addressFromBech32(address: string): AddressD {
-  const details = getAddressDetails(address);
-
-  const matchCred = (cred: Credential): CredentialD => {
-    return match(cred)
-      .returnType<CredentialD>()
-      .with({ type: 'Key', hash: P.select() }, (pkh) => {
-        return {
-          PublicKeyCredential: [pkh],
-        };
-      })
-      .with({ type: 'Script', hash: P.select() }, (scriptHash) => ({
-        ScriptCredential: [scriptHash],
-      }))
-      .exhaustive();
-  };
-
-  return match(details)
-    .returnType<AddressD>()
-    .with(
-      { paymentCredential: P.nullish },
-      { type: P.not(P.union('Base', 'Enterprise')) },
-      (_) => {
-        throw new Error('Invalid address provided');
-      },
-    )
-    .narrow()
-    .otherwise((details) => ({
-      paymentCredential: matchCred(details.paymentCredential),
-      stakeCredential: details.stakeCredential
-        ? {
-            Inline: [matchCred(details.stakeCredential)],
-          }
-        : null,
-    }));
-}
-
-export interface CurrencySymbol {
-  unCurrencySymbol: string;
-}
-
-export interface TokenName {
-  unTokenName: string;
-}
+export type ParsedOutput<T> = { utxo: UTxO; datum: T };

package/src/types/multisig.ts

@@ -0,0 +1,48 @@
+import { TSchema, Data } from '@evolution-sdk/evolution';
+import { Schema } from 'effect';
+
+const OpaqueData = Schema.typeSchema(Data.DataSchema);
+
+export const MultisigSchema = TSchema.Union(
+  TSchema.Struct(
+    {
+      Signature: TSchema.Struct(
+        {
+          keyHash: TSchema.ByteArray,
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+  TSchema.Struct(
+    {
+      AtLeast: TSchema.Struct(
+        {
+          required: TSchema.Integer,
+          authSignatories: TSchema.Array(OpaqueData),
+        },
+        { flatFields: true },
+      ),
+    },
+    { flatInUnion: true },
+  ),
+);
+
+export type Multisig = typeof MultisigSchema.Type;
+
+export function parseMultisig(datum: string): Multisig {
+  return Data.withSchema(MultisigSchema).fromCBORHex(datum);
+}
+
+export function fromDataMultisig(data: Data.Data): Multisig {
+  return Data.withSchema(MultisigSchema).fromCBORHex(Data.toCBORHex(data));
+}
+
+export function toDataMultisig(data: Multisig): Data.Data {
+  return Data.withSchema(MultisigSchema).toData(data);
+}
+
+export function serialiseMultisig(datum: Multisig): string {
+  return Data.withSchema(MultisigSchema).toCBORHex(datum);
+}

package/src/types/on-chain-decimal.ts

@@ -1,12 +1,13 @@
-import { Data } from '@lucid-evolution/lucid';
+import { TSchema } from '@evolution-sdk/evolution';
+import { divideOnChainCompatible } from '../utils/bigint-utils';
 
 export const OCD_DECIMAL_UNIT: bigint = 1_000_000n;
 
-export const OnChainDecimalSchema = Data.Object({
-  getOnChainInt: Data.Integer(),
+export const OnChainDecimalSchema = TSchema.Struct({
+  getOnChainInt: TSchema.Integer,
 });
-export type OnChainDecimal = Data.Static<typeof OnChainDecimalSchema>;
-export const OnChainDecimal = OnChainDecimalSchema as unknown as OnChainDecimal;
+
+export type OnChainDecimal = typeof OnChainDecimalSchema.Type;
 
 export function ocdCeil(a: OnChainDecimal): bigint {
   const whole = a.getOnChainInt / OCD_DECIMAL_UNIT;
@@ -24,13 +25,19 @@ export function ocdNegate(a: OnChainDecimal): OnChainDecimal {
 
 export function ocdMul(a: OnChainDecimal, b: OnChainDecimal): OnChainDecimal {
   return {
-    getOnChainInt: (a.getOnChainInt * b.getOnChainInt) / OCD_DECIMAL_UNIT,
+    getOnChainInt: divideOnChainCompatible(
+      a.getOnChainInt * b.getOnChainInt,
+      OCD_DECIMAL_UNIT,
+    ),
   };
 }
 
 export function ocdDiv(a: OnChainDecimal, b: OnChainDecimal): OnChainDecimal {
   return {
-    getOnChainInt: (a.getOnChainInt * OCD_DECIMAL_UNIT) / b.getOnChainInt,
+    getOnChainInt: divideOnChainCompatible(
+      a.getOnChainInt * OCD_DECIMAL_UNIT,
+      b.getOnChainInt,
+    ),
   };
 }
 

package/src/types/rational.ts

@@ -0,0 +1,61 @@
+import { TSchema } from '@evolution-sdk/evolution';
+import { divideOnChainCompatible } from '../utils/bigint-utils';
+
+export const RationalSchema = TSchema.Struct({
+  numerator: TSchema.Integer,
+  denominator: TSchema.Integer,
+});
+
+export type Rational = typeof RationalSchema.Type;
+
+export const rationalZero: Rational = { numerator: 0n, denominator: 1n };
+
+export function rationalFromInt(a: bigint): Rational {
+  return { numerator: a, denominator: 1n };
+}
+
+export function rationalFloor(a: Rational): bigint {
+  return divideOnChainCompatible(a.numerator, a.denominator);
+}
+
+export function rationalCeil(a: Rational): bigint {
+  const intDiv = a.numerator / a.denominator;
+  return a.numerator % a.denominator > 0n ? intDiv + 1n : intDiv;
+}
+
+export function rationalNegate(a: Rational): Rational {
+  return { numerator: -a.numerator, denominator: a.denominator };
+}
+
+export function rationalAdd(a: Rational, b: Rational): Rational {
+  return {
+    numerator: a.numerator * b.denominator + b.numerator * a.denominator,
+    denominator: a.denominator * b.denominator,
+  };
+}
+
+export function rationalSub(a: Rational, b: Rational): Rational {
+  return {
+    numerator: a.numerator * b.denominator - b.numerator * a.denominator,
+    denominator: a.denominator * b.denominator,
+  };
+}
+
+export function rationalMul(a: Rational, b: Rational): Rational {
+  return {
+    numerator: a.numerator * b.numerator,
+    denominator: a.denominator * b.denominator,
+  };
+}
+
+export function rationalDiv(a: Rational, b: Rational): Rational {
+  if (b.numerator === 0n) throw new Error('Cannot divide by zero.');
+  return {
+    numerator: a.numerator * b.denominator,
+    denominator: a.denominator * b.numerator,
+  };
+}
+
+export function rationalToFloat(a: Rational): number {
+  return Number(a.numerator) / Number(a.denominator);
+}